--trust-primitives: Remove bounds checks and receiver and argument type checks

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 28 matching lines @@
           // Run trivial instruction simplification first to optimize
           // some patterns useful for type conversion.
           new SsaInstructionSimplifier(constantSystem, backend, work),
           new SsaTypeConversionInserter(compiler),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
           // After type propagation, more instructions can be
           // simplified.
           new SsaInstructionSimplifier(constantSystem, backend, work),
-          new SsaCheckInserter(backend, work, context.boundsChecked),
+          new SsaCheckInserter(compiler, backend, work, context.boundsChecked),
           new SsaInstructionSimplifier(constantSystem, backend, work),
-          new SsaCheckInserter(backend, work, context.boundsChecked),
+          new SsaCheckInserter(compiler, backend, work, context.boundsChecked),
           new SsaTypePropagator(compiler),
           // Run a dead code eliminator before LICM because dead
           // interceptors are often in the way of LICM'able instructions.
           new SsaDeadCodeEliminator(compiler),
           new SsaGlobalValueNumberer(compiler),
           // After GVN, some instructions might need their type to be
           // updated because they now have different inputs.
           new SsaTypePropagator(compiler),
           new SsaCodeMotion(),
           new SsaLoadElimination(compiler),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
           new SsaValueRangeAnalyzer(compiler, constantSystem, work),
           // Previous optimizations may have generated new
           // opportunities for instruction simplification.
           new SsaInstructionSimplifier(constantSystem, backend, work),
-          new SsaCheckInserter(backend, work, context.boundsChecked),
+          new SsaCheckInserter(compiler, backend, work, context.boundsChecked),
           new SsaSimplifyInterceptors(compiler, constantSystem, work),
           dce = new SsaDeadCodeEliminator(compiler),
           new SsaTypePropagator(compiler)];
       runPhases(graph, phases);
       if (dce.eliminatedSideEffects) {
         phases = <OptimizationPhase>[
             new SsaGlobalValueNumberer(compiler),
             new SsaCodeMotion(),
             new SsaValueRangeAnalyzer(compiler, constantSystem, work),
             new SsaInstructionSimplifier(constantSystem, backend, work),
-            new SsaCheckInserter(backend, work, context.boundsChecked),
+            new SsaCheckInserter(
+                compiler, backend, work, context.boundsChecked),
             new SsaSimplifyInterceptors(compiler, constantSystem, work),
             new SsaDeadCodeEliminator(compiler)];
       } else {
         phases = <OptimizationPhase>[
             // Run the simplifier to remove unneeded type checks inserted
             // by type propagation.
             new SsaInstructionSimplifier(constantSystem, backend, work)];
       }
       runPhases(graph, phases);
     });
@@ skipping 789 matching lines @@
   }
 
   HInstruction visitOneShotInterceptor(HOneShotInterceptor node) {
     return handleInterceptedCall(node);
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final Set<HInstruction> boundsChecked;
   final CodegenWorkItem work;
+  final Compiler compiler;
   final JavaScriptBackend backend;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
-  SsaCheckInserter(this.backend,
+  SsaCheckInserter(this.compiler,
+                   this.backend,
                    this.work,
                    this.boundsChecked);
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
+
+    // In --trust-primitives mode we don't add bounds checks.  This is better
+    // than trying to remove them later as the limit expression would become
+    // dead and require DCE.
+    if (compiler.trustPrimitives) return;

[floitsch, 2014/11/11 10:02:04]

Ok for this CL, but in the future (i.e. the CPS IR) I want to go away from using
"compiler", and make the dependencies more explicit.
For example, here, we should just pass in the flag.
If that becomes unreasonable, there should be a different class/interface that
identifies the things that are needed for the optimization.
For global flags (like "trustPrimitives") it's not a big deal, but when reading
global information (like what classes are alive) we need to get better at
tracking dependencies.

[sra1, 2014/11/12 02:27:37]

I passed the bool.

+
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction = instruction.accept(this);
       instruction = next;
     }
@@ skipping 1233 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }