Reenable elimination of strict equals when right side is true.

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 41 matching lines @@
     return false;
   }
   ConstantVal* constant = bind->computation()->AsConstant();
   if (constant != NULL) {
     return constant->value().IsNull();
   }
   return false;
 }
 
 
+const Object& UseVal::BoundConstant() const {
+  ASSERT(BindsToConstant());
+  BindInstr* bind = definition()->AsBind();
+  ASSERT(bind != NULL);
+  ConstantVal* constant = bind->computation()->AsConstant();
+  ASSERT(constant != NULL);
+  return constant->value();
+}
+
+
 void UseVal::RemoveFromUseList() {
   ASSERT(definition_ != NULL);
   if (next_use_ != NULL) {
     next_use_->previous_use_ = previous_use_;
   }
   if (previous_use_ != NULL) {
     previous_use_->next_use_ = next_use_;
   } else {
     // This is the head of the list.
     ASSERT(definition_->use_list() == this);
@@ skipping 657 matching lines @@
       (receiver_class_id() == kNumberCid)) {
     return Type::BoolInterface();
   }
   if (HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid)) {
     return Type::BoolInterface();
   }
   return Type::DynamicType();
 }
 
 
+intptr_t EqualityCompareComp::ResultCid() const {
+  if ((receiver_class_id() == kSmiCid) ||
+      (receiver_class_id() == kDoubleCid) ||
+      (receiver_class_id() == kNumberCid)) {
+    // Known/library equalities that are guaranteed to return Boolean.
+    return kBoolCid;
+  }
+  if (HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid)) {
+    return kBoolCid;
+  }
+  return kDynamicCid;
+}
+
+
 RawAbstractType* RelationalOpComp::CompileType() const {
   if ((operands_class_id() == kSmiCid) ||
       (operands_class_id() == kDoubleCid) ||
       (operands_class_id() == kNumberCid)) {
+    // Known/library relational ops that are guaranteed to return Boolean.
     return Type::BoolInterface();
   }
   return Type::DynamicType();
 }
 
 
+intptr_t RelationalOpComp::ResultCid() const {
+  if ((operands_class_id() == kSmiCid) ||
+      (operands_class_id() == kDoubleCid) ||
+      (operands_class_id() == kNumberCid)) {
+    // Known/library relational ops that are guaranteed to return Boolean.
+    return kBoolCid;
+  }
+  return kDynamicCid;
+}
+
+
 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();
 }
 
 
 RawAbstractType* LoadIndexedComp::CompileType() const {
   return Type::DynamicType();
@@ skipping 111 matching lines @@
   return AbstractType::null();
 }
 
 
 RawAbstractType* CheckStackOverflowComp::CompileType() const {
   return AbstractType::null();
 }
 
 
 RawAbstractType* BinaryOpComp::CompileType() const {
-  // TODO(srdjan): Convert to use with class-ids instead of types.
+  ObjectStore* object_store = Isolate::Current()->object_store();
   if (operands_type() == kMintOperands) {
-    return Isolate::Current()->object_store()->mint_type();
-  } else if (op_kind() == Token::kSHL) {
+    return object_store->mint_type();
+  }
+  if (op_kind() == Token::kSHL) {
     return Type::IntInterface();
-  } else {
-    ASSERT(operands_type() == kSmiOperands);
-    return Isolate::Current()->object_store()->smi_type();
   }
+  ASSERT(operands_type() == kSmiOperands);
+  return object_store->smi_type();
+}
+
+
+intptr_t BinaryOpComp::ResultCid() const {
+  if (operands_type() == kMintOperands) {
+    return kMintCid;
+  }
+  ASSERT(operands_type() == kSmiOperands);
+  return (op_kind() == Token::kSHL) ? kDynamicCid : kSmiCid;
 }
 
 
 RawAbstractType* DoubleBinaryOpComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
+intptr_t DoubleBinaryOpComp::ResultCid() const {
+  return kDoubleCid;
+}
+
+
 RawAbstractType* UnarySmiOpComp::CompileType() const {
   return Type::IntInterface();
 }
 
 
 RawAbstractType* NumberNegateComp::CompileType() const {
-  return Type::NumberInterface();
+  return Type::DoubleInterface();

[regis, 2012/08/16 21:43:52]

Why?

[srdjan, 2012/08/16 22:11:06]

Adding comment:
Implemented only for doubles.

Added assert in EmitNatives so that we keep them in sync.

 }
 
 
 RawAbstractType* DoubleToDoubleComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
 RawAbstractType* SmiToDoubleComp::CompileType() const {
   return Type::DoubleInterface();
@@ skipping 197 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) {
-  // TODO(srdjan): Do not use CompileType for class check elimination.
-  return NULL;
   UseVal* left_use = left()->AsUse();
   UseVal* right_use = right()->AsUse();
   if ((right_use == NULL) || (left_use == NULL)) return NULL;
+  if (!right_use->BindsToConstant()) return NULL;
+  const Object& right_constant = right_use->BoundConstant();
   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.
   // Handles e === true.
   if ((kind() == Token::kEQ_STRICT) &&
-      (right_constant->value().raw() == Bool::True()) &&
-      left_use->CompileTypeIsMoreSpecificThan(
-          Type::Handle(Type::BoolInterface()))) {
+      (right_constant.raw() == Bool::True()) &&
+      (left_use->ResultCid() == kBoolCid)) {
     // Remove the constant from the graph.
-    right->RemoveFromGraph();
+    BindInstr* right = right_use->definition()->AsBind();
+    if (right != NULL) {
+      right->set_use_list(NULL);
+      right->RemoveFromGraph();
+    }
     // Return left subexpression as the replacement for this instruction.
     return left;
   }
   return NULL;
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
   return LocationSummary::Make(2,
                                Location::SameAsFirstInput(),
@@ skipping 236 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart