Generate prettier loops.

frog/leg/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 121 matching lines @@
     blocks.add(block);
     assert(blocks[id] === block);
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock result = new HBasicBlock();
     addBlock(result);
     return result;
   }
 
-  HBasicBlock addNewLoopHeaderBlock(List<LabelElement> labels) {
+  HBasicBlock addNewLoopHeaderBlock(int type,
+                                    TargetElement target,
+                                    List<LabelElement> labels) {
     HBasicBlock result = addNewBlock();
-    result.loopInformation = new HLoopInformation(result, labels);
+    result.loopInformation = new HLoopInformation(type, result, target, labels);
     return result;
   }
 
   static HType mapConstantTypeToSsaType(Constant constant) {
     if (constant.isNull()) return HType.UNKNOWN;
     if (constant.isBool()) return HType.BOOLEAN;
     if (constant.isInt()) return HType.INTEGER;
     if (constant.isDouble()) return HType.DOUBLE;
     if (constant.isString()) return HType.STRING;
     if (constant.isList()) return HType.ARRAY;
@@ skipping 160 matching lines @@
   const SubGraph(this.start, this.end);
 
   bool contains(HBasicBlock block) {
     assert(start !== null);
     assert(end !== null);
     assert(block !== null);
     return start.id <= block.id && block.id <= end.id;
   }
 }
 
+class SubExpression extends SubGraph {
+  final HInstruction expression;
+  const SubExpression(HBasicBlock start, HBasicBlock end, this.expression)
+      : super(start, end);
+}
+
 class HInstructionList {
   HInstruction first = null;
   HInstruction last = null;
 
   bool isEmpty() {
     return first === null;
   }
 
   void addAfter(HInstruction cursor, HInstruction instruction) {
     if (cursor === null) {
@@ skipping 305 matching lines @@
   }
 
   bool isValid() {
     assert(isClosed());
     HValidator validator = new HValidator();
     validator.visitBasicBlock(this);
     return validator.isValid;
   }
 }
 
-class HLabeledBlockInformation {
+interface HBlockInformation {}
+
+class HLabeledBlockInformation implements HBlockInformation {
   final SubGraph body;
   final HBasicBlock joinBlock;
   final List<LabelElement> labels;
   final TargetElement target;
   final bool isContinue;
 
   HLabeledBlockInformation(this.body, this.joinBlock,
                            List<LabelElement> labels,
                            [this.isContinue = false]) :
       this.labels = labels, this.target = labels[0].target;
 
   HLabeledBlockInformation.implicit(this.body,
                                     this.joinBlock,
                                     this.target,
                                     [this.isContinue = false])
       : this.labels = const<LabelElement>[];
 }
 
-class HLoopInformation {
+class LoopTypeVisitor extends AbstractVisitor {
+  const LoopTypeVisitor();
+  int visitNode(Node node) {
+    unreachable();
+  }
+  int visitWhile(While node) => HLoopInformation.WHILE_LOOP;
+  int visitFor(For node) => HLoopInformation.FOR_LOOP;
+  int visitDoWhile(DoWhile node) => HLoopInformation.DO_WHILE_LOOP;
+  int visitForIn(ForIn node) => HLoopInformation.FOR_IN_LOOP;
+}
+
+class HLoopInformation implements HBlockInformation {
+  static final int WHILE_LOOP = 0;
+  static final int FOR_LOOP = 1;
+  static final int DO_WHILE_LOOP = 2;
+  static final int FOR_IN_LOOP = 3;
+
+  final int type;
   final HBasicBlock header;
   final List<HBasicBlock> blocks;
   final List<HBasicBlock> backEdges;
   final List<LabelElement> labels;
+  final TargetElement target;
+  SubGraph initializer = null;
+  SubExpression condition = null;
+  SubGraph body = null;
+  SubGraph updates = null;
+  HBasicBlock joinBlock;
 
-  HLoopInformation(this.header, this.labels)
+  HLoopInformation(this.type, this.header, this.target, this.labels)
       : blocks = new List<HBasicBlock>(),
         backEdges = new List<HBasicBlock>();
 
+  static int loopType(Node node) {
+    return node.accept(const LoopTypeVisitor());
+  }
+
   void addBackEdge(HBasicBlock predecessor) {
     backEdges.add(predecessor);
     addBlock(predecessor);
   }
 
   // Adds a block and transitively all its predecessors in the loop as
   // loop blocks.
   void addBlock(HBasicBlock block) {
     if (block === header) return;
     HBasicBlock parentHeader = block.parentLoopHeader;
@@ skipping 112 matching lines @@
 
   int getChangesFlags() => flags & ((1 << FLAG_CHANGES_COUNT) - 1);
   bool hasSideEffects() => getChangesFlags() != 0;
   void prepareGvn() { setAllSideEffects(); }
 
   void setAllSideEffects() { flags |= ((1 << FLAG_CHANGES_COUNT) - 1); }
   void clearAllSideEffects() { flags &= ~((1 << FLAG_CHANGES_COUNT) - 1); }
 
   bool useGvn() => getFlag(FLAG_USE_GVN);
   void setUseGvn() { setFlag(FLAG_USE_GVN); }
+  // Does this node ootentially affect control flow.

[floitsch, 2012/03/28 04:03:48]

potentially

+  bool isControlFlow() => false;
 
   bool isArray() => type.isArray();
   bool isBoolean() => type.isBoolean();
   bool isInteger() => type.isInteger();
   bool isNumber() => type.isNumber();
   bool isString() => type.isString();
   bool isTypeUnknown() => type.isUnknown();
   bool isStringOrArray() => type.isStringOrArray();
 
   // Compute the type of the instruction.
@@ skipping 163 matching lines @@
   int typeCode() => 0;
   bool typeEquals(other) => other is HBoolify;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HCheck extends HInstruction {
   HCheck(inputs) : super(inputs);
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
+
+  bool isControlFlow() => true;
 }
 
 class HTypeGuard extends HInstruction {
   // Instruction id of the original guarded instruction.
   final int originalGuardedId;
 
   HTypeGuard(HType type, List<HInstruction> env, int this.originalGuardedId)
     : super(env) {
     this.type = type;
   }
 
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HInstruction get guarded() => inputs.last();
 
   HType computeType() => type;
   bool hasExpectedType() => true;
 
+  bool isControlFlow() => true;
+
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => 1;
   bool typeEquals(other) => other is HTypeGuard;
   bool dataEquals(HTypeGuard other) => type == other.type;
 }
 
 class HBailoutTarget extends HInstruction {
   final int state;
   HBailoutTarget(this.state, inputs) : super(inputs);
   accept(HVisitor visitor) => visitor.visitBailoutTarget(this);
+  bool isControlFlow() => true;
 }
 
 class HBoundsCheck extends HCheck {
   HBoundsCheck(length, index) : super(<HInstruction>[length, index]) {
     type = HType.INTEGER;
   }
 
   HInstruction get length() => inputs[0];
   HInstruction get index() => inputs[1];
 
@@ skipping 34 matching lines @@
   HConditionalBranch(inputs) : super(inputs);
   HInstruction get condition() => inputs[0];
   HBasicBlock get trueBranch() => block.successors[0];
   HBasicBlock get falseBranch() => block.successors[1];
   abstract toString();
 }
 
 class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
   abstract toString();
+  bool isControlFlow() => true;
 }
 
 class HInvoke extends HInstruction {
   /**
     * The first argument must be the target: either an [HStatic] node, or
     * the receiver of a method-call. The remaining inputs are the arguments
     * to the invocation.
     */
   final Selector selector;
   HInvoke(Selector this.selector, List<HInstruction> inputs) : super(inputs);
@@ skipping 989 matching lines @@
 class HIfBlockInformation {
   final HIf branch;
   final SubGraph thenGraph;
   final SubGraph elseGraph;
   final HBasicBlock joinBlock;
   HIfBlockInformation(this.branch,
                       this.thenGraph,
                       this.elseGraph,
                       this.joinBlock);
 }