Implement "one-shot" interceptors.

sdk/lib/_internal/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.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 40 matching lines @@
           new SsaDeadPhiEliminator(),
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypePropagator(compiler, types),
           new SsaReceiverSpecialization(compiler),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(constantSystem, types, work),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
           new SsaConstantFolder(constantSystem, backend, work, types),
+          new SsaSimplifyInterceptors(constantSystem),
           new SsaDeadCodeEliminator(types)];
       runPhases(graph, phases);
       if (!speculative) {
         runPhase(graph, new SsaConstructionFieldTypes(backend, work, types));
       }
     });
   }
 
   bool trySpeculativeOptimizations(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField()) {
@@ skipping 141 matching lines @@
 
   HInstruction foldUnary(UnaryOperation operation, HInstruction operand) {
     if (operand is HConstant) {
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded != null) return graph.addConstant(folded);
     }
     return null;
   }
 
-  HInstruction handleInterceptorCall(HInvokeDynamicMethod node) {
+  HInstruction handleInterceptorCall(HInvokeDynamic node) {
+    // We only optimize for intercepted method calls in this method.
+    if (node.selector.isGetter() || node.selector.isSetter()) return node;
+
     HInstruction input = node.inputs[1];
     if (input.isString(types)
         && node.selector.name == const SourceString('toString')) {
       return node.inputs[1];
     }
 
     // Try constant folding the instruction.
     Operation operation = node.specializer.operation(constantSystem);
     if (operation != null) {
       HInstruction instruction = node.inputs.length == 2
           ? foldUnary(operation, node.inputs[1])
           : foldBinary(operation, node.inputs[1], node.inputs[2]);
       if (instruction != null) return instruction;
     }
 
     // Try converting the instruction to a builtin instruction.
     HInstruction instruction =
         node.specializer.tryConvertToBuiltin(node, types);
     if (instruction != null) return instruction;
 
     // Check if this call does not need to be intercepted.
     HType type = types[input];
     var interceptor = node.inputs[0];
     if (interceptor is !HThis && !type.canBePrimitive()) {
       // If the type can be null, and the intercepted method can be in
       // the object class, keep the interceptor.
-      if (type.canBeNull()
-          && interceptor.interceptedClasses.contains(compiler.objectClass)) {
-        return node;
+      if (type.canBeNull()) {
+        Set<ClassElement> interceptedClasses;
+        if (interceptor is HInterceptor) {
+          interceptedClasses = interceptor.interceptedClasses;
+        } else if (node is HOneShotInterceptor) {
+          var oneShotInterceptor = node;
+          interceptedClasses = oneShotInterceptor.interceptedClasses;
+        }
+        if (interceptedClasses.contains(compiler.objectClass)) return node;
       }
       // Change the call to a regular invoke dynamic call.
       return new HInvokeDynamicMethod(
           node.selector, node.inputs.getRange(1, node.inputs.length - 1));
     }
 
     Selector selector = node.selector;
     SourceString selectorName = selector.name;
     Element target;
     if (input.isExtendableArray(types)) {
@@ skipping 400 matching lines @@
       HConstant constant = part;
       if (!constant.constant.isPrimitive()) return node;
       PrimitiveConstant primitive = constant.constant;
       folded = new DartString.concat(folded, primitive.toDartString());
     }
     return graph.addConstant(constantSystem.createString(folded, node.node));
   }
 
   HInstruction visitInterceptor(HInterceptor node) {
     if (node.isConstant()) return node;
-    HType type = types[node.inputs[0]];
+    HInstruction constant = tryComputeConstantInterceptor(
+        node.inputs[0], node.interceptedClasses);
+    if (constant == null) return node;
+    return constant;
+  }
+
+  HInstruction tryComputeConstantInterceptor(HInstruction input,
+                                             Set<ClassElement> intercepted) {
+    HType type = types[input];
     ClassElement constantInterceptor;
     if (type.isInteger()) {
       constantInterceptor = backend.jsIntClass;
     } else if (type.isDouble()) {
       constantInterceptor = backend.jsDoubleClass;
     } else if (type.isBoolean()) {
       constantInterceptor = backend.jsBoolClass;
     } else if (type.isString()) {
       constantInterceptor = backend.jsStringClass;
     } else if (type.isArray()) {
       constantInterceptor = backend.jsArrayClass;
     } else if (type.isNull()) {
       constantInterceptor = backend.jsIntClass;
     } else if (type.isNumber()) {
-      Set<ClassElement> intercepted = node.interceptedClasses;
       // If the method being intercepted is not defined in [int] or
       // [double] we can safely use the number interceptor.
       if (!intercepted.contains(compiler.intClass)
           && !intercepted.contains(compiler.doubleClass)) {
         constantInterceptor = backend.jsNumberClass;
       }
     }
 
-    if (constantInterceptor == null) return node;
+    if (constantInterceptor == null) return null;
     if (constantInterceptor == work.element.getEnclosingClass()) {
       return graph.thisInstruction;
     }
 
     Constant constant = new ConstructedConstant(
         constantInterceptor.computeType(compiler), <Constant>[]);
     return graph.addConstant(constant);
   }
+
+  HInstruction visitOneShotInterceptor(HOneShotInterceptor node) {
+    HInstruction newInstruction = handleInterceptorCall(node);
+    if (newInstruction != null) return newInstruction;
+
+    HInstruction constant = tryComputeConstantInterceptor(
+        node.inputs[1], node.interceptedClasses);
+
+    if (constant == null) return node;
+
+    Selector selector = node.selector;
+    // TODO(ngeoffray): make one shot interceptors know whether
+    // they have side effects.
+    if (selector.isGetter()) {
+      HInstruction res = new HInvokeDynamicGetter(
+          selector, node.element, constant, false);
+      res.inputs.add(node.intputs[1]);
+      return res;
+    } else if (node.selector.isSetter()) {
+      HInstruction res = new HInvokeDynamicSetter(
+          selector, node.element, constant, node.inputs[1], false);
+      res.inputs.add(node.intputs[2]);
+      return res;
+    } else {
+      List<HInstruction> inputs = new List<HInstruction>.from(node.inputs);
+      inputs[0] = constant;
+      return new HInvokeDynamicMethod(selector, inputs, true);
+    }
+  }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final HTypeMap types;
   final Set<HInstruction> boundsChecked;
   final CodegenWorkItem work;
   final JavaScriptBackend backend;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
@@ skipping 723 matching lines @@
             || otherIntercepted.contains(backend.jsDoubleClass)) {
           interceptor.interceptedClasses.addAll(user.interceptedClasses);
         }
         user.interceptedClasses = interceptor.interceptedClasses;
       }
     }
   }
 
   // TODO(ngeoffray): Also implement it for non-intercepted calls.
 }
