Cleanup deoptimization code to make it architecture independent (in progress).

runtime/vm/stub_code_arm.cc

 // Copyright (c) 2013, 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_ARM)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 315 matching lines @@
 // - 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 after EnterFrame(...) below:
 //   +------------------+
 //   | Saved FP         | <- TOS
 //   +------------------+
-//   | return-address   |  (deoptimization point)
+//   | Saved LR         |  (deoptimization point)
 //   +------------------+
-//   | optimized frame  |
+//   | stub pc marker   |  (necessary to keep constant offset SP - Saved LR.
+//   +------------------+
+//   | optimized frame  | <- SP of optimized code
 //   |  ...             |
 //
 // Parts of the code cannot GC, part of the code can GC.
 static void GenerateDeoptimizationSequence(Assembler* assembler,
                                            bool preserve_result) {
-  __ EnterFrame((1 << FP) | (1 << LR), 0);
+  __ EnterStubFrame();  // Do not save pp (implicit saved regs to fp offset).
   // The code in this frame may not cause GC. kDeoptimizeCopyFrameRuntimeEntry
   // and kDeoptimizeFillFrameRuntimeEntry are leaf runtime calls.
   const intptr_t saved_r0_offset_from_fp = -(kNumberOfCpuRegisters - R0);
   // Result in R0 is preserved as part of pushing all registers below.
 
+  // TODO(regis): Should we align the stack before pushing the fpu registers?
+  // If we do, saved_r0_offset_from_fp is not constant anymore.
+
   // Push registers in their enumeration order: lowest register number at
   // lowest address.
   __ PushList(kAllCpuRegistersList);
   ASSERT(kFpuRegisterSize == 2 * kWordSize);
   __ vstmd(DB_W, SP, D0, static_cast<DRegister>(kNumberOfDRegisters - 1));
 
   __ mov(R0, ShifterOperand(SP));  // Pass address of saved registers block.
   __ ReserveAlignedFrameSpace(0);
   __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry);
   // Result (R0) is stack-size (FP - SP) in bytes, incl. the return address.
 
   if (preserve_result) {
     // Restore result into R1 temporarily.
     __ ldr(R1, Address(FP, saved_r0_offset_from_fp * kWordSize));
   }
 
-  __ LeaveFrame((1 << FP) | (1 << LR));
+  __ LeaveStubFrame();  // Restores FP and LR from stack.
   __ sub(SP, FP, ShifterOperand(R0));
 
-  __ EnterFrame((1 << FP) | (1 << LR), 0);
+  __ EnterStubFrame();
   __ mov(R0, ShifterOperand(SP));  // Get last FP address.
   if (preserve_result) {
     __ Push(R1);  // Preserve result.
   }
   __ ReserveAlignedFrameSpace(0);
   __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry);  // Pass last FP in R0.
   // Result (R0) is our FP.
   if (preserve_result) {
     // Restore result into R1.
     __ ldr(R1, Address(FP, -1 * kWordSize));
   }
   // Code above cannot cause GC.
-  __ LeaveFrame((1 << FP) | (1 << LR));
+  __ LeaveStubFrame();
   __ mov(FP, ShifterOperand(R0));
 
   // 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.
   __ EnterStubFrame();
   if (preserve_result) {
     __ Push(R1);  // Preserve result, it will be GC-d here.
   }
   __ CallRuntime(kDeoptimizeMaterializeDoublesRuntimeEntry);
   if (preserve_result) {
     __ Pop(R0);  // Restore result.
   }
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
-  __ Unimplemented("DeoptimizeLazy stub");
+  // Correct return address to point just after the call that is being
+  // deoptimized.
+  __ AddImmediate(LR, -CallPattern::kFixedLengthInBytes);
+  GenerateDeoptimizationSequence(assembler, true);  // Preserve R0.
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   GenerateDeoptimizationSequence(assembler, false);  // Don't preserve R0.
 }
 
 
 void StubCode::GenerateMegamorphicMissStub(Assembler* assembler) {
   __ Unimplemented("MegamorphicMiss stub");
@@ skipping 1489 matching lines @@
   __ Bind(&reference_compare);
   __ cmp(left, ShifterOperand(right));
   __ Bind(&done);
   __ PopList((1 << R0) | (1 << R1) | (1 << R2));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM