Use simple loop tracking instead of size to determine if

lib/compiler/implementation/ssa/bailout.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.
 
 class BailoutInfo {
   int instructionId;
   int bailoutId;
   BailoutInfo(this.instructionId, this.bailoutId);
 }
 
@@ skipping 63 matching lines @@
 
 
 /**
  * Visits the graph in dominator order and inserts TypeGuards in places where
  * we consider the guard to be of value.
  *
  * Might modify the [:propagatedType:] fields of the instructions in an
  * inconsistent way. No further analysis should rely on them.
  */
 class SsaTypeGuardInserter extends HGraphVisitor implements OptimizationPhase {
-  static final int SMALL_METHOD_BLOCK_LIMIT = 5;
-
   final Compiler compiler;
   final String name = 'SsaTypeGuardInserter';
   final WorkItem work;
-  bool smallMethodNoLoops = false;
+  bool calledInLoop = false;
   bool isRecursiveMethod = false;
   int stateId = 1;
 
   SsaTypeGuardInserter(this.compiler, this.work);
 
   void visitGraph(HGraph graph) {
     isRecursiveMethod = graph.isRecursiveMethod;
-    var blocks = graph.blocks;
-    if (blocks.length < SMALL_METHOD_BLOCK_LIMIT) {
-      smallMethodNoLoops = true;
-      for (var i = 0; i < blocks.length; i++) {
-        if (blocks[i].enclosingLoopHeader !== null) {
-          smallMethodNoLoops = false;
-        }
-      }
-    }
+    calledInLoop = graph.calledInLoop;
     work.guards = <HTypeGuard>[];
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     block.forEachPhi(visitInstruction);
 
     HInstruction instruction = block.first;
     while (instruction !== null) {
       // Note that visitInstruction (from the phis and here) might insert an
@@ skipping 40 matching lines @@
       return false;
     }
 
     // If the instruction is not in a loop then the header will be null.
     HBasicBlock currentLoopHeader = instruction.block.enclosingLoopHeader;
     for (HInstruction user in instruction.usedBy) {
       HBasicBlock userLoopHeader = user.block.enclosingLoopHeader;
       if (isNested(userLoopHeader, currentLoopHeader)) return true;
     }
 
-    // Insert type guards for small methods with no loops and multiple
-    // uses. These are expected to be helper methods that could
-    // benefit from type guards. If there is a loop, we expect the
-    // loop to take most of the time and that inserting a type guard
-    // for something not used in the loop will not be valuable.
-    if (smallMethodNoLoops && instruction.usedBy.length > 2) return true;
-
-    return false;
+    // Insert type guards if the method is likely to be called in a
+    // loop.
+    return calledInLoop;
   }
 
   bool shouldInsertTypeGuard(HInstruction instruction) {
     HType speculativeType = instruction.propagatedType;
     HType computedType = instruction.computeTypeFromInputTypes();
     // Start by reverting the propagated type. If we add a type guard then the
     // guard will expose the speculative type. If we don't add a type guard
     // then this avoids subsequent instructions to use the the wrong type.
     //
     // Note that just setting the propagatedType of the instruction is not
@@ skipping 275 matching lines @@
       }
     }
   }
 
   visitTypeGuard(HTypeGuard guard) {
     blocks.forEach((HBasicBlock block) {
       block.guards.add(guard);
     });
   }
 }