Support non-speculative type propagation.

frog/leg/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)

[floitsch, 2012/03/27 22:38:33]

I prefer not to type 'this.X' parameters, but your call.

[ngeoffray, 2012/03/28 07:23:22]

I will keep it with the types since that's what was there before. My preference
would be to type it, but what would be best is consistency in the dart2js code
base. We can do a cleanup later.

       : 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;
+    HType newType = instruction.computeType();
+
+    if (speculative) {
+      HType desiredType = instruction.computeDesiredType();
+      HType combined = newType.combine(desiredType);
+      if (combined.isKnown()) newType = combined;
+    }
+
+    bool changed = (instruction.type != newType);
+    if (instruction.type.isUnknown()) {
+      instruction.type = newType;
+      return changed;
+    } else if (changed) {
+      instruction.type = instruction.type.combine(newType);
+      return changed;
+    }
+    return false;
+  }
+
   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;
     }
   }
 }