Instruction selection before removing HTypeKnown

sdk/lib/_internal/compiler/implementation/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 237 matching lines @@
 
   js.Node attachLocationRange(js.Node jsNode,
                               SourceFileLocation sourcePosition,
                               SourceFileLocation endSourcePosition) {
     jsNode.sourcePosition = sourcePosition;
     jsNode.endSourcePosition = endSourcePosition;
     return jsNode;
   }
 
   void preGenerateMethod(HGraph graph) {
+    new SsaInstructionSelection(compiler).visitGraph(graph);
     new SsaTypeKnownRemover().visitGraph(graph);
     new SsaInstructionMerger(generateAtUseSite, compiler).visitGraph(graph);
     new SsaConditionMerger(
         generateAtUseSite, controlFlowOperators).visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder = new SsaLiveIntervalBuilder(
         compiler, generateAtUseSite, controlFlowOperators);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
         intervalBuilder.liveInstructions,
@@ skipping 924 matching lines @@
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeUnary(HInvokeUnary node, String op) {
     visitInvokeUnary(node, op);
     if (requiresUintConversion(node)) {
       push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
     }
   }
 
-  void emitIdentityComparison(HInstruction left,
-                              HInstruction right,
-                              bool inverse) {
-    String op = singleIdentityComparison(left, right, compiler);
+  void emitIdentityComparison(HIdentity instruction, bool inverse) {
+    String op = instruction.singleComparisonOp;
+    HInstruction left = instruction.left;
+    HInstruction right = instruction.right;
     if (op != null) {
       use(left);
       js.Expression jsLeft = pop();
       use(right);
       push(new js.Binary(mapRelationalOperator(op, inverse), jsLeft, pop()));
     } else {
       assert(NullConstant.JsNull == 'null');
       use(left);
       js.Binary leftEqualsNull =
           new js.Binary("==", pop(), new js.LiteralNull());
       use(right);
       js.Binary rightEqualsNull =
           new js.Binary(mapRelationalOperator("==", inverse),
                         pop(), new js.LiteralNull());
       use(right);
       use(left);
       js.Binary tripleEq = new js.Binary(mapRelationalOperator("===", inverse),
                                          pop(), pop());
 
       push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq));
     }
   }
 
   visitIdentity(HIdentity node) {
-    emitIdentityComparison(node.left, node.right, false);
+    emitIdentityComparison(node, false);
   }
 
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
   visitBitXor(HBitXor node)         => visitBitInvokeBinary(node, '^');
@@ skipping 564 matching lines @@
       // This optimization doesn't work for NaN, so we only do it if the
       // type is known to be an integer.
       return left.isInteger(compiler) && right.isInteger(compiler);
     }
 
     bool handledBySpecialCase = false;
     if (isGenerateAtUseSite(input)) {
       handledBySpecialCase = true;
       if (input is HIs) {
         emitIs(input, '!==');
+      } else if (input is HIsViaInterceptor) {
+        emitIsViaInterceptor(input, true);
       } else if (input is HNot) {
         use(input.inputs[0]);
       } else if (input is HIdentity) {
-        HIdentity identity = input;
-        emitIdentityComparison(identity.left, identity.right, true);
+        emitIdentityComparison(input, true);
       } else if (input is HBoolify) {
         use(input.inputs[0]);
         push(new js.Binary("!==", pop(), newLiteralBool(true)), input);
       } else if (canGenerateOptimizedComparison(input)) {
         HRelational relational = input;
         BinaryOperation operation =
             relational.operation(backend.constantSystem);
         String op = mapRelationalOperator(operation.name, true);
         visitRelational(input, op);
       } else {
@@ skipping 403 matching lines @@
       return;
     } else if (element == backend.jsFixedArrayClass) {
       if (negative) {
         checkExtendableArray(input);
       } else {
         checkFixedArray(input);
       }
       return;
     }
     if (interceptor != null) {
-      use(interceptor);
+      checkTypeViaProperty(interceptor, type, negative);
     } else {
-      use(input);
+      checkTypeViaProperty(input, type, negative);
     }
+  }
 
+  void checkTypeViaProperty(HInstruction input, DartType type, bool negative) {
     world.registerIsCheck(type, work.resolutionTree);
 
+    use(input);
+
     js.PropertyAccess field =
         new js.PropertyAccess.field(pop(), backend.namer.operatorIsType(type));
     // We always negate at least once so that the result is boolified.
     push(new js.Prefix('!', field));
     // If the result is not negated, put another '!' in front.
     if (!negative) push(new js.Prefix('!', pop()));
   }
 
   void handleNumberOrStringSupertypeCheck(HInstruction input,
                                           HInstruction interceptor,
@@ skipping 52 matching lines @@
     String combiner = negative ? '&&' : '||';
     push(new js.Binary(negative ? '||' : '&&',
                        objectTest,
                        new js.Binary(combiner, arrayTest, pop())));
   }
 
   void visitIs(HIs node) {
     emitIs(node, "===");
   }
 
+  void visitIsViaInterceptor(HIsViaInterceptor node) {
+    emitIsViaInterceptor(node, false);
+  }
+
   void emitIs(HIs node, String relation)  {
     DartType type = node.typeExpression;
     world.registerIsCheck(type, work.resolutionTree);
     HInstruction input = node.expression;
 
     // If this is changed to single == there are several places below that must
     // be changed to match.
     assert(relation == '===' || relation == '!==');
     bool negative = relation == '!==';
 
@@ skipping 59 matching lines @@
         js.Expression objectTest = pop();
         checkType(input, interceptor, type, negative: negative);
         push(new js.Binary(negative ? '||' : '&&', objectTest, pop()), node);
       } else {
         checkType(input, interceptor, type, negative: negative);
         attachLocationToLast(node);
       }
     }
   }
 
+  void emitIsViaInterceptor(HIsViaInterceptor node, bool negative) {
+    checkTypeViaProperty(node.interceptor, node.typeExpression, negative);
+    attachLocationToLast(node);
+  }
+
   js.Expression generateTest(HInstruction input, TypeMask checkedType) {
     TypeMask receiver = input.instructionType;
     // Figure out if it is beneficial to turn this into a null check.
     // V8 generally prefers 'typeof' checks, but for integers and
     // indexable primitives we cannot compile this test into a single
     // typeof check so the null check is cheaper.
     bool turnIntoNumCheck = input.isIntegerOrNull(compiler)
         && checkedType.containsOnlyInt(compiler);
     bool turnIntoNullCheck = !turnIntoNumCheck
         && (checkedType.nullable() == receiver)
@@ skipping 233 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = compiler.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     world.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }
-
-String singleIdentityComparison(HInstruction left,
-                                HInstruction right,
-                                Compiler compiler) {
-  // Returns the single identity comparison (== or ===) or null if a more
-  // complex expression is required.
-  if (left.canBeNull() && right.canBeNull()) {
-    if (left.isConstantNull() || right.isConstantNull() ||
-        (left.isPrimitive(compiler) &&
-         left.instructionType == right.instructionType)) {
-      return '==';
-    }
-    return null;
-  } else {
-    return '===';
-  }
-}