--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 15 matching lines @@
 
   void runPhase(HGraph graph, OptimizationPhase phase) {
     phase.visitGraph(graph);
     compiler.tracer.traceGraph(phase.name, graph);
     assert(graph.isValid());
   }
 
   void optimize(CodegenWorkItem work, HGraph graph) {
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
+    bool trustPrimitives = compiler.trustPrimitives;
     measure(() {
       SsaDeadCodeEliminator dce;
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // 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(
+              trustPrimitives, backend, work, context.boundsChecked),
           new SsaInstructionSimplifier(constantSystem, backend, work),
-          new SsaCheckInserter(backend, work, context.boundsChecked),
+          new SsaCheckInserter(
+              trustPrimitives, 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(
+              trustPrimitives, 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(
+                trustPrimitives, 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 bool trustPrimitives;
   final JavaScriptBackend backend;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
-  SsaCheckInserter(this.backend,
+  SsaCheckInserter(this.trustPrimitives,
+                   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 (trustPrimitives) return;
+
     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;
   }
 }