Canonicalize away simple arithmetic equivalences.

runtime/vm/intermediate_language.cc

 // 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.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1362 matching lines @@
   return Type::Double();
 }
 
 
 intptr_t BinaryDoubleOpInstr::ResultCid() const {
   // The output is not an instance but when it is boxed it becomes double.
   return kDoubleCid;
 }
 
 
+static bool ToIntegerConstant(Value* value, intptr_t* result) {
+  if (!value->BindsToConstant()) {
+    return false;
+  }
+
+  const Object& constant = value->BoundConstant();
+  if (constant.IsDouble()) {
+    const Double& double_constant = Double::Cast(constant);
+    *result = static_cast<intptr_t>(double_constant.value());
+    return (static_cast<double>(*result) == double_constant.value());
+  } else if (constant.IsSmi()) {
+    *result = Smi::Cast(constant).Value();
+    return true;
+  }
+
+  return false;
+}
+
+
+static Definition* CanonicalizeCommutativeArithmetic(Token::Kind op,
+                                                     intptr_t cid,
+                                                     Value* left,
+                                                     Value* right) {
+  ASSERT((cid == kSmiCid) || (cid == kDoubleCid));
+
+  intptr_t value;

[Florian Schneider, 2013/01/08 12:15:47]

For better readability I'd rename this to left_value.

+  if (!ToIntegerConstant(left, &value)) {
+    return NULL;
+  }
+
+  switch (op) {
+    case Token::kMUL:
+      if (value == 1) {
+        return right->definition();
+      } else if (value == 0) {
+        return left->definition();
+      }
+      break;
+    case Token::kADD:
+      if ((value == 0) && (cid == kSmiCid)) {
+        // Can't apply this equivalence to double operations because
+        // 0.0 + (-0.0) is 0.0 not -0.0.
+        return right->definition();
+      }
+      break;
+    case Token::kBIT_AND:
+      ASSERT(cid == kSmiCid);
+      if (value == 0) {
+        return left->definition();
+      } else if (value == -1) {
+        return right->definition();
+      }
+      break;
+    case Token::kBIT_OR:
+      ASSERT(cid == kSmiCid);
+      if (value == 0) {
+        return right->definition();
+      } else if (value == -1) {
+        return left->definition();
+      }
+      break;
+    case Token::kBIT_XOR:
+      ASSERT(cid == kSmiCid);
+      if (value == 0) {
+        return right->definition();
+      }
+      break;
+    default:
+      break;
+  }
+
+  return NULL;
+}
+
+
+Definition* BinaryDoubleOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+  Definition* result = NULL;
+

[Florian Schneider, 2013/01/08 12:15:47]

Remove extra \n.

+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kDoubleCid,
+                                             left(),
+                                             right());
+  if (result != NULL) {
+    return result;
+  }
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kDoubleCid,
+                                             right(),
+                                             left());
+  if (result != NULL) {
+    return result;
+  }
+
+  return this;
+}
+
+
+Definition* BinarySmiOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+  Definition* result = NULL;
+

[Florian Schneider, 2013/01/08 12:15:47]

Remove extra \n.

+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kSmiCid,
+                                             left(),
+                                             right());
+  if (result != NULL) {
+    return result;
+  }
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kSmiCid,
+                                             right(),
+                                             left());
+  if (result != NULL) {
+    return result;
+  }
+
+  return this;
+}
+
+
 RawAbstractType* MathSqrtInstr::CompileType() const {
   return Type::Double();
 }
 
 
 RawAbstractType* UnboxDoubleInstr::CompileType() const {
   return Type::null();
 }
 
 
@@ skipping 1386 matching lines @@
     default:
       UNREACHABLE();
       return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart