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

lib/compiler/implementation/ssa/optimize.dart

Index: lib/compiler/implementation/ssa/optimize.dart
===================================================================
--- lib/compiler/implementation/ssa/optimize.dart	(revision 5967)
+++ lib/compiler/implementation/ssa/optimize.dart	(working copy)
@@ -21,6 +21,8 @@
   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(),
@@ -38,7 +40,7 @@
       // 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);
@@ -99,7 +101,7 @@
         // 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;
     }
@@ -297,6 +299,7 @@
 
   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);
@@ -307,6 +310,7 @@
 
   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 =