Optimize expressions of the form (expr === true) when expr has boolean type.

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 284 matching lines @@
   }
 }
 
 
 void Instruction::RecordAssignedVars(BitVector* assigned_vars,
                                      intptr_t fixed_parameter_count) {
   // Nothing to do for the base class.
 }
 
 
+void Definition::ReplaceUsesWith(Definition* other) {
+  UseVal* head = use_list();
+  if (head == NULL) return;
+
+  UseVal* current = head;
+  while (current->next_use() != NULL) {
+    current->definition_ = other;
+    current = current->next_use();
+  }
+  current->definition_ = other;
+
+  current->next_use_ = other->use_list();
+  other->use_list()->previous_use_ = current;
+  other->set_use_list(head);
+}
+
+
 RawAbstractType* BindInstr::CompileType() const {
   if (HasPropagatedType()) {
     return PropagatedType();
   }
   // The compile type may be requested when building the flow graph, i.e. before
   // type propagation has occurred.
   return computation()->CompileType();
 }
 
 
@@ skipping 305 matching lines @@
   return value()->CompileType();
 }
 
 
 RawAbstractType* StrictCompareComp::CompileType() const {
   return Type::BoolInterface();
 }
 
 
 RawAbstractType* EqualityCompareComp::CompileType() const {
-  return Type::BoolInterface();
+  return receiver_class_id() != kObjectCid
+      ? Type::BoolInterface()
+      : Type::DynamicType();
 }
 
 
 RawAbstractType* RelationalOpComp::CompileType() const {
-  return Type::BoolInterface();
+  return operands_class_id() != kObjectCid
+      ? Type::BoolInterface()
+      : 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 340 matching lines @@
   return summary;
 }
 
 
 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) {
+  UseVal* left_use = left()->AsUse();
+  UseVal* right_use = right()->AsUse();
+  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_use->definition()->AsBind()->computation()->AsConstant();

[Kevin Millikin (Google), 2012/08/13 12:43:34]

right->computation()->AsConstant()

[Florian Schneider, 2012/08/13 12:58:07]

Done.

+  // 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) &&

[Kevin Millikin (Google), 2012/08/13 12:43:34]

(left_type.raw() == Type::BoolInterface()) &&
(kind() == Token::kEQ_STRICT) &&
(right_constant != NULL) &
(right_constant->value().raw() == Bool::True())

[Florian Schneider, 2012/08/13 12:58:07]

Thanks. Done.

+      (right_constant->value().raw() == Bool::True())) {
+    // 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 {
   return LocationSummary::Make(2,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
@@ skipping 255 matching lines @@
         locations_[i] = Location::NoLocation();
       }
     }
   }
 }
 
 
 #undef __
 
 }  // namespace dart