Better constant fold identity checks. (100 bytes saved on swarm, yeah! :))

lib/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2011, 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 275 matching lines @@
     }
 
     if (left.isNonPrimitive() && node.operation.isUserDefinable()) {
       SourceString methodName = Elements.constructOperatorName(
           const SourceString('operator'), node.operation.name);
       return fromInterceptorToDynamicInvocation(node, methodName);
     }
     return node;
   }
 
+  HInstruction handleIdentityCheck(HInvokeBinary node) {

[Lasse Reichstein Nielsen, 2012/04/26 07:24:02]

With the new == semantics (which we haven't implemented yet, but still...), we
can also optimize tests if we know that either side is null.
In that case, we only need to compare the other to null.

[ngeoffray, 2012/04/26 09:25:19]

True. Let's wait until we start implementing the new changes in the spec.

+    HInstruction left = node.left;
+    HInstruction right = node.right;
+    if (left.propagatedType.union(right.propagatedType) === HType.CONFLICTING) {

[floitsch, 2012/04/26 08:31:16]

This should be intersection, except for numbers.
That is 0 === 0.0 is (semantically) false, but we compile it to 0 === 0.
Therefore, if we want to keep the runtime semantics, we need to fold it using
the 'union' operations.
For all the others intersection is fine. A string and a read-able array can
never be ===.

[ngeoffray, 2012/04/26 09:25:19]

I used union because I was mostly thinking of the number types. But yes, for the
others, it must be intersection.

So I added a check if both inputs are numbers. In that case, I don't fold to
false.

+      return graph.addConstantBool(false);

[floitsch, 2012/04/26 08:31:16]

I don't think this is correct: A phi with inputs integer and string will say
that its input is conflicting.
var x = 3;
while (true) { if (x == "done") return; x = done; }

[ngeoffray, 2012/04/26 09:25:19]

I'm not sure I understand how this relates to the code.

[ngeoffray, 2012/04/26 10:09:53]

Actually, it looks like a phi never gets a conflicting type: see
HPhi::computeTypeFromInputTypes in nodes.dart. I added a test still and some
asserts, to make sure we don't regress on that case.

+    }
+
+    if (left.isConstantBoolean() && right.isBoolean()) {
+      HConstant constant = left;
+      if (constant.constant.isTrue()) {
+        return right;
+      } else {
+        return new HNot(right);
+      }
+    }
+
+    if (right.isConstantBoolean() && left.isBoolean()) {
+      HConstant constant = right;
+      if (constant.constant.isTrue()) {
+        return left;
+      } else {
+        return new HNot(left);
+      }
+    }
+
+    return null;
+  }
+
+  HInstruction visitIdentity(HIdentity node) {
+    HInstruction newInstruction = handleIdentityCheck(node);
+    return newInstruction === null ? super.visitIdentity(node) : newInstruction;
+  }
+
+  HInstruction foldBuiltinEqualsCheck(HEquals node) {
+    // TODO(floitsch): cache interceptors.
+    HInstruction newInstruction = handleIdentityCheck(node);
+    if (newInstruction === null) {
+      HStatic target = new HStatic(
+          compiler.builder.interceptors.getTripleEqualsInterceptor());
+      node.block.addBefore(node, target);
+      return new HIdentity(target, node.left, node.right);
+    } else {
+      return newInstruction;
+    }
+  }
+
   HInstruction visitEquals(HEquals node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
 
+    if (node.builtin) {
+      return foldBuiltinEqualsCheck(node);
+    }
+
     if (left.isConstant() && right.isConstant()) {
       return visitInvokeBinary(node);
     }
 
     if (left.isNonPrimitive()) {
       HNonPrimitiveType type = left.propagatedType;
       Element element = type.lookupMember(Namer.OPERATOR_EQUALS);
       if (element !== null) {
         // If the left-hand side is guaranteed to be a non-primitive
         // type and and it defines operator==, we emit a call to that
         // operator.
         return visitInvokeBinary(node);
       } else if (right.isConstantNull()) {
         return graph.addConstantBool(false);
       } else {
         // We can just emit an identity check because the type does
         // not implement operator=.
-        // TODO(floitsch): cache interceptors.
-        HStatic target = new HStatic(
-            compiler.builder.interceptors.getTripleEqualsInterceptor());
-        node.block.addBefore(node, target);
-        return new HIdentity(target, left, right);
+        return foldBuiltinEqualsCheck(node);
       }
     }
 
-
     if (right.isConstantNull()) {
       if (left.propagatedType.isUseful()) {
         return graph.addConstantBool(false);
       } else {
         // TODO(floitsch): cache interceptors.
         HStatic target = new HStatic(
             compiler.builder.interceptors.getEqualsNullInterceptor());
         node.block.addBefore(node, target);
         return new HEquals(target, node.left, node.right);
       }
@@ skipping 529 matching lines @@
         }
       }
       if (!canBeMoved) continue;
 
       // This is safe because we are running after GVN.
       // TODO(ngeoffray): ensure GVN has been run.
       set_.add(current);
     }
   }
 }