Wrap block-informations when embedding them in the graph.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String buildJavaScriptFunction(FunctionElement element,
@@ skipping 563 matching lines @@
       addIndented("}");
       if (info.elseGraph !== null) {
         buffer.add(" else {\n");
         indent++;
         generateStatements(info.elseGraph);
         indent--;
         addIndented("}");
       }
       buffer.add("\n");
     }
-    if (info.joinBlock !== null) {
-      visitBasicBlock(info.joinBlock);
-    }
     return true;
   }
 
+  bool visitSequenceInfo(HStatementSequenceInformation info) {
+    return false;
+  }
+
   bool visitSubGraphInfo(HSubGraphBlockInformation info) {
     visitSubGraph(info.subGraph);
     // A [HSubGraphBlockInformation] is always part of another block
     // information structure, so it doesn't have a joinBlock.
   }
 
   bool visitSubExpressionInfo(HSubExpressionBlockInformation info) {
     return false;
   }
 
@@ skipping 20 matching lines @@
       addIndented('}');
     }
     if (info.finallyBlock != null) {
       buffer.add(" finally {\n");
       indent++;
       generateStatements(info.finallyBlock);
       indent--;
       addIndented("}");
     }
     buffer.add("\n");
-    visitBasicBlock(info.joinBlock);
     return true;
   }
 
