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

lib/compiler/implementation/ssa/optimize.dart

Index: lib/compiler/implementation/ssa/optimize.dart
===================================================================
--- lib/compiler/implementation/ssa/optimize.dart	(revision 6988)
+++ lib/compiler/implementation/ssa/optimize.dart	(working copy)
@@ -293,10 +293,60 @@
     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);
     }
@@ -314,15 +364,10 @@
       } 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);