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

lib/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
   SsaOptimizerTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA optimizer';
 
   void runPhases(HGraph graph, List<OptimizationPhase> phases) {
     for (OptimizationPhase phase in phases) {
       phase.visitGraph(graph);
       compiler.tracer.traceGraph(phase.name, graph);
     }
   }
 
   void optimize(WorkItem work, HGraph graph) {
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
+          new SsaTypePropagator(compiler),
+          new SsaCheckInserter(compiler),
           new SsaConstantFolder(compiler),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
           new SsaDeadCodeEliminator()];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(WorkItem work, HGraph graph) {
     return measure(() {
       // Run the phases that will generate type guards. We must also run
       // [SsaCheckInserter] because the type propagator also propagates
       // types non-speculatively. For example, it propagates the type
       // array for a call to the List constructor.
       List<OptimizationPhase> phases = <OptimizationPhase>[
-          new SsaTypePropagator(compiler),
+          new SsaSpeculativeTypePropagator(compiler),
           new SsaTypeGuardBuilder(compiler, work),
           new SsaCheckInserter(compiler)];
       runPhases(graph, phases);
       return !work.guards.isEmpty();
     });
   }
 
   void prepareForSpeculativeOptimizations(WorkItem work, HGraph graph) {
     measure(() {
       // In order to generate correct code for the bailout version, we did not
@@ skipping 36 matching lines @@
       HInstruction replacement = instruction.accept(this);
       if (replacement !== instruction) {
         if (!replacement.isInBasicBlock()) {
           // The constant folding can return an instruction that is already
           // part of the graph (like an input), so we only add the replacement
           // if necessary.
           block.addAfter(instruction, replacement);
         }
         block.rewrite(instruction, replacement);
         block.remove(instruction);
-        // Because the constant folder runs after type propagation, we
-        // must update the type of this instruction manually. Later
-        // phases can then optimize this instruction based on its
-        // type.
-        replacement.updateType();
+        // If the replacement instruction does not know its type yet,
+        // use the type of the instruction.
+        if (!replacement.type.isKnown()) {
+          replacement.type = instruction.type;
+        }
       }
       instruction = next;
     }
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
@@ skipping 177 matching lines @@
   }
 
   HIntegerCheck insertIntegerCheck(HInstruction node, HInstruction value) {
     HIntegerCheck check = new HIntegerCheck(value);
     node.block.addBefore(node, check);
     return check;
   }
 
   void visitIndex(HIndex node) {
     if (!node.builtin) return;
+    if (node.index is HBoundsCheck) return;
     HInstruction index = insertIntegerCheck(node, node.index);
     index = insertBoundsCheck(node, node.receiver, index);
     HIndex newInstruction = new HIndex(node.target, node.receiver, index);
     node.block.addBefore(node, newInstruction);
     node.block.rewrite(node, newInstruction);
     node.block.remove(node);
   }
 
   void visitIndexAssign(HIndexAssign node) {
     if (!node.builtin) return;
+    if (node.index is HBoundsCheck) return;
     HInstruction index = insertIntegerCheck(node, node.index);
     index = insertBoundsCheck(node, node.receiver, index);
     HIndexAssign newInstruction =
         new HIndexAssign(node.target, node.receiver, index, node.value);
     node.block.addBefore(node, newInstruction);
     node.block.rewrite(node, newInstruction);
     node.block.remove(node);
   }
 }
 
@@ skipping 380 matching lines @@
         }
       }
       if (!canBeMoved) continue;
 
       // This is safe because we are running after GVN.
       // TODO(ngeoffray): ensure GVN has been run.
       set_.add(current);
     }
   }
 }