Implement class id checks as a separate instruction and add a local CSE optimization pass.

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"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, enable_type_checks);
 
+
+intptr_t Computation::Hashcode() const {
+  intptr_t result = computation_kind();
+  for (intptr_t i = 0; i < InputCount(); ++i) {
+    UseVal* val = InputAt(i)->AsUse();
+    intptr_t j = val != NULL
+        ? val->definition()->ssa_temp_index()
+        : -1;
+    result = result * 31 + j;
+  }
+  return result;
+}
+
+
+bool Computation::Equals(Computation* other) const {
+  if (computation_kind() != other->computation_kind()) return false;
+  for (intptr_t i = 0; i < InputCount(); ++i) {
+    if (!InputAt(i)->Equals(other->InputAt(i))) return false;
+  }
+  return AttributesEqual(other);
+}
+
+
+bool CheckClassComp::AttributesEqual(Computation* other) const {
+  CheckClassComp* other_check = other->AsCheckClass();
+  if (other_check == NULL) return false;
+  if (ic_data()->NumberOfChecks() != other->ic_data()->NumberOfChecks()) {
+    return false;
+  }
+  for (intptr_t i = 0; i < ic_data()->NumberOfChecks(); ++i) {
+    // TODO(fschneider): Make sure ic_data are sorted to hit more cases.
+    if (ic_data()->GetReceiverClassIdAt(i) !=
+        other->ic_data()->GetReceiverClassIdAt(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
 UseVal::UseVal(Definition* definition)
     : definition_(definition), next_use_(NULL), previous_use_(NULL) {
   AddToUseList();
 }
 
 
 void UseVal::SetDefinition(Definition* definition) {
   ASSERT(definition != NULL);
   RemoveFromUseList();
   definition_ = definition;
@@ skipping 136 matching lines @@
   next_instr->set_previous(prev_instr);
   // Reset successor and previous instruction to indicate
   // that the instruction is removed from the graph.
   set_previous(NULL);
   set_next(NULL);
   ASSERT(!IsDefinition() || AsDefinition()->use_list() == NULL);
   return return_previous ? prev_instr : next_instr;
 }
 
 
+void BindInstr::InsertBefore(BindInstr* next) {
+  ASSERT(previous_ == NULL);
+  ASSERT(next_ == NULL);
+  next_ = next;
+  previous_ = next->previous_;
+  next->previous_ = this;
+  previous_->next_ = this;
+}
+
+
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
   current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
 // Default implementation of visiting basic blocks.  Can be overridden.
 void FlowGraphVisitor::VisitBlocks() {
   ASSERT(current_iterator_ == NULL);
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
@@ skipping 768 matching lines @@
 RawAbstractType* DoubleToDoubleComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
 RawAbstractType* SmiToDoubleComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
+RawAbstractType* CheckClassComp::CompileType() const {
+  return AbstractType::null();
+}
+
+
 // Shared code generation methods (EmitNativeCode, MakeLocationSummary, and
 // PrepareEntry). Only assembly code that can be shared across all architectures
 // can be used. Machine specific register allocation and code generation
 // is located in intermediate_language_<arch>.cc
 
 
 // True iff. the arguments to a call will be properly pushed and can
 // be popped after the call.
 template <typename T> static bool VerifyCallComputation(T* comp) {
   // Argument values should be consecutive temps.
@@ skipping 457 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart