Track fields which are known to be always set to integer constants

lib/compiler/implementation/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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 18 matching lines @@
           // some patterns useful for type conversion.
           new SsaConstantFolder(backend, work),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler),
           new SsaCheckInserter(backend),
           new SsaConstantFolder(backend, work),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
-          new SsaDeadCodeEliminator()];
+          new SsaDeadCodeEliminator(),
+          new SsaProcessRecompileCandidates(backend, work)];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(WorkItem work, HGraph graph) {
     return measure(() {
       // Run the phases that will generate type guards.
       List<OptimizationPhase> phases = <OptimizationPhase>[
           new SsaSpeculativeTypePropagator(compiler),
           new SsaTypeGuardInserter(compiler, work),
@@ skipping 1114 matching lines @@
         // the if block terminates. So any use of the instruction
         // after the join block should be changed to the new
         // instruction.
         changeUsesDominatedBy(ifUser.joinBlock, input, convertedType);
       }
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }
+
+class SsaProcessRecompileCandidates
+      extends HBaseVisitor implements OptimizationPhase {
+  final String name = "SsaProcessRecompileCandidates";
+  final JavaScriptBackend backend;
+  final WorkItem work;
+  HGraph graph;
+  Compiler get compiler() => backend.compiler;
+
+  SsaProcessRecompileCandidates(this.backend, this.work);
+
+  void visitGraph(HGraph visitee) {
+    graph = visitee;
+    visitDominatorTree(visitee);
+  }
+
+  HInstruction visitEquals(HEquals node) {
+    // Try to optimize the case where a field which is known to always be an
+    // integer is compared with a constant integer literal.
+    if (node.left is HFieldGet &&
+        node.right is HConstant &&
+        node.right.isInteger()) {
+      HFieldGet left = node.left;
+      HConstant right = node.right;
+      if (left.element != null) {
+        Type type = left.receiver.propagatedType.computeType(compiler);
+        switch (compiler.phase) {
+          case Compiler.PHASE_COMPILING:
+            if (compiler.codegenWorld.couldHaveFieldOnlyIntegerSetters(
+                    type, left.element.name) &&
+                compiler.codegenWorld.couldHaveFieldOnlyIntegerInitializer(
+                    type, left.element.name)) {
+              compiler.enqueuer.codegen.registerRecompilationCandidate(
+                  work.element);
+            }
+            break;
+          case Compiler.PHASE_RECOMPILING:
+            if (compiler.codegenWorld.hasFieldOnlyIntegerSetters(
+                    type, left.element.name) &&
+                compiler.codegenWorld.hasFieldOnlyIntegerInitializer(
+                    type, left.element.name)) {
+              if (compiler.codegenWorld.hasInvokedSetter(left.element,
+                                                         compiler)) {
+                // If there are invoked setters we don't know for sure that the
+                // field will hold an integer, but the fact that the class
+                // itselfalways sets an integer in the fiels is still a strong

[floitsch, 2012/06/18 13:20:40]

itself always

[Søren Gjesse, 2012/06/19 14:35:00]

Done.

+                // signal to indiate the expected type of the field.
+                left.propagatedType = HType.INTEGER;
+                graph.highTypeLikelyhood = true;
+              } else {
+                // If there are no invoked setters we know the type of this
+                // field for sure.
+                left.guaranteedType = HType.INTEGER;
+              }
+            }
+            break;
+          default:
+            assert(false);
+            break;
+        }
+      }
+    }
+  }
+}