-  bool visitLoopInfo(HLoopInformation info) {
-    // We must look at the loop information only once, when visiting the
-    // initializer. After that, the initializer has been generated.
-    // The same block information is also put on the condition-block for
-    // the traditional code generation.
-    bool isInitializerBlock = (currentBlock !== info.header);
-    if (!isInitializerBlock && info.kind != HLoopInformation.DO_WHILE_LOOP) {
-      return false;
-    }
-
+  bool visitLoopInfo(HLoopBlockInformation info) {
     HExpressionInformation condition = info.condition;
     bool isConditionExpression = isJSCondition(condition);
 
     void visitBodyIgnoreLabels() {
       if (info.body.start.isLabeledBlock()) {
         HBlockInformation oldInfo = currentBlockInformation;
-        currentBlockInformation = info.body.start.blockInformation;
+        currentBlockInformation = info.body.start.blockInformation.body;
         generateStatements(info.body);
         currentBlockInformation = oldInfo;
       } else {
         generateStatements(info.body);
       }
     }
 
     switch (info.kind) {
       // Treate all three "test-first" loops the same way.
-      case HLoopInformation.FOR_LOOP:
-      case HLoopInformation.WHILE_LOOP:
-      case HLoopInformation.FOR_IN_LOOP: {
+      case HLoopBlockInformation.FOR_LOOP:
+      case HLoopBlockInformation.WHILE_LOOP:
+      case HLoopBlockInformation.FOR_IN_LOOP: {
         HBlockInformation initialization = info.initializer;
         int initializationType = TYPE_STATEMENT;
         if (initialization !== null) {
           initializationType = expressionType(initialization);
           if (initializationType == TYPE_STATEMENT) {
             generateStatements(initialization);
             initialization = null;
           }
         }
         for (LabelElement label in info.labels) {
@@ skipping 50 matching lines @@
             wrapLoopBodyForContinue(info);
             generateStatements(info.updates);
           } else {
             visitBodyIgnoreLabels();
           }
           indent--;
         }
         addIndented("}\n");
         break;
       }
-      case HLoopInformation.DO_WHILE_LOOP: {
+      case HLoopBlockInformation.DO_WHILE_LOOP: {
         // Generate do-while loop in all cases.
         if (info.initializer !== null) {
           generateStatements(info.initializer);
         }
         addIndentation();
         for (LabelElement label in info.labels) {
           if (label.isTarget) {
             writeLabel(label);
             buffer.add(":");
           }
@@ skipping 20 matching lines @@
           use(condition.conditionExpression, JSPrecedence.PREFIX_PRECEDENCE);
           buffer.add(");\n");
         }
         break;
       }
       default:
         compiler.internalError(
           'Unexpected loop kind: ${info.kind}',
           instruction: condition.conditionExpression);
     }
-    visitBasicBlock(info.joinBlock);
     return true;
   }
 
   bool visitLabeledBlockInfo(HLabeledBlockInformation labeledBlockInfo) {
     preLabeledBlock(labeledBlockInfo);
     addIndentation();
     Link<Element> continueOverrides = const EmptyLink<Element>();
     // If [labeledBlockInfo.isContinue], the block is an artificial
     // block around the body of a loop with an update block, so that
     // continues of the loop can be written as breaks of the body
@@ skipping 35 matching lines @@
     buffer.add('{\n');
     indent++;
 
     startLabeledBlock(labeledBlockInfo);
     generateStatements(labeledBlockInfo.body);
     endLabeledBlock(labeledBlockInfo);
 
     indent--;
     addIndented('}\n');
 
-    if (labeledBlockInfo.joinBlock !== null) {
-      visitBasicBlock(labeledBlockInfo.joinBlock);
-    }
     if (labeledBlockInfo.isContinue) {
       while (!continueOverrides.isEmpty()) {
         continueAction.remove(continueOverrides.head);
         continueOverrides = continueOverrides.tail;
       }
     } else {
       breakAction.remove(labeledBlockInfo.target);
     }
     return true;
   }
 
   void emitLogicalOperation(HPhi node, String operation) {
     JSBinaryOperatorPrecedence operatorPrecedence =
         JSPrecedence.binary[operation];
     beginExpression(operatorPrecedence.precedence);
     use(node.inputs[0], operatorPrecedence.left);
     buffer.add(" $operation ");
     use(node.inputs[1], operatorPrecedence.right);
     endExpression(operatorPrecedence.precedence);
   }
 
   // Wraps a loop body in a block to make continues have a target to break
   // to (if necessary).
-  void wrapLoopBodyForContinue(HLoopInformation info) {
+  void wrapLoopBodyForContinue(HLoopBlockInformation info) {
     TargetElement target = info.target;
     if (target !== null && target.isContinueTarget) {
       addIndentation();
       for (LabelElement label in info.labels) {
         if (label.isContinueTarget) {
           writeContinueLabel(label);
           buffer.add(":");
           continueAction[label] = continueAsBreak;
         }
       }
       writeImplicitContinueLabel(target);
       buffer.add(":{\n");
       continueAction[info.target] = implicitContinueAsBreak;
       indent++;
       generateStatements(info.body);
       indent--;
       addIndented("}\n");
       continueAction.remove(info.target);
       for (LabelElement label in info.labels) {
         if (label.isContinueTarget) {
           continueAction.remove(label);
         }
       }
     } else {
       // Loop body contains no continues, so we don't need a break target.
       generateStatements(info.body);
     }
   }
 
+  bool handleBlockInfo(HBlockFlow block) {
+    HBlockInformation info = block.body;
+    // If we reach here again while handling the attached information,
+    // e.g., because we call visitSubGraph on a subgraph starting on
+    // the same block, don't handle it again.
+    // When the structure graph is complete, we will be able to have
+    // different structures starting on the same basic block (e.g., an
+    // "if" and its condition).
+    if (info === currentBlockInformation) return false;
+
+    HBlockInformation oldBlockInformation = currentBlockInformation;
+    currentBlockInformation = info;
+    bool success = info.accept(this);
+    currentBlockInformation = oldBlockInformation;
+    if (success) {
+      HBasicBlock continuation = block.continuation;
+      if (continuation !== null) {
+        visitBasicBlock(continuation);
+      }
+    }
+    return success;
+  }
+
   void visitBasicBlock(HBasicBlock node) {
     // Abort traversal if we are leaving the currently active sub-graph.
     if (!subGraph.contains(node)) return;
 
     currentBlock = node;
-    // If this node has special behavior attached, handle it.
-    // If we reach here again while handling the attached information,
-    // e.g., because we call visitSubGraph on a subgraph starting here,
-    // don't handle it again.
+    // If this node has block-structure based information attached,
+    // try using that to traverse from here.
     if (node.blockInformation !== null &&
-        node.blockInformation !== currentBlockInformation) {
-      HBlockInformation oldBlockInformation = currentBlockInformation;
-      currentBlockInformation = node.blockInformation;
-      bool success = currentBlockInformation.accept(this);
-      currentBlockInformation = oldBlockInformation;
-      if (success) return;
-
-      // If our special handling didn't succeed, we have to emit a generic
-      // version. This still requires special handling for loop-blocks
-      if (node.isLoopHeader()) {
-        beginLoop(node);
-      }
+        handleBlockInfo(node.blockInformation)) {
+      return;
+    }
+    // Flow based traversal.
+    if (node.isLoopHeader() &&
+        node.loopInformation.loopBlockInformation !== currentBlockInformation) {
+      beginLoop(node);
     }
     iterateBasicBlock(node);
   }
 
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (instruction != null) {
       if (instruction === node.last) {
         for (HBasicBlock successor in node.successors) {
           int index = successor.predecessors.indexOf(node);
@@ skipping 21 matching lines @@
             }
             if (!temporaryExists(canonicalPhi)) {
               declareVariable(temporary(canonicalPhi));
             } else {
               buffer.add(temporary(canonicalPhi));
             }
             buffer.add(" = ");
             if (isLogicalOperation) {
               emitLogicalOperation(phi, logicalOperations[phi]);
             } else {
-              use(phi.inputs[index], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+              use(input, JSPrecedence.ASSIGNMENT_PRECEDENCE);
             }
             if (!isGeneratingExpression()) {
               buffer.add(';\n');
             }
           });
         }
       }
 
       if (instruction is HGoto || instruction is HExit || instruction is HTry) {
         visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
@@ skipping 209 matching lines @@
   visitIf(HIf node) {
     if (subGraph !== null && node.block === subGraph.end) {
       if (isGeneratingExpression()) {
         use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       }
       return;
     }
     HInstruction condition = node.inputs[0];
     int preVisitedBlocks = 0;
     List<HBasicBlock> dominated = node.block.dominatedBlocks;
-    HIfBlockInformation info = node.blockInformation;
+    HIfBlockInformation info = node.blockInformation.body;
     if (condition.isConstant()) {
       HConstant constant = condition;
       if (constant.constant.isTrue()) {
         generateStatements(info.thenGraph);
       } else if (node.hasElse) {
         generateStatements(info.elseGraph);
       }
       // We ignore the other branch, even if it isn't visited.
       preVisitedBlocks = node.hasElse ? 2 : 1;
     } else {
       startIf(node);
       assert(!isGenerateAtUseSite(node));
       startThen(node);
       assert(node.thenBlock === dominated[0]);
       generateStatements(info.thenGraph);
       preVisitedBlocks++;
       endThen(node);
       if (node.hasElse) {
         startElse(node);
         assert(node.elseBlock === dominated[1]);
         generateStatements(info.elseGraph);
         preVisitedBlocks++;
         endElse(node);
       }
       endIf(node);
     }
-    if (info.joinBlock !== null && info.joinBlock.dominator !== node.block) {
+    HBasicBlock joinBlock = node.joinBlock;
+    if (joinBlock !== null && joinBlock.dominator !== node.block) {
       // The join block is dominated by a block in one of the branches.
       // The subgraph traversal never reached it, so we visit it here
       // instead.
-      visitBasicBlock(info.joinBlock);
+      visitBasicBlock(joinBlock);
     }
 
     // Visit all the dominated blocks that are not part of the then or else
     // branches, and is not the join block.
     // Depending on how the then/else branches terminate
     // (e.g., return/throw/break) there can be any number of these.
     int dominatedCount = dominated.length;
     for (int i = preVisitedBlocks; i < dominatedCount; i++) {
       HBasicBlock dominatedBlock = dominated[i];
       assert(dominatedBlock.dominator === node.block);
@@ skipping 781 matching lines @@
       buffer.add(')) ');
       bailout(node, 'Not a string or array');
     } else {
       unreachable();
     }
     buffer.add(';\n');
   }
 
   void beginLoop(HBasicBlock block) {
     addIndentation();
-    HLoopInformation info = block.blockInformation;
+    HLoopInformation info = block.loopInformation;
     for (LabelElement label in info.labels) {
       writeLabel(label);
       buffer.add(":");
     }
     buffer.add('while (true) {\n');
     indent++;
   }
 
   void endLoop(HBasicBlock block) {
     indent--;
@@ skipping 103 matching lines @@
     } else if (argument is HTypeGuard) {
       HTypeGuard instruction = argument;
       return unwrap(instruction.guarded);
     } else {
       return argument;
     }
   }
 
   bool visitAndOrInfo(HAndOrBlockInformation info) => false;
   bool visitIfInfo(HIfBlockInformation info) => false;
-  bool visitLoopInfo(HLoopInformation info) => false;
+  bool visitLoopInfo(HLoopBlockInformation info) => false;
   bool visitTryInfo(HTryBlockInformation info) => false;
-
+  bool visitSequenceInfo(HStatementSequenceInformation info) => false;
 
   void visitTypeGuard(HTypeGuard node) {
     indent--;
     addIndented('case ${node.state}:\n');
     indent++;
     addIndented('state = 0;\n');
 
     setup.add('    case ${node.state}:\n');
     int i = 0;
     for (HInstruction input in node.inputs) {
@@ skipping 33 matching lines @@
   }
 
   void beginLoop(HBasicBlock block) {
     // TODO(ngeoffray): Don't put labels on loops that don't bailout.
     String newLabel = pushLabel();
     if (block.hasGuards()) {
       startBailoutCase(block.guards, const <HTypeGuard>[]);
     }
 
     addIndentation();
-    HLoopInformation loopInformation = block.blockInformation;
+    HLoopInformation loopInformation = block.loopInformation;
     for (LabelElement label in loopInformation.labels) {
       writeLabel(label);
       buffer.add(":");
     }
     buffer.add('$newLabel: while (true) {\n');
     indent++;
 
     if (block.hasGuards()) {
       startBailoutSwitch();
       if (loopInformation.target !== null) {
         breakAction[loopInformation.target] = (TargetElement target) {
           addIndented("break $newLabel;\n");
         };
       }
     }
   }
 
   void endLoop(HBasicBlock block) {
     popLabel();
     HBasicBlock header = block.isLoopHeader() ? block : block.parentLoopHeader;
     if (header.hasGuards()) {
       endBailoutSwitch();
-      HLoopInformation info = header.blockInformation;
+      HLoopInformation info = header.loopInformation;
       if (info.target != null) breakAction.remove(info.target);
     }
     indent--;
     addIndented('}\n');  // Close 'while'.
   }
 
   void handleLoopCondition(HLoopBranch node) {
     buffer.add('if (!');
     use(node.inputs[0], JSPrecedence.PREFIX_PRECEDENCE);
     buffer.add(') break ${currentLabel()};\n');
@@ skipping 73 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }