Some cleanups, started implementing checked instance calls, better equality operation.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 38 matching lines @@
 void FlowGraphVisitor::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     Instruction* current = block_order_[i]->Accept(this);
     while ((current != NULL) && !current->IsBlockEntry()) {
       current = current->Accept(this);
     }
   }
 }
 
 
+void Computation::ReplaceWith(Computation* other) {
+  ASSERT(other->instr() == NULL);
+  ASSERT(instr() != NULL);
+  other->set_instr(other->instr());
+  instr()->replace_computation(other);
+  set_instr(NULL);
+}
+
+
 intptr_t InstanceCallComp::InputCount() const {
   return ArgumentCount();
 }
 
 
 intptr_t StaticCallComp::InputCount() const {
   return ArgumentCount();
 }
 
 
@@ skipping 391 matching lines @@
   // TODO(regis): The result type may be generic. Consider upper bounds.
   return signature_function.result_type();
 }
 
 
 RawAbstractType* InstanceCallComp::StaticType() const {
   return Type::DynamicType();
 }
 
 
+RawAbstractType* PolymorphicInstanceCallComp::StaticType() const {
+  return Type::DynamicType();
+}
+
+
 RawAbstractType* StaticCallComp::StaticType() const {
   return function().result_type();
 }
 
 
 RawAbstractType* LoadLocalComp::StaticType() const {
   return local().type().raw();
 }
 
 
@@ skipping 492 matching lines @@
   compiler->GenerateInstanceCall(cid(),
                                  token_index(),
                                  try_index(),
                                  function_name(),
                                  ArgumentCount(),
                                  argument_names(),
                                  checked_argument_count());
 }
 
 
+LocationSummary* PolymorphicInstanceCallComp::MakeLocationSummary() const {
+  return MakeCallSummary();
+}
+
+
+void PolymorphicInstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // TODO(srdjan): Add checked calls, a series of checks each issuing
+  // a direct call to the target if check succeeds.
+  ASSERT(VerifyCallComputation(instance_call()));
+  compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
+                                 instance_call()->cid(),
+                                 instance_call()->token_index(),
+                                 instance_call()->try_index());
+  compiler->GenerateInstanceCall(instance_call()->cid(),
+                                 instance_call()->token_index(),
+                                 instance_call()->try_index(),
+                                 instance_call()->function_name(),
+                                 instance_call()->ArgumentCount(),
+                                 instance_call()->argument_names(),
+                                 instance_call()->checked_argument_count());
+}
+
+
 LocationSummary* StaticCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void StaticCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyCallComputation(this));
   compiler->GenerateStaticCall(cid(),
                                token_index(),
                                try_index(),
@@ skipping 125 matching lines @@
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_index(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 #undef __
 
 }  // namespace dart