Convert a == to a builtin identity check if the receiver type can only hit Object==.

sdk/lib/_internal/compiler/implementation/ssa/invoke_dynamic_specializers.dart

 // Copyright (c) 2013, 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;
 
 /**
  * [InvokeDynamicSpecializer] and its subclasses are helpers to
  * optimize intercepted dynamic calls. It knows what input types
  * would be beneficial for performance, and how to change a invoke
  * dynamic to a builtin instruction (e.g. HIndex, HBitNot).
  */
 class InvokeDynamicSpecializer {
   const InvokeDynamicSpecializer();
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     return HType.UNKNOWN;
   }
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     return instruction.instructionType;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     return null;
   }
 
   Operation operation(ConstantSystem constantSystem) => null;
 
   static InvokeDynamicSpecializer lookupSpecializer(Selector selector) {
     if (selector.kind == SelectorKind.INDEX) {
       return selector.name == const SourceString('[]')
           ? const IndexSpecializer()
           : const IndexAssignSpecializer();
@@ skipping 51 matching lines @@
         index.instructionType.canBePrimitiveNumber(compiler)) {
       return HType.MUTABLE_ARRAY;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     if (instruction.inputs[1].isMutableArray()) {
       return new HIndexAssign(instruction.inputs[1],
                               instruction.inputs[2],
                               instruction.inputs[3]);
     }
     return null;
   }
 }
 
 class IndexSpecializer extends InvokeDynamicSpecializer {
   const IndexSpecializer();
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     HInstruction index = instruction.inputs[2];
     if (input == instruction.inputs[1] &&
         index.instructionType.canBePrimitiveNumber(compiler)) {
       return HType.INDEXABLE_PRIMITIVE;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     if (instruction.inputs[1].isIndexablePrimitive()) {
       return new HIndex(instruction.inputs[1], instruction.inputs[2]);
     }
     return null;
   }
 }
 
 class BitNotSpecializer extends InvokeDynamicSpecializer {
   const BitNotSpecializer();
 
@@ skipping 14 matching lines @@
   }
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (instruction.inputs[1].isPrimitive()) return HType.INTEGER;
     return instruction.instructionType;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     HInstruction input = instruction.inputs[1];
     if (input.isNumber()) return new HBitNot(input);
     return null;
   }
 }
 
 class UnaryNegateSpecializer extends InvokeDynamicSpecializer {
   const UnaryNegateSpecializer();
 
   UnaryOperation operation(ConstantSystem constantSystem) {
@@ skipping 14 matching lines @@
     return HType.UNKNOWN;
   }
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     HType operandType = instruction.inputs[1].instructionType;
     if (operandType.isNumber()) return operandType;
     return instruction.instructionType;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     HInstruction input = instruction.inputs[1];
     if (input.isNumber()) return new HNegate(input);
     return null;
   }
 }
 
 abstract class BinaryArithmeticSpecializer extends InvokeDynamicSpecializer {
   const BinaryArithmeticSpecializer();
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
@@ skipping 34 matching lines @@
     HInstruction right = instruction.inputs[2];
     if (input == right && left.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool isBuiltin(HInvokeDynamic instruction) {
     return instruction.inputs[1].isNumber()
         && instruction.inputs[2].isNumber();
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     if (isBuiltin(instruction)) {
       HInstruction builtin =
           newBuiltinVariant(instruction.inputs[1], instruction.inputs[2]);
       if (builtin != null) return builtin;
       // Even if there is no builtin equivalent instruction, we know
       // the instruction does not have any side effect, and that it
       // can be GVN'ed.
       instruction.clearAllSideEffects();
       instruction.clearAllDependencies();
       instruction.setUseGvn();
@@ skipping 122 matching lines @@
   }
 }
 
 class ShiftLeftSpecializer extends BinaryBitOpSpecializer {
   const ShiftLeftSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.shiftLeft;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (!left.isNumber() || !right.isConstantInteger()) return null;
     HConstant rightConstant = right;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     if (count >= 0 && count <= 31) {
       return newBuiltinVariant(left, right);
     }
     return null;
@@ skipping 74 matching lines @@
     // is desired, then numbers are incorrect, though.
     if (propagatedType.canBePrimitiveBoolean(compiler)) {
       HInstruction left = instruction.inputs[1];
       if (left.instructionType.canBePrimitiveNumber(compiler)) {
         return HType.NUMBER;
       }
     }
     return HType.UNKNOWN;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber() && right.isNumber()) {
       return newBuiltinVariant(left, right);
     }
     return null;
   }
 
   HInstruction newBuiltinVariant(HInstruction left, HInstruction right);
 }
@@ skipping 20 matching lines @@
     if (input == left && left.isIndexablePrimitive()) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
     if (input == right && right.isIndexablePrimitive()) {
       return HType.STRING;
     }
     return HType.UNKNOWN;
   }
 
-  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
+  HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
+                                   Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
-    if (left.instructionType.isPrimitiveOrNull() || right.isConstantNull()) {
+    HType instructionType = left.instructionType;
+    if (right.isConstantNull() || instructionType.isPrimitiveOrNull()) {
+      return newBuiltinVariant(left, right);
+    }
+    // Make the mask non-nullable to avoid finding a potential
+    // JSNull::operator==.

[kasperl, 2013/03/21 07:07:04]

Do we need the JSNull operator ==? If we ignore it even when the receiver might
be null, it seems like we could be able to get rid of it?

[ngeoffray, 2013/03/21 08:59:01]

We can't get rid of it. If we have no clue what the receiver is, and there are
multiple operator==, we'll do a getInterceptor(receiver).eq(other). The
getInterceptor will return JSNull.prototype, which must have a specialized
operator== because the Object implementation does not consider the receiver to
be null.

It's a bit complicated...

[sra1, 2013/03/21 08:59:07]

I'm not sure whether you mean get rid of this check (and generate HIdentity more
often), or get rid of operator== on JSNull?

+    TypeMask mask = instructionType.computeMask(compiler).nonNullable();
+    Selector selector = new TypedSelector(mask, instruction.selector);
+    World world = compiler.world;
+    JavaScriptBackend backend = compiler.backend;
+    if (world.locateSingleElement(selector) == backend.objectEquals) {
       return newBuiltinVariant(left, right);
     }
     return null;
   }
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.equal;
   }
 
   HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
@@ skipping 41 matching lines @@
   const LessEqualSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.lessEqual;
   }
 
   HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
     return new HLessEqual(left, right);
   }
 }