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

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2011, 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_IA32)
 
 #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 452 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);
 
+
+// Used by eager and lazy deoptimization. Preserve result in EAX if necessary.
 // 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         |
+//   | Saved FP         | <- TOS
 //   +------------------+
 //   | 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_eax) {
   __ EnterFrame(0);
+  const intptr_t saved_eax_offset_from_ebp = -(kNumberOfCpuRegisters - EAX);
+  // 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--) {
     __ pushl(static_cast<Register>(i));
   }
   __ subl(ESP, 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(ESP, offset), xmm_reg);
     offset += kDoubleSize;
   }
 
   __ movl(ECX, ESP);  // Saved saved registers block.
   __ ReserveAlignedFrameSpace(1 * kWordSize);
   __ SmiUntag(EAX);
   __ movl(Address(ESP, 0), ECX);  // Start of register block.
   __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry);
   // Result (EAX) is stack-size (FP - SP) in bytes, incl. the return address.
+
+  if (preserve_eax) {
+    // Restore result into EBX temporarily.
+    __ movl(EBX, Address(EBP, saved_eax_offset_from_ebp * kWordSize));
+  }
+
   __ LeaveFrame();
   __ popl(EDX);  // Preserve return address.
   __ movl(ESP, EBP);
   __ subl(ESP, EAX);
   __ movl(Address(ESP, 0), EDX);
 
   __ EnterFrame(0);
   __ movl(ECX, ESP);  // Get last FP address.
+  if (preserve_eax) {
+    __ pushl(EBX);  // Preserve result.
+  }
   __ ReserveAlignedFrameSpace(1 * kWordSize);
   __ movl(Address(ESP, 0), ECX);
   __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry);
+
+  if (preserve_eax) {
+    // Restore result into EAX.
+    __ movl(EAX, Address(EBP, -1 * kWordSize));
+  }
   __ LeaveFrame();

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

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_eax) {
+    __ pushl(EAX);  // Preserve result, it will be GC-d here.
+  }
   __ CallRuntime(kDeoptimizeMaterializeDoublesRuntimeEntry);
+  if (preserve_eax) {
+    __ popl(EAX);  // Restore result.
+  }
   __ LeaveFrame();
   __ ret();
 }
 
+// TOS: return address + call-instruction-size (5 bytes).
+// EAX: result, must be preserved
+void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
+  // Correct return address to point just after the call that is being
+  // deoptimized.
+  __ popl(EBX);
+  __ subl(EBX, Immediate(CallPattern::InstructionLength()));
+  __ pushl(EBX);
+  GenerateDeoptimizationSequence(assembler, true);  // Preserve EAX.
+}
+
+
+void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
+  GenerateDeoptimizationSequence(assembler, false);  // Don't preserve EAX.
+}
+
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   EDX : Array length as Smi.
 //   ECX : array element type (either NULL or an instantiated type).
 // Uses EAX, EBX, ECX, EDI  as temporary registers.
 // NOTE: EDX cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in EAX.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
@@ skipping 1346 matching lines @@
   __ movl(EAX, Address(ESP, 4 * kWordSize));  // Load error object.
   __ movl(EBP, Address(ESP, 3 * kWordSize));  // Load target frame_pointer.
   __ movl(EBX, Address(ESP, 1 * kWordSize));  // Load target PC into EBX.
   __ movl(ESP, Address(ESP, 2 * kWordSize));  // Load target stack_pointer.
   __ jmp(EBX);  // Jump to the exception handler code.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32