Implement basic support for deferred slow path code with calls that save and restore live registers.

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
@@ skipping 187 matching lines @@
 }
 
 
 bool FlowGraphCompiler::IsNextBlock(BlockEntryInstr* block_entry) const {
   intptr_t current_index = reverse_index(current_block()->postorder_number());
   return (current_index < (block_order().length() - 1)) &&
       (block_order()[current_index + 1] == block_entry);
 }
 
 
+void FlowGraphCompiler::SaveLiveRegisters(LocationSummary* locs) {
+  // TODO(vegorov): consider saving only caller save (volatile) registers.
+  for (intptr_t reg_idx = 0; reg_idx < kNumberOfCpuRegisters; reg_idx++) {
+    Register reg = static_cast<Register>(reg_idx);
+    if (locs->live_registers()->Contains(reg)) {
+      assembler()->PushRegister(reg);
+    }
+  }
+}
+
+
+void FlowGraphCompiler::RestoreLiveRegisters(LocationSummary* locs) {
+  for (intptr_t reg_idx = 0; reg_idx < kNumberOfCpuRegisters; reg_idx++) {
+    Register reg = static_cast<Register>(reg_idx);
+    if (locs->live_registers()->Contains(reg)) {
+      assembler()->PopRegister(reg);
+    }
+  }
+}
+
+
+void FlowGraphCompiler::AddSlowPathCode(SlowPathCode* code) {
+  slow_path_code_.Add(code);
+}
+
+
 void FlowGraphCompiler::GenerateDeferredCode() {
+  for (intptr_t i = 0; i < slow_path_code_.length(); i++) {
+    slow_path_code_[i]->EmitNativeCode(this);
+  }
   for (intptr_t i = 0; i < deopt_stubs_.length(); i++) {
     deopt_stubs_[i]->GenerateCode(this, i);
   }
 }
 
 
 void FlowGraphCompiler::AddExceptionHandler(intptr_t try_index,
                                             intptr_t pc_offset) {
   exception_handlers_list_->AddHandler(try_index, pc_offset);
 }
@@ skipping 452 matching lines @@
       locs->set_in(i, Location::RegisterLocation(reg));
     }
 
     // Inputs are consumed from the simulated frame. In case of a call argument
     // we leave it until the call instruction.
     if (!instr->IsPushArgument()) Pop(reg, instr->InputAt(i));
   }
 
   // If this instruction is call spill everything that was not consumed by
   // input locations.
-  if (locs->is_call() || instr->IsBranch() || instr->IsGoto()) {
+  if ((locs->contains_call() != LocationSummary::kNoCall) ||
+      instr->IsBranch() || instr->IsGoto()) {
     Spill();
   }
 
   // Allocate all unallocated temp locations.
   for (intptr_t i = 0; i < locs->temp_count(); i++) {
     Location loc = locs->temp(i);
     if (loc.IsUnallocated()) {
       ASSERT(loc.policy() == Location::kRequiresRegister);
       loc = Location::RegisterLocation(
         AllocateFreeRegister(blocked_registers));
@@ skipping 176 matching lines @@
       return;
     }
   }
 
   // This move is not blocked.
   EmitMove(index);
 }
 
 
 }  // namespace dart