Finish implementing lazy deoptimization (ia32, x64). Ran tests with --deoptimize-alot.

runtime/vm/stub_code_x64.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"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
 #include "vm/flow_graph_compiler.h"
+#include "vm/instructions.h"
 #include "vm/object_store.h"
 #include "vm/pages.h"
 #include "vm/resolver.h"
 #include "vm/scavenger.h"
 #include "vm/stub_code.h"
 
 
 #define __ assembler->
 
 namespace dart {
@@ skipping 445 matching lines @@
   __ ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                            intptr_t deopt_reason,
                            uword saved_registers_address);
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, uword last_fp);
 
+
 // This stub translates optimized frame into unoptimized frame. The optimized
 // frame can contain values in registers and on stack, the unoptimized
 // frame contains all values on stack.
 // Deoptimization occurs in following steps:
 // - Push all registers that can contain values.
 // - Call C routine to copy the stack and saved registers into temporary buffer.
 // - Adjust caller's frame to correct unoptimized frame size.
 // - Fill the unoptimized frame.
 // - Materialize objects that require allocation (e.g. Double instances).
 // GC can occur only after frame is fully rewritten.
 // Stack:
 //   +------------------+
-//   | 0 as PC marker   | <- TOS
-//   +------------------+
 //   | Saved FP         |
 //   +------------------+
 //   | return-address   |  (deoptimization point)
 //   +------------------+
 //   | optimized frame  |
 //   |  ...             |
 //
-void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
+// Parts of the code cannot GC, part of the code can GC.
+static void GenerateDeoptimizationSequence(Assembler* assembler,
+                                           bool preserve_rax) {
   __ EnterFrame(0);
+  const intptr_t saved_rax_offset_from_ebp = -(kNumberOfCpuRegisters - RAX);
+  // Result in EAX is preserved as part of pushing all registers below.
+
   // Push registers in their enumeration order: lowest register number at
   // lowest address.
   for (intptr_t i = kNumberOfCpuRegisters - 1; i >= 0; i--) {
     __ pushq(static_cast<Register>(i));
   }
   __ subq(RSP, Immediate(kNumberOfXmmRegisters * kDoubleSize));
   intptr_t offset = 0;
   for (intptr_t reg_idx = 0; reg_idx < kNumberOfXmmRegisters; ++reg_idx) {
     XmmRegister xmm_reg = static_cast<XmmRegister>(reg_idx);
     __ movsd(Address(RSP, offset), xmm_reg);
     offset += kDoubleSize;
   }
 
   __ movq(RCX, RSP);  // Saved saved registers block.
   __ ReserveAlignedFrameSpace(0);
   __ SmiUntag(RAX);
   __ movq(RDI, RCX);  // Set up argument 1 saved_registers_address.
 
   __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry);
   // Result (RAX) is stack-size (FP - SP) in bytes, incl. the return address.
+
+  if (preserve_rax) {
+    // Restore result into RBX temporarily.
+    __ movq(RBX, Address(RBP, saved_rax_offset_from_ebp * kWordSize));
+  }
+
   __ LeaveFrame();
   __ popq(RCX);   // Preserve return address.
   __ movq(RSP, RBP);
   __ subq(RSP, RAX);
   __ movq(Address(RSP, 0), RCX);
 
   __ EnterFrame(0);
   __ movq(RCX, RSP);  // Get last FP address.
+  if (preserve_rax) {
+    __ pushq(RBX);  // Preserve result.
+  }
   __ ReserveAlignedFrameSpace(0);
   __ movq(RDI, RCX);  // Set up argument 1 last_fp.
   __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry);
+  if (preserve_rax) {
+    // Restore result into RAX.
+    __ movq(RAX, Address(RBP, -1 * kWordSize));
+  }
   __ LeaveFrame();

[siva, 2012/09/07 23:16:17]

Ditto comment regarding GC:

Could you add a comment here or above stating that the code
above should not have any GC in it and that runtime calls
kDeoptimizeCopyFrameRuntimeEntry and
kDeoptimizeFillFrameEntry
are leaf runtime calls

would make it easier when reading through the code.

[srdjan, 2012/09/12 06:15:26]

Done.

 
   // Frame is fully rewritten at this point and it is safe to perform a GC.
   // Materialize any objects that were deferred by FillFrame because they
   // require allocation.
   __ EnterFrame(0);
+  if (preserve_rax) {
+    __ pushq(RAX);  // Preserve result, it will be GC-d here.
+  }
   __ CallRuntime(kDeoptimizeMaterializeDoublesRuntimeEntry);
+  if (preserve_rax) {
+    __ popq(RAX);  // Restore result.
+  }
   __ LeaveFrame();
 
   __ ret();
 }
 
 
+// TOS: return address + call-instruction-size (5 bytes).
+// RAX: result, must be preserved
+void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
+  // Correct return address to point just after the call that is being
+  // deoptimized.
+  __ popq(RBX);
+  __ subq(RBX, Immediate(ShortCallPattern::InstructionLength()));
+  __ pushq(RBX);
+  GenerateDeoptimizationSequence(assembler, true);  // Preserve RAX.
+}
+
+
+void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
+  GenerateDeoptimizationSequence(assembler, false);  // Don't preserve RAX.
+}
+
+
 // Called for inline allocation of arrays.
 // Input parameters:
 //   R10 : Array length as Smi.
 //   RBX : array element type (either NULL or an instantiated type).
 // NOTE: R10 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in RAX.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 1311 matching lines @@
 void StubCode::GenerateJumpToErrorHandlerStub(Assembler* assembler) {
   __ movq(RAX, RCX);  // error object.
   __ movq(RBP, RDX);  // target frame_pointer.
   __ movq(RSP, RSI);  // target stack_pointer.
   __ jmp(RDI);  // Jump to the exception handler code.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64