Optimize equality for case when all targets are Object.equals.

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 630 matching lines @@
 RawAbstractType* StoreLocalComp::CompileType() const {
   return value()->CompileType();
 }
 
 
 RawAbstractType* StrictCompareComp::CompileType() const {
   return Type::BoolInterface();
 }
 
 
+// Only known == targets return a Boolean.
 RawAbstractType* EqualityCompareComp::CompileType() const {
-  return receiver_class_id() != kObjectCid
-      ? Type::BoolInterface()
-      : Type::DynamicType();
+  if ((receiver_class_id() == kSmiCid) ||
+      (receiver_class_id() == kDoubleCid) ||
+      (receiver_class_id() == kNumberCid)) {
+    return Type::BoolInterface();
+  }
+  if (HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid)) {
+    return Type::BoolInterface();
+  }
+  return Type::DynamicType();
 }
 
 
 RawAbstractType* RelationalOpComp::CompileType() const {
-  return operands_class_id() != kObjectCid
-      ? Type::BoolInterface()
-      : Type::DynamicType();
+  if ((operands_class_id() == kSmiCid) ||
+      (operands_class_id() == kDoubleCid) ||
+      (operands_class_id() == kNumberCid)) {
+    return Type::BoolInterface();
+  }
+  return Type::DynamicType();
 }
 
 
 RawAbstractType* NativeCallComp::CompileType() const {
   // The result type of the native function is identical to the result type of
   // the enclosing native Dart function. However, we prefer to check the type
   // of the value returned from the native call.
   return Type::DynamicType();
 }
 
@@ skipping 353 matching lines @@
 }
 
 
 void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 Definition* StrictCompareComp::TryReplace(BindInstr* instr) {
+  return NULL;

[Florian Schneider, 2012/08/15 11:29:57]

Accidental edit? I don't see why this should be disabled. 

[srdjan, 2012/08/15 13:54:25]

Yes, accidental edit, but correct. See other email, we cannot rely on
CompileType at the moment.

[Florian Schneider, 2012/08/15 14:15:56]

I'm not convinced: This optimization relies only on the fact that the left
expression is guaranteed to be a boolean.

The only expressions that return a CompileType() of BoolInterface are:

AssertBoolean
StrictCompare
EqualityCompare, RelationalOp iff operands cid are {smi, double, number}
BooleanNegate

[srdjan, 2012/08/15 15:36:06]

If the left expression's CompileType says that it is Boollnterface, it may be
null-class as well (OK for assignability, not OK for removing class checks).

Example:


foo(a) {
  var x;
  if (a > 0) {
    // x = a == 1;  // x's compile-type will be bool interface.
    x = true;  // x's compile-type will be Bool type.
  } else {
    x = null;
  }
  return x === true;
}

   UseVal* left_use = left()->AsUse();
   UseVal* right_use = right()->AsUse();
-  if (right_use == NULL || left_use == NULL) return NULL;
+  if ((right_use == NULL) || (left_use == NULL)) return NULL;
   Definition* left = left_use->definition();
   BindInstr* right = right_use->definition()->AsBind();
   if (right == NULL) return NULL;
   ConstantVal* right_constant = right->computation()->AsConstant();
   if (right_constant == NULL) return NULL;
   // TODO(fschneider): Handle other cases: e === false and e !== true/false.
-  const AbstractType& left_type =
-      AbstractType::Handle(left->HasPropagatedType()
-                           ? left->PropagatedType()
-                           : left->CompileType());
-  if ((left_type.raw() == Type::BoolInterface()) &&
-      (kind() == Token::kEQ_STRICT) &&
-      (right_constant->value().raw() == Bool::True())) {
+  // Handles e === true.
+  // const AbstractType& left_type = AbstractType::Handle(left->CompileType());
+  if ((kind() == Token::kEQ_STRICT) &&
+      (right_constant->value().raw() == Bool::True()) &&
+      left_use->CompileTypeIsMoreSpecificThan(

[Florian Schneider, 2012/08/15 14:15:56]

Not sure if this works with null: Which other type that is more specific than
Bool would be valid here?

I think the optimization is valid if the CompileType is _exactly_ Bool.

[srdjan, 2012/08/15 15:36:06]

The only type more specific than bool interface is Bool class.

+          Type::Handle(Type::BoolInterface()))) {
     // Remove the constant from the graph.
     right->RemoveFromGraph();
     // Return left subexpression as the replacement for this instruction.
     return left;
   }
   return NULL;
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
@@ skipping 232 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart