New CL for https://chromiumcodereview.appspot.com/9784002/: Support non-speculative type propagatio…

lib/compiler/implementation/ssa/types.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.
 
 class SsaTypePropagator extends HGraphVisitor implements OptimizationPhase {
 
   final Map<int, HInstruction> workmap;
   final List<int> worklist;
   final Compiler compiler;
+  final bool speculative;
   final String name = 'type propagator';
 
-  SsaTypePropagator(Compiler this.compiler)
+  SsaTypePropagator(Compiler this.compiler, bool this.speculative)

[Lasse Reichstein Nielsen, 2012/03/29 11:46:55]

As mentioned: make this argument optional so you can name the parameter (or,
perhaps, make two constructors, one called SsaTypePropagator.speculative).

Boolean mode switches are annoying.

       : workmap = new Map<int, HInstruction>(),
         worklist = new List<int>();
 
+  // Re-compute and update the type of the instruction. Returns
+  // whether or not the type was changed.
+  bool updateType(HInstruction instruction) {
+    if (instruction.type.isConflicting()) return false;
+
+    // Constants have the type they have. It can't be changed.
+    if (instruction.isConstant()) return false;
+    HType oldType = instruction.type;
+    HType newType = instruction.computeType();
+
+    if (speculative) {

[Lasse Reichstein Nielsen, 2012/03/29 11:46:55]

Is this the only place speculative is used? 
If so, as a third option, extract this into a separate method that does nothing
in the base class, and override it in a speculative type propagator subclass.

[ngeoffray, 2012/03/29 12:51:02]

Done.

+      HType desiredType = instruction.computeDesiredType();
+      HType combined = newType.combine(desiredType);
+      // If the propagated type [newType] does not conflict with the
+      // speculated type [desiredType], use it.
+      if (combined.isKnown()) newType = combined;
+    }
+
+    instruction.type = oldType.combine(newType);
+    return oldType !== instruction.type;
+  }
+
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
     processWorklist();
   }
 
   visitBasicBlock(HBasicBlock block) {
     if (block.isLoopHeader()) {
       block.forEachPhi((HPhi phi) {
-        phi.setInitialTypeForLoopPhi();
+        // Set the initial type for the phi.
+        phi.type = phi.inputs[0].type;
         addToWorkList(phi);
       });
     } else {
       block.forEachPhi((HPhi phi) {
-        if (phi.updateType()) addUsersAndInputsToWorklist(phi);
+        if (updateType(phi)) addUsersAndInputsToWorklist(phi);
       });
     }
 
     HInstruction instruction = block.first;
     while (instruction !== null) {
-      if (instruction.updateType()) addUsersAndInputsToWorklist(instruction);
+      if (updateType(instruction)) addUsersAndInputsToWorklist(instruction);
       instruction = instruction.next;
     }
   }
 
   void processWorklist() {
     while (!worklist.isEmpty()) {
       int id = worklist.removeLast();
       HInstruction instruction = workmap[id];
       assert(instruction !== null);
       workmap.remove(id);
-      if (instruction.updateType()) addUsersAndInputsToWorklist(instruction);
+      if (updateType(instruction)) addUsersAndInputsToWorklist(instruction);
     }
   }
 
   void addUsersAndInputsToWorklist(HInstruction instruction) {
     for (int i = 0, length = instruction.usedBy.length; i < length; i++) {
       addToWorkList(instruction.usedBy[i]);
     }
     for (int i = 0, length = instruction.inputs.length; i < length; i++) {
       addToWorkList(instruction.inputs[i]);
     }
   }
 
   void addToWorkList(HInstruction instruction) {
     final int id = instruction.id;
     if (!workmap.containsKey(id)) {
       worklist.add(id);
       workmap[id] = instruction;
     }
   }
 }