Refactor building arguments for InstanceCall and fix deoptimization environment for pushed argument…

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_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 59 matching lines @@
 #define DEFINE_ACCEPT(ShortName)                                               \
 void ShortName##Instr::Accept(FlowGraphVisitor* visitor) {                     \
   visitor->Visit##ShortName(this);                                             \
 }
 
 FOR_EACH_INSTRUCTION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
-void ForwardInstructionIterator::RemoveCurrentFromGraph() {
-  ASSERT(!current_->IsBlockEntry());
-  ASSERT(!current_->IsBranch());
-  ASSERT(!current_->IsThrow());
-  ASSERT(!current_->IsReturn());
-  ASSERT(!current_->IsReThrow());
-  ASSERT(current_->previous() != NULL);
-  ASSERT(current_ != block_entry_->last_instruction());
-  Instruction* prev = current_->previous();
-  Instruction* next = current_->next();
-  ASSERT(next != NULL);
-  ASSERT(!next->IsBlockEntry());
-  prev->set_next(next);
-  next->set_previous(prev);
+Instruction* Instruction::RemoveFromGraph(bool return_previous) {
+  ASSERT(!IsBlockEntry());
+  ASSERT(!IsBranch());
+  ASSERT(!IsThrow());
+  ASSERT(!IsReturn());
+  ASSERT(!IsReThrow());
+  ASSERT(!IsGoto());
+  ASSERT(previous() != NULL);
+  Instruction* prev_instr = previous();
+  Instruction* next_instr = next();
+  ASSERT(next_instr != NULL);
+  ASSERT(!next_instr->IsBlockEntry());
+  prev_instr->set_next(next_instr);
+  next_instr->set_previous(prev_instr);
   // Reset successor and previous instruction to indicate
   // that the instruction is removed from the graph.
-  current_->set_previous(NULL);
-  current_->set_next(NULL);
-  current_ = prev;
+  set_previous(NULL);
+  set_next(NULL);
+  return return_previous ? prev_instr : next_instr;
+}
+
+
+void ForwardInstructionIterator::RemoveCurrentFromGraph() {
+  current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
 // Default implementation of visiting basic blocks.  Can be overridden.
 void FlowGraphVisitor::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
     entry->Accept(this);
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       it.Current()->Accept(this);
     }
   }
 }
 
 
-intptr_t InstanceCallComp::InputCount() const {
-  return ArgumentCount();
-}
-
-
 intptr_t AllocateObjectComp::InputCount() const {
   return arguments().length();
 }
 
 
 intptr_t AllocateObjectWithBoundsCheckComp::InputCount() const {
   return arguments().length();
 }
 
 
@@ skipping 1024 matching lines @@
   __ Drop(argument_count);
 }
 
 
 LocationSummary* InstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ASSERT(VerifyCallComputation(this));
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  cid(),
                                  token_pos(),
                                  try_index());
   compiler->GenerateInstanceCall(cid(),
                                  token_pos(),
                                  try_index(),
                                  function_name(),
                                  ArgumentCount(),
                                  argument_names(),
                                  checked_argument_count());
 }
 
 
-bool InstanceCallComp::VerifyComputation() {
-  return VerifyCallComputation(this);
-}
-
-
 LocationSummary* StaticCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void StaticCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label done;
   if (recognized() == MethodRecognizer::kMathSqrt) {
     compiler->GenerateInlinedMathSqrt(&done);
     // Falls through to static call when operand type is not double or smi.
@@ skipping 149 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart