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);

[srdjan, 2012/08/15 00:12:03]

How does GC work here, e.g., if a register contains an object? Is it only
because all registers currently contain boxed values and are above the
spill-slot limit, i.e., they are automatically considered objects? Please add
comment, thanks.

[Kevin Millikin (Google), 2012/08/15 08:02:15]

Exactly.  It works now but needs to be changed when we begin deferring more
code.

I'm working on a change to the stackmaps to count these register values, and
when that lands I can safely look for more code to defer.

+    }
+  }
+}
+
+
+void FlowGraphCompiler::RestoreLiveRegisters(LocationSummary* locs) {
+  for (intptr_t reg_idx = kNumberOfCpuRegisters - 1; reg_idx >= 0; --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() || 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