Refactoring if block-information.

lib/compiler/implementation/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 visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 120 matching lines @@
     blocks.add(block);
     assert(blocks[id] === block);
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock result = new HBasicBlock();
     addBlock(result);
     return result;
   }
 
-  HBasicBlock addNewLoopHeaderBlock(int type,
+  HBasicBlock addNewLoopHeaderBlock(int kind,
                                     TargetElement target,
                                     List<LabelElement> labels) {
     HBasicBlock result = addNewBlock();
-    result.loopInformation = new HLoopInformation(type, result, target, labels);
+    result.blockInformation =
+        new HLoopInformation(kind, 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.READABLE_ARRAY;
@@ skipping 250 matching lines @@
   // this [id]. The exception are back-edges.
   int id;
 
   static final int STATUS_NEW = 0;
   static final int STATUS_OPEN = 1;
   static final int STATUS_CLOSED = 2;
   int status = STATUS_NEW;
 
   HInstructionList phis;
 
-  HLoopInformation loopInformation = null;
-  HLabeledBlockInformation labeledBlockInformation = null;
+  HBlockInformation blockInformation = null;
   HBasicBlock parentLoopHeader = null;
   List<HTypeGuard> guards;
 
   final List<HBasicBlock> predecessors;
   List<HBasicBlock> successors;
 
   HBasicBlock dominator = null;
   final List<HBasicBlock> dominatedBlocks;
 
   HBasicBlock() : this.withId(null);
   HBasicBlock.withId(this.id)
       : phis = new HInstructionList(),
         predecessors = <HBasicBlock>[],
         successors = const <HBasicBlock>[],
         dominatedBlocks = <HBasicBlock>[],
         guards = <HTypeGuard>[];
 
   int hashCode() => id;
 
   bool isNew() => status == STATUS_NEW;
   bool isOpen() => status == STATUS_OPEN;
   bool isClosed() => status == STATUS_CLOSED;
 
-  bool isLoopHeader() => loopInformation !== null;
-  bool hasLabeledBlockInformation() => labeledBlockInformation !== null;
+  bool isLoopHeader() => blockInformation is HLoopInformation;
+  bool isLabeledBlock() => blockInformation is HLabeledBlockInformation;
 
   bool hasGuards() => !guards.isEmpty();
 
   void open() {
     assert(isNew());
     status = STATUS_OPEN;
   }
 
   void close(HControlFlow end) {
     assert(isOpen());
@@ skipping 88 matching lines @@
     } else {
       successors.add(block);
     }
     block.predecessors.add(this);
   }
 
   void postProcessLoopHeader() {
     assert(isLoopHeader());
     // Only the first entry into the loop is from outside the
     // loop. All other entries must be back edges.
+    HLoopInformation loopInformation = this.blockInformation;
     for (int i = 1, length = predecessors.length; i < length; i++) {
       loopInformation.addBackEdge(predecessors[i]);
     }
   }
 
   /**
    * Rewrites all uses of the [from] instruction to using the [to]
    * instruction instead.
    */
   void rewrite(HInstruction from, HInstruction to) {
@@ skipping 87 matching lines @@
   }
 
   bool isValid() {
     assert(isClosed());
     HValidator validator = new HValidator();
     validator.visitBasicBlock(this);
     return validator.isValid;
   }
 }
 
-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 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.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;
-    if (parentHeader === header) {
-      // Nothing to do in this case.
-    } else if (parentHeader !== null) {
-      addBlock(parentHeader);
-    } else {
-      block.parentLoopHeader = header;
-      blocks.add(block);
-      for (int i = 0, length = block.predecessors.length; i < length; i++) {
-        addBlock(block.predecessors[i]);
-      }
-    }
-  }
-
-  HBasicBlock getLastBackEdge() {
-    int maxId = -1;
-    HBasicBlock result = null;
-    for (int i = 0, length = backEdges.length; i < length; i++) {
-      HBasicBlock current = backEdges[i];
-      if (current.id > maxId) {
-        maxId = current.id;
-        result = current;
-      }
-    }
-    return result;
-  }
-}
 
 class HType {
   final int flag;
   const HType(int this.flag);
 
   static final int FLAG_CONFLICTING = 0;
   static final int FLAG_UNKNOWN = 1;
   static final int FLAG_BOOLEAN = FLAG_UNKNOWN << 1;
   static final int FLAG_INTEGER = FLAG_BOOLEAN << 1;
   static final int FLAG_STRING = FLAG_INTEGER << 1;
@@ skipping 140 matching lines @@
    *
    * Note that the [propagatedType] may only be set to [HType.CONFLICTING] with
    * speculative types (as otherwise the instruction either sets the output
    * type to [HType.UNKNOWN] or a specific type.
    */
   HType propagatedType = HType.UNKNOWN;
 
   /**
    * Some instructions have a good idea of their return type, but cannot
    * guarantee the type. The [likelyType] does not need to be more specialized
-   * than the [propagatedType]. 
+   * than the [propagatedType].
    *
    * Examples: the [likelyType] of [:x == y:] is a boolean. In most cases this
    * cannot be guaranteed, but when merging types we still want to use this
    * information.
    *
    * Similarily the [HAdd] instruction is likely a number. Note that, even if
    * the [propagatedType] is already set to integer, the [likelyType] still
-   * might just return the number type. 
-   */ 
+   * might just return the number type.
+   */
   HType get likelyType() => propagatedType;
 
   /**
    * Compute the type of the instruction by propagating the input types through
    * the instruction.
    *
    * By default just copy the guaranteed type.
    */
   HType computeTypeFromInputTypes() => guaranteedType;
 
@@ skipping 1068 matching lines @@
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     if (input == left && right.propagatedType.isUseful()) {
       // All our useful types have === semantics. But we don't want to
       // speculatively test for all possible types. Therefore we try to match
       // the two types. That is, if we see x == 3, then we speculatively test
       // if x is a number and bailout if it isn't.
       if (right.isNumber()) return HType.NUMBER;  // No need to be more precise.
       // String equality testing is much more common than array equality
       // testing.
-      if (right.isStringOrArray()) return HType.STRING; 
+      if (right.isStringOrArray()) return HType.STRING;
       return right.propagatedType;
     }
     // String equality testing is much more common than array equality testing.
     if (input == left && left.isStringOrArray()) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
     if (input == right && right.isStringOrArray()) {
       return HType.STRING;
     }
@@ skipping 195 matching lines @@
 
   HInstruction get expression() => inputs[0];
 
   HType get guaranteedType() => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeName";
 }
 
-class HIfBlockInformation {
-  final HIf branch;
+
+interface HBlockInformation {
+  bool accept(HBlockInformationVisitor visitor);
+}
+
+interface HBlockInformationVisitor {
+  bool visitLabeledBlockInfo(HLabeledBlockInformation info);
+  bool visitLoopInfo(HLoopInformation info);
+  bool visitIfInfo(HIfBlockInformation info);
+  bool visitAndOrInfo(HAndOrBlockInformation info);
+}
+
+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>[];
+
+  bool accept(HBlockInformationVisitor visitor) =>
+    visitor.visitLabeledBlockInfo(this);
+}
+
+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 kind;
+  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.kind, 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;
+    if (parentHeader === header) {
+      // Nothing to do in this case.
+    } else if (parentHeader !== null) {
+      addBlock(parentHeader);
+    } else {
+      block.parentLoopHeader = header;
+      blocks.add(block);
+      for (int i = 0, length = block.predecessors.length; i < length; i++) {
+        addBlock(block.predecessors[i]);
+      }
+    }
+  }
+
+  HBasicBlock getLastBackEdge() {
+    int maxId = -1;
+    HBasicBlock result = null;
+    for (int i = 0, length = backEdges.length; i < length; i++) {
+      HBasicBlock current = backEdges[i];
+      if (current.id > maxId) {
+        maxId = current.id;
+        result = current;
+      }
+    }
+    return result;
+  }
+
+  bool accept(HBlockInformationVisitor visitor) => visitor.visitLoopInfo(this);
+}
+
+class HIfBlockInformation implements HBlockInformation {
+  final SubExpression condition;
   final SubGraph thenGraph;
   final SubGraph elseGraph;
   final HBasicBlock joinBlock;
-  HIfBlockInformation(this.branch,
+  HIfBlockInformation(this.condition,
                       this.thenGraph,
                       this.elseGraph,
                       this.joinBlock);
+  bool accept(HBlockInformationVisitor visitor) => visitor.visitIfInfo(this);
 }
+
+class HAndOrBlockInformation implements HBlockInformation {
+  final bool isAnd;
+  final SubExpression left;
+  final SubExpression right;
+  final HBasicBlock joinBlock;
+  HAndOrBlockInformation(this.isAnd,
+                         this.left,
+                         this.right,
+                         this.joinBlock);
+  bool accept(HBlockInformationVisitor visitor) => visitor.visitAndOrInfo(this);
+}