+
+/**
+ * This phase replaces all interceptors that are used only once with
+ * one-shot interceptors. It saves code size and makes the receiver of
+ * an intercepted call a candidate for being generated at use site.
+ */
+class SsaSimplifyInterceptors extends HBaseVisitor
+    implements OptimizationPhase {
+  final String name = "SsaSimplifyInterceptors";
+  final ConstantSystem constantSystem;
+  HGraph graph;
+
+  SsaSimplifyInterceptors(this.constantSystem);
+
+  void visitGraph(HGraph graph) {
+    this.graph = graph;
+    visitDominatorTree(graph);
+  }
+
+  void visitInterceptor(HInterceptor node) {
+    if (node.usedBy.length != 1) return;
+    // [HBailoutTarget] instructions might have the interceptor as
+    // input. In such situation we let the dead code analyzer find out
+    // the interceptor is not needed.
+    if (node.usedBy[0] is !HInvokeDynamic) return;
+
+    HInvokeDynamic user = node.usedBy[0];
+
+    // If [node] was loop hoisted, we keep the interceptor.
+    if (!user.hasSameLoopHeaderAs(node)) return;
+
+    // Replace the user with a [HOneShotInterceptor].
+    HConstant nullConstant = graph.addConstantNull(constantSystem);
+    List<HInstruction> inputs = new List<HInstruction>.from(user.inputs);
+    inputs[0] = nullConstant;
+    HOneShotInterceptor interceptor = new HOneShotInterceptor(
+        user.selector, inputs, node.interceptedClasses);
+    interceptor.sourcePosition = user.sourcePosition;
+
+    HBasicBlock block = user.block;
+    block.addAfter(user, interceptor);
+    block.rewrite(user, interceptor);
+    block.remove(user);
+
+    // The interceptor will be removed in the dead code elimination
+    // phase. Note that removing it here would not work because of how
+    // the [visitBasicBlock] is implemented.
+  }
+}