Use simple loop tracking instead of size to determine if

lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 121 matching lines @@
 
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
   }
 }
 
 class SsaBuilderTask extends CompilerTask {
   final Interceptors interceptors;
   final Map<Node, ClosureData> closureDataCache;
   final CodeEmitterTask emitter;
+  // Loop tracking information.
+  final Set<FunctionElement> functionsCalledInLoop;
+  final Set<SourceString> selectorsCalledInLoop;

[ngeoffray, 2012/06/12 11:11:09]

I think this should be a Map<SourceString, Selector>, so that you only optimize
a method that can actually be hit by the call in a loop (eg matches the number
of arugments, or is of the right type, or ...).

[Mads Ager (google), 2012/06/12 11:24:21]

Another good point. Done!

 
   String get name() => 'SSA builder';
 
   SsaBuilderTask(JavaScriptBackend backend)
     : interceptors = new Interceptors(backend.compiler),
       closureDataCache = new HashMap<Node, ClosureData>(),
       emitter = backend.emitter,
+      functionsCalledInLoop = new Set<FunctionElement>(),
+      selectorsCalledInLoop = new Set<SourceString>(),
       super(backend.compiler);
 
   HGraph build(WorkItem work) {
     return measure(() {
       FunctionElement element = work.element;
       HInstruction.idCounter = 0;
       SsaBuilder builder = new SsaBuilder(this, work);
       HGraph graph;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
           graph = compileConstructor(builder, work);
           break;
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           graph = builder.buildMethod(work.element);
           break;
       }
       assert(graph.isValid());
+      if (functionsCalledInLoop.contains(element) ||
+          selectorsCalledInLoop.contains(element.name)) {
+        graph.calledInLoop = true;
+      }
       if (compiler.tracer.enabled) {
         String name;
         if (element.enclosingElement !== null &&
             element.enclosingElement.kind == ElementKind.CLASS) {
           String className = element.enclosingElement.name.slowToString();
           String memberName = element.name.slowToString();
           name = "$className.$memberName";
           if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
             name = "$name (body)";
           }
@@ skipping 3263 matching lines @@
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction = new HStringConcat(left, right, node);
     builder.add(instruction);
     return instruction;
   }
 }