Cleanup after the interceptor refactoring work, and add a new SSA instruction for an interceptor, s…

sdk/lib/_internal/compiler/implementation/ssa/nodes.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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 14 matching lines @@
   R visitForeign(HForeign node);
   R visitForeignNew(HForeignNew node);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitIntegerCheck(HIntegerCheck node);
+  R visitInterceptor(HInterceptor node);
   R visitInvokeClosure(HInvokeClosure node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitInvokeSuper(HInvokeSuper node);
   R visitIs(HIs node);
   R visitLazyStatic(HLazyStatic node);
   R visitLess(HLess node);
   R visitLessEqual(HLessEqual node);
@@ skipping 239 matching lines @@
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInvokeStatic(node);
   visitIndexAssign(HIndexAssign node) => visitInvokeStatic(node);
   visitIntegerCheck(HIntegerCheck node) => visitCheck(node);
+  visitInterceptor(HInterceptor node) => visitInstruction(node);
   visitInvokeClosure(HInvokeClosure node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
       => visitInvokeDynamicField(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
@@ skipping 470 matching lines @@
 
   // Other flags.
   static const int FLAG_USE_GVN = FLAG_DEPENDS_ON_SOMETHING + 1;
 
   // Type codes.
   static const int UNDEFINED_TYPECODE = -1;
   static const int BOOLIFY_TYPECODE = 0;
   static const int TYPE_GUARD_TYPECODE = 1;
   static const int BOUNDS_CHECK_TYPECODE = 2;
   static const int INTEGER_CHECK_TYPECODE = 3;
-  static const int INVOKE_INTERCEPTOR_TYPECODE = 4;
+  static const int INTERCEPTOR_TYPECODE = 4;
   static const int ADD_TYPECODE = 5;
   static const int DIVIDE_TYPECODE = 6;
   static const int MODULO_TYPECODE = 7;
   static const int MULTIPLY_TYPECODE = 8;
   static const int SUBTRACT_TYPECODE = 9;
   static const int TRUNCATING_DIVIDE_TYPECODE = 10;
   static const int SHIFT_LEFT_TYPECODE = 11;
   static const int SHIFT_RIGHT_TYPECODE = 12;
   static const int BIT_OR_TYPECODE = 13;
   static const int BIT_AND_TYPECODE = 14;
@@ skipping 589 matching lines @@
     clearAllSideEffects();
     if (isSideEffectFree) {
       setChangesInstanceProperty();
     } else {
       setAllSideEffects();
     }
   }
 }
 
 class HInvokeStatic extends HInvoke {
-  bool isSideEffectFree = false;
   /** The first input must be the target. */
   HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
   Element get element => target.element;
   HStatic get target => inputs[0];
 
   HType computeDesiredTypeForInput(HInstruction input,
                                    HTypeMap types,
                                    Compiler compiler) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return computeDesiredTypeForNonTargetInput(input, types, compiler);
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types,
                                             Compiler compiler) {
     return HType.UNKNOWN;
   }
-
-  void prepareGvn(HTypeMap types) {

[ahe, 2012/11/22 13:26:11]

What is this change for?

[ngeoffray, 2012/11/22 13:37:59]

This code was temporary, to make sure we did not regress on some benchmarks
(otherwise the getInterceptor method would be treated as having side effects and
therefore disabling potential gvn optimizations).

-    clearAllSideEffects();
-    if (!isSideEffectFree) {
-      setAllSideEffects();
-    }
-  }
 }
 
 class HInvokeSuper extends HInvokeStatic {
   final bool isSetter;
   HInvokeSuper(inputs, {this.isSetter: false}) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
   HInstruction get value {
     assert(isSetter);
@@ skipping 958 matching lines @@
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode;
   int typeCode() => HInstruction.STATIC_TYPECODE;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
   bool isCodeMotionInvariant() => !element.isAssignable();
 }
 
+class HInterceptor extends HInstruction {
+  final Set<ClassElement> interceptedClasses;
+  HInterceptor(this.interceptedClasses, HInstruction receiver)
+      : super(<HInstruction>[receiver]);
+  String toString() => 'interceptor on $interceptedClasses';

[ahe, 2012/11/22 13:26:11]

What is the method name?

[ngeoffray, 2012/11/22 13:37:59]

An interceptor is not necessary on one method call. It can be shared between
different intercepted calls.

+  accept(HVisitor visitor) => visitor.visitInterceptor(this);
+  HInstruction get receiver => inputs[0];
+
+  void prepareGvn(HTypeMap types) {
+    clearAllSideEffects();
+  }
+
+  int typeCode() => HInstruction.INTERCEPTOR_TYPECODE;
+}
+
 /** An [HLazyStatic] is a static that is initialized lazily at first read. */
 class HLazyStatic extends HStatic {
   HLazyStatic(Element element) : super(element);
 
   void prepareGvn(HTypeMap types) {
     // TODO(4931): The first access has side-effects, but we afterwards we
     // should be able to GVN.
     setAllSideEffects();
   }
 
@@ skipping 535 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }