Refactoring to prepare for kernel based jump targets

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 591 matching lines @@
     constructor.function.namedParameters.toList()
       ..sort(namedOrdering)
       ..forEach(handleParameter);
 
     // Set the locals handler state as if we were inlining the constructor.
     ConstructorEntity astElement = _elementMap.getConstructor(constructor);
     ClosureRepresentationInfo oldClosureData = localsHandler.closureData;
     ClosureRepresentationInfo newClosureData =
         closureDataLookup.getClosureRepresentationInfo(astElement);
     if (astElement is ConstructorElement) {
-      // TODO(johnniwinther): Support constructor (body) entities.
+      // TODO(redemption): Support constructor (body) entities.
       ResolvedAst resolvedAst = astElement.resolvedAst;
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(
             closureDataLookup.getClosureAnalysisInfo(resolvedAst.node),
             forGenerativeConstructorBody:
                 astElement.isGenerativeConstructorBody);
       }
     }
     inlinedFrom(astElement, () {
@@ skipping 29 matching lines @@
       if (!backend.operatorEqHandlesNullArgument(method)) {
         handleIf(
           visitCondition: () {
             HParameterValue parameter = parameters.values.first;
             push(new HIdentity(parameter, graph.addConstantNull(closedWorld),
                 null, commonMasks.boolType));
           },
           visitThen: () {
             closeAndGotoExit(new HReturn(
                 graph.addConstantBool(false, closedWorld),
-                // TODO(johnniwinther): Provider source information like
+                // TODO(redemption): Provider source information like
                 // `sourceInformationBuilder.buildImplicitReturn(method)`.
                 null));
           },
           visitElse: null,
           // TODO(27394): Add sourceInformation via
           // `sourceInformationBuilder.buildIf(?)`.
         );
       }
     }
     functionNode.body.accept(this);
@@ skipping 231 matching lines @@
     }
 
     void buildBody() {
       forStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
         forStatement,
         localsMap.getClosureRepresentationInfoForLoop(
             closureDataLookup, forStatement),
+        localsMap.getJumpTargetForFor(forStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
       _buildAsyncForIn(forInStatement);
@@ skipping 109 matching lines @@
       HInstruction addInstruction =
           new HAdd(index, one, null, commonMasks.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
     }
 
     loopHandler.handleLoop(
         forInStatement,
         localsMap.getClosureRepresentationInfoForLoop(
             closureDataLookup, forInStatement),
+        localsMap.getJumpTargetForForIn(forInStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   _buildForInIterator(ir.ForInStatement forInStatement) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
@@ skipping 31 matching lines @@
       if (loopVariableLocal is! SyntheticLocal) {
         value.sourceElement ??= loopVariableLocal;
       }
       forInStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
         forInStatement,
         localsMap.getClosureRepresentationInfoForLoop(
             closureDataLookup, forInStatement),
+        localsMap.getJumpTargetForForIn(forInStatement),
         buildInitializer,
         buildCondition,
         () {},
         buildBody);
   }
 
   void _buildAsyncForIn(ir.ForInStatement forInStatement) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
@@ skipping 27 matching lines @@
 
     void buildUpdate() {}
 
     // Creates a synthetic try/finally block in case anything async goes amiss.
     TryCatchFinallyBuilder tryBuilder = new TryCatchFinallyBuilder(this);
     // Build fake try body:
     loopHandler.handleLoop(
         forInStatement,
         localsMap.getClosureRepresentationInfoForLoop(
             closureDataLookup, forInStatement),
+        localsMap.getJumpTargetForForIn(forInStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
 
     void finalizerFunction() {
       _pushDynamicInvocation(forInStatement, null, [streamIterator],
           selector: Selectors.cancel);
       add(new HAwait(pop(), closedWorld.commonMasks.dynamicType));
     }
@@ skipping 31 matching lines @@
     assert(isReachable);
     HInstruction buildCondition() {
       whileStatement.condition.accept(this);
       return popBoolified();
     }
 
     loopHandler.handleLoop(
         whileStatement,
         localsMap.getClosureRepresentationInfoForLoop(
             closureDataLookup, whileStatement),
+        localsMap.getJumpTargetForWhile(whileStatement),
         () {},
         buildCondition,
         () {}, () {
       whileStatement.body.accept(this);
     });
   }
 
   @override
   visitDoStatement(ir.DoStatement doStatement) {
     // TODO(efortuna): I think this can be rewritten using
     // LoopHandler.handleLoop with some tricks about when the "update" happens.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     LoopClosureRepresentationInfo loopClosureInfo = localsMap
         .getClosureRepresentationInfoForLoop(closureDataLookup, doStatement);
     localsHandler.startLoop(loopClosureInfo);
-    JumpHandler jumpHandler = loopHandler.beginLoopHeader(doStatement);
+    JumpTarget target = localsMap.getJumpTargetForDo(doStatement);
+    JumpHandler jumpHandler = loopHandler.beginLoopHeader(doStatement, target);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
-    JumpTarget target = localsMap.getJumpTarget(doStatement);
     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 75 matching lines @@
       loopEntryBlock.postProcessLoopHeader();
       SubGraph bodyGraph = new SubGraph(loopEntryBlock, bodyExitBlock);
       HLoopBlockInformation loopBlockInfo = new HLoopBlockInformation(
           HLoopBlockInformation.DO_WHILE_LOOP,
           null,
           wrapExpressionGraph(conditionExpression),
           wrapStatementGraph(bodyGraph),
           null,
           loopEntryBlock.loopInformation.target,
           loopEntryBlock.loopInformation.labels,
-          // TODO(johnniwinther): Provide source information like:
+          // TODO(redemption): Provide source information like:
           // sourceInformationBuilder.buildLoop(astAdapter.getNode(doStatement))
           null);
       loopEntryBlock.setBlockFlow(loopBlockInfo, current);
       loopInfo.loopBlockInformation = loopBlockInfo;
     } else {
       // Since the loop has no back edge, we remove the loop information on the
       // header.
       loopEntryBlock.loopInformation = null;
 
       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 = localsMap.getJumpTarget(doStatement);
-        LabelDefinition label = target.addLabel(null, 'loop');
-        label.setBreakTarget();
+        JumpTarget target = localsMap.getJumpTargetForDo(doStatement);
+        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 101 matching lines @@
     handleIf(visitCondition: buildCondition, visitThen: fail);
   }
 
   /// 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(ir.TreeNode node, {bool isLoopJump: false}) {
-    JumpTarget target = localsMap.getJumpTarget(node);
+  JumpHandler createJumpHandler(ir.TreeNode node, JumpTarget target,
+      {bool isLoopJump: false}) {
     if (target == null) {
       // No breaks or continues to this node.
       return new NullJumpHandler(reporter);
     }
     if (isLoopJump && node is ir.SwitchStatement) {
       return new KernelSwitchCaseJumpHandler(this, target, node, localsMap);
     }
 
     return new JumpHandler(this, target);
   }
 
   @override
   void visitBreakStatement(ir.BreakStatement breakStatement) {
     assert(!isAborted());
     handleInTryStatement();
-    JumpTarget target = localsMap.getJumpTarget(breakStatement.target);
+    JumpTarget target = localsMap.getJumpTargetForBreak(breakStatement);
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (handler.labels.isNotEmpty) {
       handler.generateBreak(handler.labels.first);
     } else {
       handler.generateBreak();
     }
   }
 
   @override
   void visitLabeledStatement(ir.LabeledStatement labeledStatement) {
     ir.Statement body = labeledStatement.body;
     if (body is ir.WhileStatement ||
         body is ir.DoStatement ||
         body is ir.ForStatement ||
         body is ir.ForInStatement ||
         body is ir.SwitchStatement) {
       // loops and switches handle breaks on their own
       body.accept(this);
       return;
     }
-    JumpHandler handler = createJumpHandler(labeledStatement);
+    JumpHandler handler = createJumpHandler(
+        labeledStatement, localsMap.getJumpTargetForLabel(labeledStatement));
 
     LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
 
     HBasicBlock newBlock = openNewBlock();
     body.accept(this);
     SubGraph bodyGraph = new SubGraph(newBlock, lastOpenedBlock);
 
     HBasicBlock joinBlock = graph.addNewBlock();
     List<LocalsHandler> breakHandlers = <LocalsHandler>[];
     handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
@@ skipping 29 matching lines @@
         constants[caseExpression] = constant;
       }
     }
     return constants;
   }
 
   @override
   void visitContinueSwitchStatement(
       ir.ContinueSwitchStatement switchStatement) {
     handleInTryStatement();
-    JumpTarget target = localsMap.getJumpTarget(switchStatement.target);
+    JumpTarget target =
+        localsMap.getJumpTargetForContinueSwitch(switchStatement);
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     assert(target.labels.isNotEmpty);
     handler.generateContinue(target.labels.first);
   }
 
   @override
   void visitSwitchStatement(ir.SwitchStatement switchStatement) {
     // The switch case indices must match those computed in
     // [KernelSwitchCaseJumpHandler].
     bool hasContinue = false;
     Map<ir.SwitchCase, int> caseIndex = new Map<ir.SwitchCase, int>();
     int switchIndex = 1;
     bool hasDefault = false;
     for (ir.SwitchCase switchCase in switchStatement.cases) {
       if (_isDefaultCase(switchCase)) {
         hasDefault = true;
       }
       if (SwitchContinueAnalysis.containsContinue(switchCase.body)) {
         hasContinue = true;
       }
       caseIndex[switchCase] = switchIndex;
       switchIndex++;
     }
 
-    JumpHandler jumpHandler = createJumpHandler(switchStatement);
+    JumpHandler jumpHandler = createJumpHandler(
+        switchStatement, localsMap.getJumpTargetForSwitch(switchStatement));
     if (!hasContinue) {
       // If the switch statement has no switch cases targeted by continue
       // statements we encode the switch statement directly.
       _buildSimpleSwitchStatement(switchStatement, jumpHandler);
     } else {
       _buildComplexSwitchStatement(
           switchStatement, jumpHandler, caseIndex, hasDefault);
     }
   }
 
@@ skipping 72 matching lines @@
     //       case 1: s_1; break l;
     //       case 2: s_2; target = i; continue l;
     //       ...
     //       case n: s_n; target = j; continue l;
     //     }
     //   }
     //
     // This is because JS does not have this same "continue label" semantics so
     // we encode it in the form of a state machine.
 
-    JumpTarget switchTarget = localsMap.getJumpTarget(switchStatement);
+    JumpTarget switchTarget = localsMap.getJumpTargetForSwitch(switchStatement);
     localsHandler.updateLocal(switchTarget, graph.addConstantNull(closedWorld));
 
     var switchCases = switchStatement.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 = new List<ir.SwitchCase>.from(switchCases);
       switchCases.add(null);
     }
@@ skipping 48 matching lines @@
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
       loopHandler.handleLoop(
           switchStatement,
           localsMap.getClosureRepresentationInfoForLoop(
               closureDataLookup, switchStatement),
+          switchTarget,
           () {},
           buildCondition,
           () {},
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
@@ skipping 1749 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }