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, false),
+          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 SsaTypePropagator(compiler, true),

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

Make the boolean parameter optional so you can give it a name here.
Booleans are magic constants too :)

           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 39 matching lines @@
           // 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.

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

Why don't we run the constant folder before type propagation?
Seems that constant folding don't need types, and it would reduce the size of
the code we type propagate on.

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

No reason, I added the type propagator as the first optimization to run because
it's a trivial optimization. Constant folding could potentially make use of
types, so I'll keep it how it is right now, but we can definitely revisit the
order.
It doesn't need types, but it needs to set it on the new instruction. I
understand now that the comment in the code is outdated, I'll change it :)

[floitsch, 2012/03/29 22:00:38]

The constant-folder needs types to fold away boolifications. Unless I'm wrong it
could also fold away half of the array-bounds checks when the index is known to
be a positive integer.

-        replacement.updateType();
+        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);
     }
   }
 }