Uses an object pool on x64

runtime/vm/stub_code_x64.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_X64)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 65 matching lines @@
   __ movq(Address(RSP, retval_offset), RAX);  // Set retval in NativeArguments.
   __ call(RBX);
 
   // Reset exit frame information in Isolate structure.
   __ movq(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into RBX.
   __ movq(RBX, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ movq(Address(CTX, Isolate::top_context_offset()), raw_null);
+  __ LoadObject(R12, Object::Handle(), PP);
+  __ movq(Address(CTX, Isolate::top_context_offset()), R12);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movq(CTX, RBX);
 
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Print the stop message.
@@ skipping 66 matching lines @@
   __ movq(RSI, RBX);  // Pass pointer to function entrypoint.
   __ call(&NativeEntry::NativeCallWrapperLabel());
 
   // Reset exit frame information in Isolate structure.
   __ movq(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into R8.
   __ movq(R8, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ movq(Address(CTX, Isolate::top_context_offset()), raw_null);
+  __ LoadObject(R12, Object::Handle(), PP);
+  __ movq(Address(CTX, Isolate::top_context_offset()), R12);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movq(CTX, R8);
 
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
@@ skipping 45 matching lines @@
   __ movq(RDI, RSP);  // Pass the pointer to the NativeArguments.
   __ call(RBX);
 
   // Reset exit frame information in Isolate structure.
   __ movq(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into R8.
   __ movq(R8, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ movq(Address(CTX, Isolate::top_context_offset()), raw_null);
+  __ LoadObject(R12, Object::Handle(), PP);
+  __ movq(Address(CTX, Isolate::top_context_offset()), R12);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movq(CTX, R8);
 
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   R10: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
   __ pushq(R10);  // Preserve arguments descriptor array.
-  __ pushq(raw_null);  // Setup space on stack for return value.
+  // Setup space on stack for return value.
+  __ PushObject(Object::Handle());
   __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
   __ popq(RAX);  // Get Code object result.
   __ popq(R10);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ movq(RBX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RBX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RBX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // R10: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
   __ pushq(R10);  // Preserve arguments descriptor array.
-  __ pushq(raw_null);  // Setup space on stack for return value.
+  // Setup space on stack for return value.
+  __ PushObject(Object::Handle());
   __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   __ popq(RAX);  // Get Code object.
   __ popq(R10);  // Restore arguments descriptor array.
   __ movq(RAX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(RAX);
   __ int3();
 }
 
 
 // Input parameters:
 //   R10: smi-tagged argument count, may be zero.
 //   RBP[kParamEndSlotFromFp + 1]: last argument.
 static void PushArgumentsArray(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-
+  __ LoadObject(R12, Object::Handle(), PP);
   // Allocate array to store arguments of caller.
-  __ movq(RBX, raw_null);  // Null element type for raw Array.
+  __ movq(RBX, R12);  // Null element type for raw Array.
   __ call(&StubCode::AllocateArrayLabel());
   __ SmiUntag(R10);
   // RAX: newly allocated array.
   // R10: length of the array (was preserved by the stub).
   __ pushq(RAX);  // Array is in RAX and on top of stack.
   __ leaq(R12, Address(RBP, R10, TIMES_8, kParamEndSlotFromFp * kWordSize));
   __ leaq(RBX, FieldAddress(RAX, Array::data_offset()));
   // R12: address of first argument on stack.
   // RBX: address of first argument in array.
   Label loop, loop_condition;
   __ jmp(&loop_condition, Assembler::kNearJump);
   __ Bind(&loop);
   __ movq(RAX, Address(R12, 0));
   __ movq(Address(RBX, 0), RAX);
   __ AddImmediate(RBX, Immediate(kWordSize));
   __ AddImmediate(R12, Immediate(-kWordSize));
   __ Bind(&loop_condition);
   __ decq(R10);
   __ j(POSITIVE, &loop, Assembler::kNearJump);
 }
 
 
 // Input parameters:
 //   RBX: ic-data.
 //   R10: arguments descriptor array.
 // Note: The receiver object is the first argument to the function being
 //       called, the stub accesses the receiver from this location directly
 //       when trying to resolve the call.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
-  __ EnterStubFrame();
-
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ pushq(raw_null);  // Space for the return value.
+  __ EnterStubFrameWithPP();
+  __ PushObject(Object::Handle());  // Space for the return value.
 
   // Push the receiver as an argument.  Load the smi-tagged argument
   // count into R13 to index the receiver in the stack.  There are
-  // three words (null, stub's pc marker, saved fp) above the return
+  // four words (null, stub's pc marker, saved pp, saved fp) above the return
   // address.
   __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
-  __ pushq(Address(RSP, R13, TIMES_4, (3 * kWordSize)));
+  __ pushq(Address(RSP, R13, TIMES_4, (4 * kWordSize)));
 
   __ pushq(RBX);  // Pass IC data object.
   __ pushq(R10);  // Pass arguments descriptor array.
 
   // Pass the call's arguments array.
   __ movq(R10, R13);  // Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
   __ CallRuntime(kInstanceFunctionLookupRuntimeEntry, 4);
 
   // Remove arguments.
   __ Drop(4);
   __ popq(RAX);  // Get result into RAX.
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
   __ 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 RAX 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 after EnterDartFrame(0) below:
+// Stack after EnterDartFrame(0, PP, kNoRegister) below:
+//   +------------------+
+//   | Saved PP         | <- PP
 //   +------------------+
 //   | PC marker        | <- TOS
 //   +------------------+
 //   | Saved FP         | <- FP of stub
 //   +------------------+
 //   | return-address   |  (deoptimization point)
 //   +------------------+
 //   | ...              | <- SP of optimized frame
 //
 // Parts of the code cannot GC, part of the code can GC.
 static void GenerateDeoptimizationSequence(Assembler* assembler,
                                            bool preserve_result) {
-  // Leaf runtime function DeoptimizeCopyFrame expects a Dart frame.
-  __ EnterDartFrame(0);
+  // DeoptimizeCopyFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
+  // is no need to set the correct PC marker or load PP, since they get patched.
+  __ EnterFrame(0);
+  __ pushq(Immediate(0));
+  __ pushq(PP);
+
   // The code in this frame may not cause GC. kDeoptimizeCopyFrameRuntimeEntry
   // and kDeoptimizeFillFrameRuntimeEntry are leaf runtime calls.
   const intptr_t saved_result_slot_from_fp =
       kFirstLocalSlotFromFp + 1 - (kNumberOfCpuRegisters - RAX);
   // Result in RAX 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 * kFpuRegisterSize));
   intptr_t offset = 0;
   for (intptr_t reg_idx = 0; reg_idx < kNumberOfXmmRegisters; ++reg_idx) {
     XmmRegister xmm_reg = static_cast<XmmRegister>(reg_idx);
     __ movups(Address(RSP, offset), xmm_reg);
     offset += kFpuRegisterSize;
   }
 
   __ movq(RDI, RSP);  // Pass address of saved registers block.
   __ ReserveAlignedFrameSpace(0);
   __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
   // Result (RAX) is stack-size (FP - SP) in bytes.
 
   if (preserve_result) {
     // Restore result into RBX temporarily.
     __ movq(RBX, Address(RBP, saved_result_slot_from_fp * kWordSize));
   }
 
+  // There is a Dart Frame on the stack. We just need the PP.
+  __ movq(PP, Address(RBP, -2 * kWordSize));
   __ LeaveFrame();
+
   __ popq(RCX);   // Preserve return address.
   __ movq(RSP, RBP);  // Discard optimized frame.
   __ subq(RSP, RAX);  // Reserve space for deoptimized frame.
   __ pushq(RCX);  // Restore return address.
 
-  // Leaf runtime function DeoptimizeFillFrame expects a Dart frame.
-  __ EnterDartFrame(0);
+  // DeoptimizeFillFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
+  // is no need to set the correct PC marker or load PP, since they get patched.
+  __ EnterFrame(0);
+  __ pushq(Immediate(0));
+  __ pushq(PP);
+
   if (preserve_result) {
     __ pushq(RBX);  // Preserve result as first local.
   }
   __ ReserveAlignedFrameSpace(0);
   __ movq(RDI, RBP);  // Pass last FP as parameter in RDI.
   __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry, 1);
   if (preserve_result) {
     // Restore result into RBX.
     __ movq(RBX, Address(RBP, kFirstLocalSlotFromFp * kWordSize));
   }
   // Code above cannot cause GC.
+  // There is a Dart Frame on the stack. We just need the PP.
+  __ movq(PP, Address(RBP, -2 * kWordSize));
   __ LeaveFrame();
 
   // 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) {
     __ pushq(RBX);  // Preserve result, it will be GC-d here.
   }
   __ pushq(Immediate(Smi::RawValue(0)));  // Space for the result.
@@ skipping 25 matching lines @@
   GenerateDeoptimizationSequence(assembler, true);  // Preserve RAX.
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   GenerateDeoptimizationSequence(assembler, false);  // Don't preserve RAX.
 }
 
 
 void StubCode::GenerateMegamorphicMissStub(Assembler* assembler) {
-  __ EnterStubFrame();
+  __ EnterStubFrameWithPP();
   // Load the receiver into RAX.  The argument count in the arguments
   // descriptor in R10 is a smi.
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
-  // Two words (saved fp, stub's pc marker) in the stack above the return
-  // address.
-  __ movq(RAX, Address(RSP, RAX, TIMES_4, 2 * kWordSize));
+  // Three words (saved pp, saved fp, stub's pc marker)
+  // in the stack above the return address.
+  __ movq(RAX, Address(RSP, RAX, TIMES_4,
+                       kSavedAboveReturnAddress * kWordSize));
   // Preserve IC data and arguments descriptor.
   __ pushq(RBX);
   __ pushq(R10);
 
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Instructions::null()));
-  __ pushq(raw_null);  // Space for the result of the runtime call.
+  // Space for the result of the runtime call.
+  __ PushObject(Object::Handle());
   __ pushq(RAX);  // Receiver.
   __ pushq(RBX);  // IC data.
   __ pushq(R10);  // Arguments descriptor.
   __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
   // Discard arguments.
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);  // Return value from the runtime call (instructions).
   __ popq(R10);  // Restore arguments descriptor.
   __ popq(RBX);  // Restore IC data.
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
 
   Label lookup;
-  __ cmpq(RAX, raw_null);
+  __ CompareObject(RAX, Object::Handle());
   __ j(EQUAL, &lookup, Assembler::kNearJump);
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RAX);
 
   __ Bind(&lookup);
   __ jmp(&StubCode::InstanceFunctionLookupLabel());
 }
 
 
 // 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()));
 
   if (FLAG_inline_alloc) {
     // Compute the size to be allocated, it is based on the array length
     // and is computed as:
     // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
     // Assert that length is a Smi.
     __ testq(R10, Immediate(kSmiTagMask));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
     } else {
@@ skipping 68 matching lines @@
       __ movq(FieldAddress(RAX, Array::tags_offset()), RBX);
     }
 
     // Initialize all array elements to raw_null.
     // RAX: new object start as a tagged pointer.
     // R12: new object end address.
     // R10: Array length as Smi.
     __ leaq(RBX, FieldAddress(RAX, Array::data_offset()));
     // RBX: iterator which initially points to the start of the variable
     // data area to be initialized.
+    __ LoadObject(R13, Object::Handle(), PP);
     Label done;
     Label init_loop;
     __ Bind(&init_loop);
     __ cmpq(RBX, R12);
     __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
     // TODO(cshapiro): StoreIntoObjectNoBarrier
-    __ movq(Address(RBX, 0), raw_null);
+    __ movq(Address(RBX, 0), R13);
     __ addq(RBX, Immediate(kWordSize));
     __ jmp(&init_loop, Assembler::kNearJump);
     __ Bind(&done);
 
     // Done allocating and initializing the array.
     // RAX: new object.
     // R10: Array length as Smi (preserved for the caller.)
     __ ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
-  __ pushq(raw_null);  // Setup space on stack for return value.
+  // Setup space on stack for return value.
+  __ PushObject(Object::Handle());
   __ pushq(R10);  // Array length as Smi.
   __ pushq(RBX);  // Element type.
   __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   __ popq(RAX);  // Pop element type argument.
   __ popq(R10);  // Pop array length argument.
   __ popq(RAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   R10: Arguments descriptor array.
 // Note: The closure object is the first argument to the function being
 //       called, the stub accesses the closure from this location directly
 //       when trying to resolve the call.
 void StubCode::GenerateCallClosureFunctionStub(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-
   // Load num_args.
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   // Load closure object in R13.
   __ movq(R13, Address(RSP, RAX, TIMES_4, 0));  // RAX is a Smi.
 
+  __ LoadObject(R12, Object::Handle(), PP);
+
   // Verify that R13 is a closure by checking its class.
   Label not_closure;
-  __ cmpq(R13, raw_null);
+  __ cmpq(R13, R12);
   // Not a closure, but null object.
   __ j(EQUAL, &not_closure);
   __ testq(R13, Immediate(kSmiTagMask));
   __ j(ZERO, &not_closure);  // Not a closure, but a smi.
   // Verify that the class of the object is a closure class by checking that
   // class.signature_function() is not null.
   __ LoadClass(RAX, R13);
   __ movq(RAX, FieldAddress(RAX, Class::signature_function_offset()));
-  __ cmpq(RAX, raw_null);
+  __ cmpq(RAX, R12);
   // Actual class is not a closure class.
   __ j(EQUAL, &not_closure, Assembler::kNearJump);
 
   // RAX is just the signature function. Load the actual closure function.
   __ movq(RBX, FieldAddress(R13, Closure::function_offset()));
 
   // Load closure context in CTX; note that CTX has already been preserved.
   __ movq(CTX, FieldAddress(R13, Closure::context_offset()));
 
   // Load closure function code in RAX.
   __ movq(RAX, FieldAddress(RBX, Function::code_offset()));
-  __ cmpq(RAX, raw_null);
+  __ cmpq(RAX, R12);
   Label function_compiled;
   __ j(NOT_EQUAL, &function_compiled, Assembler::kNearJump);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   __ pushq(R10);  // Preserve arguments descriptor array.
   __ pushq(RBX);  // Preserve read-only function object argument.
   __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
@@ skipping 18 matching lines @@
   // Call runtime to attempt to resolve and invoke a call method on a
   // non-closure object, passing the non-closure object and its arguments array,
   // returning here.
   // If no call method exists, throw a NoSuchMethodError.
   // R13: non-closure object.
   // R10: arguments descriptor array.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
-
-  __ pushq(raw_null);  // Setup space on stack for result from call.
+  // Setup space on stack for result from call.
+  __ pushq(R12);
   __ pushq(R10);  // Arguments descriptor.
   // Load smi-tagged arguments array length, including the non-closure.
   __ movq(R10, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   PushArgumentsArray(assembler);
 
   __ CallRuntime(kInvokeNonClosureRuntimeEntry, 2);
 
   // Remove arguments.
   __ Drop(2);
   __ popq(RAX);  // Get result into RAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RSP : points to return address.
 //   RDI : entrypoint of the Dart function to call.
 //   RSI : arguments descriptor array.
 //   RDX : arguments array.
 //   RCX : new context containing the current isolate pointer.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   // Save frame pointer coming in.
-  __ EnterFrame(0);
+  __ EnterStubFrame();
 
   // Save arguments descriptor array and new context.
-  const intptr_t kArgumentsDescOffset = -1 * kWordSize;
+  const intptr_t kArgumentsDescOffset = -2 * kWordSize;
   __ pushq(RSI);
-  const intptr_t kNewContextOffset = -2 * kWordSize;
+  const intptr_t kNewContextOffset = -3 * kWordSize;
   __ pushq(RCX);
 
   // Save C++ ABI callee-saved registers.
   __ pushq(RBX);
   __ pushq(R12);
   __ pushq(R13);
   __ pushq(R14);
   __ pushq(R15);
 
   // The new Context structure contains a pointer to the current Isolate
   // structure. Cache the Context pointer in the CTX register so that it is
   // available in generated code and calls to Isolate::Current() need not be
   // done. The assumption is that this register will never be clobbered by
   // compiled or runtime stub code.
 
   // Cache the new Context pointer into CTX while executing Dart code.
   __ movq(CTX, Address(RCX, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load Isolate pointer from Context structure into R8.
   __ movq(R8, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save the top exit frame info. Use RAX as a temporary register.
   // StackFrameIterator reads the top exit frame info saved in this frame.
   // The constant kExitLinkSlotFromEntryFp must be kept in sync with the
   // code below.
-  ASSERT(kExitLinkSlotFromEntryFp == -8);
+  ASSERT(kExitLinkSlotFromEntryFp == -9);
   __ movq(RAX, Address(R8, Isolate::top_exit_frame_info_offset()));
   __ pushq(RAX);
   __ movq(Address(R8, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Save the old Context pointer. Use RAX as a temporary register.
   // Note that VisitObjectPointers will find this saved Context pointer during
   // GC marking, since it traverses any information between SP and
   // FP - kExitLinkSlotFromEntryFp * kWordSize.
   // EntryFrame::SavedContext reads the context saved in this frame.
   // The constant kSavedContextSlotFromEntryFp must be kept in sync with
   // the code below.
-  ASSERT(kSavedContextSlotFromEntryFp == -9);
+  ASSERT(kSavedContextSlotFromEntryFp == -10);
   __ movq(RAX, Address(R8, Isolate::top_context_offset()));
   __ pushq(RAX);
 
   // Load arguments descriptor array into R10, which is passed to Dart code.
   __ movq(R10, Address(RSI, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load number of arguments into RBX.
   __ movq(RBX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ SmiUntag(RBX);
 
@@ skipping 56 matching lines @@
   __ ret();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 // R10: number of context variables.
 // Output:
 // RAX: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  __ LoadObject(R12, Object::Handle(), PP);
   if (FLAG_inline_alloc) {
     const Class& context_class = Class::ZoneHandle(Object::context_class());
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     // First compute the rounded instance size.
     // R10: number of context variables.
     intptr_t fixed_size = (sizeof(RawContext) + kObjectAlignment - 1);
     __ leaq(R13, Address(R10, TIMES_8, fixed_size));
     __ andq(R13, Immediate(-kObjectAlignment));
 
@@ skipping 54 matching lines @@
     __ movq(FieldAddress(RAX, Context::num_variables_offset()), R10);
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into R13.
     // RAX: new object.
     // R10: number of context variables.
     __ movq(R13, FieldAddress(CTX, Context::isolate_offset()));
     // R13: Isolate, not an object.
     __ movq(FieldAddress(RAX, Context::isolate_offset()), R13);
 
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
     // Setup the parent field.
     // RAX: new object.
     // R10: number of context variables.
-    __ movq(FieldAddress(RAX, Context::parent_offset()), raw_null);
+    __ movq(FieldAddress(RAX, Context::parent_offset()), R12);
 
     // Initialize the context variables.
     // RAX: new object.
     // R10: number of context variables.
     {
       Label loop, entry;
       __ leaq(R13, FieldAddress(RAX, Context::variable_offset(0)));
 
       __ jmp(&entry, Assembler::kNearJump);
       __ Bind(&loop);
       __ decq(R10);
-      __ movq(Address(R13, R10, TIMES_8, 0), raw_null);
+      __ movq(Address(R13, R10, TIMES_8, 0), R12);
       __ Bind(&entry);
       __ cmpq(R10, Immediate(0));
       __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
     }
 
     // Done allocating and initializing the context.
     // RAX: new object.
     __ ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame.
   __ EnterStubFrame();
-  __ pushq(raw_null);  // Setup space on stack for the return value.
+  __ pushq(R12);  // Setup space on stack for the return value.
   __ SmiTag(R10);
   __ pushq(R10);  // Push number of context variables.
   __ CallRuntime(kAllocateContextRuntimeEntry, 1);  // Allocate context.
   __ popq(RAX);  // Pop number of context variables argument.
   __ popq(RAX);  // Pop the new context object.
   // RAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
@@ skipping 63 matching lines @@
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   RSP + 16 : type arguments object (only if class is parameterized).
 //   RSP + 8 : type arguments of instantiator (only if class is parameterized).
 //   RSP : points to return address.
 void StubCode::GenerateAllocationStubForClass(Assembler* assembler,
                                               const Class& cls) {
   const intptr_t kObjectTypeArgumentsOffset = 2 * kWordSize;
   const intptr_t kInstantiatorTypeArgumentsOffset = 1 * kWordSize;
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // The generated code is different if the class is parameterized.
   const bool is_cls_parameterized = cls.HasTypeArguments();
   ASSERT(!cls.HasTypeArguments() ||
          (cls.type_arguments_field_offset() != Class::kNoTypeArguments));
   // kInlineInstanceSize is a constant used as a threshold for determining
   // when the object initialization should be done as a loop or as
   // straight line code.
   const int kInlineInstanceSize = 12;  // In words.
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
   const intptr_t type_args_size = InstantiatedTypeArguments::InstanceSize();
+  __ LoadObject(R12, Object::Handle(), PP);
   if (FLAG_inline_alloc &&
       Heap::IsAllocatableInNewSpace(instance_size + type_args_size)) {
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     __ movq(RAX, Immediate(heap->TopAddress()));
     __ movq(RAX, Address(RAX, 0));
     __ leaq(RBX, Address(RAX, instance_size));
     if (is_cls_parameterized) {
       __ movq(RCX, RBX);
       // A new InstantiatedTypeArguments object only needs to be allocated if
@@ skipping 63 matching lines @@
     // RBX: next object start.
     // RDI: new object type arguments (if is_cls_parameterized).
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     __ movq(Address(RAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the remaining words of the object.
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
-
     // RAX: new object start.
     // RBX: next object start.
     // RDI: new object type arguments (if is_cls_parameterized).
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
       for (intptr_t current_offset = sizeof(RawObject);
            current_offset < instance_size;
            current_offset += kWordSize) {
-        __ movq(Address(RAX, current_offset), raw_null);
+        __ movq(Address(RAX, current_offset), R12);
       }
     } else {
       __ leaq(RCX, Address(RAX, sizeof(RawObject)));
       // Loop until the whole object is initialized.
       // RAX: new object.
       // RBX: next object start.
       // RCX: next word to be initialized.
       // RDI: new object type arguments (if is_cls_parameterized).
       Label init_loop;
       Label done;
       __ Bind(&init_loop);
       __ cmpq(RCX, RBX);
       __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
-      __ movq(Address(RCX, 0), raw_null);
+      __ movq(Address(RCX, 0), R12);
       __ addq(RCX, Immediate(kWordSize));
       __ jmp(&init_loop, Assembler::kNearJump);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
       // RDI: new object type arguments.
       // Set the type arguments in the new object.
       __ movq(Address(RAX, cls.type_arguments_field_offset()), RDI);
     }
     // Done allocating and initializing the instance.
     // RAX: new object.
     __ addq(RAX, Immediate(kHeapObjectTag));
     __ ret();
 
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
     __ movq(RAX, Address(RSP, kObjectTypeArgumentsOffset));
     __ movq(RDX, Address(RSP, kInstantiatorTypeArgumentsOffset));
   }
   // Create a stub frame.
-  __ EnterStubFrame();
-  __ pushq(raw_null);  // Setup space on stack for return value.
+  __ EnterStubFrameWithPP();
+  __ pushq(R12);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushq(RAX);  // Push type arguments of object to be allocated.
     __ pushq(RDX);  // Push type arguments of instantiator.
   } else {
-    __ pushq(raw_null);  // Push null type arguments.
+    __ pushq(R12);  // Push null type arguments.
     __ pushq(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ popq(RAX);  // Pop argument (instantiator).
   __ popq(RAX);  // Pop argument (type arguments of object).
   __ popq(RAX);  // Pop argument (class of object).
   __ popq(RAX);  // Pop result (newly allocated object).
   // RAX: new object
   // Restore the frame pointer.
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
   __ ret();
 }
 
 
 // Called for inline allocation of closures.
 // Input parameters:
 //   RSP + 16 : receiver (null if not an implicit instance closure).
 //   RSP + 8 : type arguments object (null if class is not parameterized).
 //   RSP : points to return address.
 void StubCode::GenerateAllocationStubForClosure(Assembler* assembler,
                                                 const Function& func) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   ASSERT(func.IsClosureFunction());
   ASSERT(!func.IsImplicitStaticClosureFunction());
   const bool is_implicit_instance_closure =
       func.IsImplicitInstanceClosureFunction();
   const Class& cls = Class::ZoneHandle(func.signature_class());
   const bool has_type_arguments = cls.HasTypeArguments();
-  const intptr_t kTypeArgumentsOffset = 1 * kWordSize;
-  const intptr_t kReceiverOffset = 2 * kWordSize;
+
+  __ EnterStubFrameWithPP();  // Uses pool pointer to refer to function.
+  __ LoadObject(R12, Object::Handle(), PP);
+  const intptr_t kTypeArgumentsOffset = 4 * kWordSize;
+  const intptr_t kReceiverOffset = 5 * kWordSize;
   const intptr_t closure_size = Closure::InstanceSize();
   const intptr_t context_size = Context::InstanceSize(1);  // Captured receiver.
   if (FLAG_inline_alloc &&
       Heap::IsAllocatableInNewSpace(closure_size + context_size)) {
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     __ movq(RAX, Immediate(heap->TopAddress()));
     __ movq(RAX, Address(RAX, 0));
     __ leaq(R13, Address(RAX, closure_size));
     if (is_implicit_instance_closure) {
@@ skipping 22 matching lines @@
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(closure_size, tags);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     __ movq(Address(RAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the function field in the object.
     // RAX: new closure object.
     // RBX: new context object (only if is_implicit_closure).
     // R13: next object start.
-    __ LoadObject(R10, func);  // Load function of closure to be allocated.
+    // Load function of closure to be allocated.
+    __ LoadObject(R10, func, PP);
     __ movq(Address(RAX, Closure::function_offset()), R10);
 
     // Setup the context for this closure.
     if (is_implicit_instance_closure) {
       // Initialize the new context capturing the receiver.
 
       const Class& context_class = Class::ZoneHandle(Object::context_class());
       // Set the tags.
       uword tags = 0;
       tags = RawObject::SizeTag::update(context_size, tags);
       tags = RawObject::ClassIdTag::update(context_class.id(), tags);
       __ movq(Address(RBX, Context::tags_offset()), Immediate(tags));
 
       // Set number of variables field to 1 (for captured receiver).
       __ movq(Address(RBX, Context::num_variables_offset()), Immediate(1));
 
       // Set isolate field to isolate of current context.
       __ movq(R10, FieldAddress(CTX, Context::isolate_offset()));
       __ movq(Address(RBX, Context::isolate_offset()), R10);
 
       // Set the parent to null.
-      __ movq(Address(RBX, Context::parent_offset()), raw_null);
+      __ movq(Address(RBX, Context::parent_offset()), R12);
 
       // Initialize the context variable to the receiver.
       __ movq(R10, Address(RSP, kReceiverOffset));
       __ movq(Address(RBX, Context::variable_offset(0)), R10);
 
       // Set the newly allocated context in the newly allocated closure.
       __ addq(RBX, Immediate(kHeapObjectTag));
       __ movq(Address(RAX, Closure::context_offset()), RBX);
     } else {
       __ movq(Address(RAX, Closure::context_offset()), CTX);
     }
 
     // Set the type arguments field in the newly allocated closure.
     __ movq(R10, Address(RSP, kTypeArgumentsOffset));
     __ movq(Address(RAX, Closure::type_arguments_offset()), R10);
 
     // Done allocating and initializing the instance.
     // RAX: new object.
     __ addq(RAX, Immediate(kHeapObjectTag));
+    __ LeaveFrameWithPP();
     __ ret();
 
     __ Bind(&slow_case);
   }
   if (has_type_arguments) {
     __ movq(RCX, Address(RSP, kTypeArgumentsOffset));
   }
   if (is_implicit_instance_closure) {
     __ movq(RAX, Address(RSP, kReceiverOffset));
   }
-  // Create the stub frame.
-  __ EnterStubFrame();
-  __ pushq(raw_null);  // Setup space on stack for the return value.
+
+  __ pushq(R12);  // Setup space on stack for the return value.
   __ PushObject(func);
   if (is_implicit_instance_closure) {
     __ pushq(RAX);  // Receiver.
   }
   if (has_type_arguments) {
     __ pushq(RCX);  // Push type arguments of closure to be allocated.
   } else {
-    __ pushq(raw_null);  // Push null type arguments.
+    __ pushq(R12);  // Push null type arguments.
   }
   if (is_implicit_instance_closure) {
     __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry, 3);
     __ popq(RAX);  // Pop type arguments.
     __ popq(RAX);  // Pop receiver.
   } else {
     ASSERT(func.IsNonImplicitClosureFunction());
     __ CallRuntime(kAllocateClosureRuntimeEntry, 2);
     __ popq(RAX);  // Pop type arguments.
   }
   __ popq(RAX);  // Pop the function object.
   __ popq(RAX);  // Pop the result.
   // RAX: New closure object.
   // Restore the calling frame.
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
   __ ret();
 }
 
 
 // Called for invoking "dynamic noSuchMethod(Invocation invocation)" function
 // from the entry code of a dart function after an error in passed argument
 // name or number is detected.
 // Input parameters:
 //   RSP : points to return address.
 //   RSP + 8 : address of last argument.
 //   RBX : ic-data.
 //   R10 : arguments descriptor array.
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   __ EnterStubFrame();
 
   // Load the receiver.
   __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ movq(RAX, Address(RBP, R13, TIMES_4, kParamEndSlotFromFp * kWordSize));
 
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ pushq(raw_null);  // Setup space on stack for result from noSuchMethod.
+  __ LoadObject(R12, Object::Handle(), PP);
+  __ pushq(R12);  // Setup space on stack for result from noSuchMethod.
   __ pushq(RAX);  // Receiver.
   __ pushq(RBX);  // IC data array.
   __ pushq(R10);  // Arguments descriptor array.
 
   __ movq(R10, R13);  // Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
   __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry, 4);
 
   // Remove arguments.
@@ skipping 127 matching lines @@
 
   const intptr_t entry_size = ICData::TestEntryLengthFor(num_args) * kWordSize;
   __ addq(R12, Immediate(entry_size));  // Next entry.
   __ movq(R13, Address(R12, 0));  // Next class ID.
 
   __ Bind(&test);
   __ cmpq(R13, Immediate(Smi::RawValue(kIllegalCid)));  // Done?
   __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
 
   // IC miss.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  __ LoadObject(R12, Object::Handle(), PP);
   // Compute address of arguments (first read number of arguments from
   // arguments descriptor array and then compute address on the stack).
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ leaq(RAX, Address(RSP, RAX, TIMES_4, 0));  // RAX is Smi.
   __ EnterStubFrame();
   __ pushq(R10);  // Preserve arguments descriptor array.
   __ pushq(RBX);  // Preserve IC data object.
-  __ pushq(raw_null);  // Setup space on stack for result (target code object).
+  __ pushq(R12);  // Setup space on stack for result (target code object).
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ movq(RCX, Address(RAX, -kWordSize * i));
     __ pushq(RCX);
   }
   __ pushq(RBX);  // Pass IC data object.
   __ CallRuntime(handle_ic_miss, num_args + 1);
   // Remove the call arguments pushed earlier, including the IC data object.
   for (intptr_t i = 0; i < num_args + 1; i++) {
     __ popq(RAX);
   }
   __ popq(RAX);  // Pop returned code object into RAX (null if not found).
   __ popq(RBX);  // Restore IC data array.
   __ popq(R10);  // Restore arguments descriptor array.
   __ LeaveFrame();
   Label call_target_function;
-  __ cmpq(RAX, raw_null);
+  __ cmpq(RAX, R12);
   __ j(NOT_EQUAL, &call_target_function, Assembler::kNearJump);
   // NoSuchMethod or closure.
   // Mark IC call that it may be a closure call that does not collect
   // type feedback.
   __ movb(FieldAddress(RBX, ICData::is_closure_call_offset()), Immediate(1));
   __ jmp(&StubCode::InstanceFunctionLookupLabel());
 
   __ Bind(&found);
   // R12: Pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
@@ skipping 145 matching lines @@
   const intptr_t count_offset = ICData::CountIndexFor(0) * kWordSize;
 
   // Increment count for this call.
   Label increment_done;
   __ addq(Address(R12, count_offset), Immediate(Smi::RawValue(1)));
   __ j(NO_OVERFLOW, &increment_done, Assembler::kNearJump);
   __ movq(Address(R12, count_offset),
           Immediate(Smi::RawValue(Smi::kMaxValue)));
   __ Bind(&increment_done);
 
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label target_is_compiled;
   // Get function and call it, if possible.
   __ movq(R13, Address(R12, target_offset));
   __ movq(RAX, FieldAddress(R13, Function::code_offset()));
-  __ cmpq(RAX, raw_null);
+  __ LoadObject(R12, Object::Handle(), PP);
+  __ cmpq(RAX, R12);
   __ j(NOT_EQUAL, &target_is_compiled, Assembler::kNearJump);
 
   __ EnterStubFrame();
   __ pushq(R13);  // Preserve target function.
   __ pushq(RBX);  // Preserve IC data object.
   __ pushq(R13);  // Pass function.
   __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ popq(RAX);  // Discard argument.
   __ popq(RBX);  // Restore IC data object.
   __ popq(R13);  // Restore target function.
@@ skipping 19 matching lines @@
 
 //  RBX, R10: May contain arguments to runtime stub.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointRuntimeStub(Assembler* assembler) {
   __ EnterStubFrame();
   // Preserve runtime args.
   __ pushq(RBX);
   __ pushq(R10);
   // Room for result. Debugger stub returns address of the
   // unpatched runtime stub.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ pushq(raw_null);  // Room for result.
+  __ LoadObject(R12, Object::Handle(), PP);
+  __ pushq(R12);  // Room for result.
   __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry, 0);
   __ popq(RAX);  // Address of original.
   __ popq(R10);  // Restore arguments.
   __ popq(RBX);
   __ LeaveFrame();
   __ jmp(RAX);   // Jump to original stub.
 }
 
 
 //  RBX: ICData (unoptimized static call)
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
+  __ LoadObject(R12, Object::Handle(), PP);
   __ pushq(RBX);  // Preserve IC data for unoptimized call.
-  __ pushq(raw_null);  // Room for result.
+  __ pushq(R12);  // Room for result.
   __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry, 0);
   __ popq(RAX);  // Code object.
   __ popq(RBX);  // Restore IC data.
   __ LeaveFrame();
 
   // Load arguments descriptor into R10.
   __ movq(R10, FieldAddress(RBX, ICData::arguments_descriptor_offset()));
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ movq(RBX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RBX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RBX);
 }
 
 
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   __ EnterStubFrame();
   __ pushq(RAX);
   __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry, 0);
   __ popq(RAX);
   __ LeaveFrame();
 
   __ popq(R11);  // discard return address of call to this stub.
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
   __ ret();
 }
 
 
 //  RBX: Inline cache data array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   __ EnterStubFrame();
   __ pushq(RBX);
   __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry, 0);
@@ skipping 20 matching lines @@
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
 // TOS + 1: instantiator type arguments (can be NULL).
 // TOS + 2: instance.
 // TOS + 3: SubtypeTestCache.
 // Result in RCX: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
   ASSERT((1 <= n) && (n <= 3));
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   const intptr_t kInstantiatorTypeArgumentsInBytes = 1 * kWordSize;
   const intptr_t kInstanceOffsetInBytes = 2 * kWordSize;
   const intptr_t kCacheOffsetInBytes = 3 * kWordSize;
   __ movq(RAX, Address(RSP, kInstanceOffsetInBytes));
+  __ LoadObject(R12, Object::Handle(), PP);
   if (n > 1) {
     __ LoadClass(R10, RAX);
     // Compute instance type arguments into R13.
     Label has_no_type_arguments;
-    __ movq(R13, raw_null);
+    __ movq(R13, R12);
     __ movq(RDI, FieldAddress(R10,
         Class::type_arguments_field_offset_in_words_offset()));
     __ cmpq(RDI, Immediate(Class::kNoTypeArguments));
     __ j(EQUAL, &has_no_type_arguments, Assembler::kNearJump);
     __ movq(R13, FieldAddress(RAX, RDI, TIMES_8, 0));
     __ Bind(&has_no_type_arguments);
   }
   __ LoadClassId(R10, RAX);
   // RAX: instance, R10: instance class id.
   // R13: instance type arguments or null, used only if n > 1.
   __ movq(RDX, Address(RSP, kCacheOffsetInBytes));
   // RDX: SubtypeTestCache.
   __ movq(RDX, FieldAddress(RDX, SubtypeTestCache::cache_offset()));
   __ addq(RDX, Immediate(Array::data_offset() - kHeapObjectTag));
   // RDX: Entry start.
   // R10: instance class id.
   // R13: instance type arguments.
   Label loop, found, not_found, next_iteration;
   __ SmiTag(R10);
   __ Bind(&loop);
   __ movq(RDI, Address(RDX, kWordSize * SubtypeTestCache::kInstanceClassId));
-  __ cmpq(RDI, raw_null);
+  __ cmpq(RDI, R12);
   __ j(EQUAL, &not_found, Assembler::kNearJump);
   __ cmpq(RDI, R10);
   if (n == 1) {
     __ j(EQUAL, &found, Assembler::kNearJump);
   } else {
     __ j(NOT_EQUAL, &next_iteration, Assembler::kNearJump);
     __ movq(RDI,
         Address(RDX, kWordSize * SubtypeTestCache::kInstanceTypeArguments));
     __ cmpq(RDI, R13);
     if (n == 2) {
       __ j(EQUAL, &found, Assembler::kNearJump);
     } else {
       __ j(NOT_EQUAL, &next_iteration, Assembler::kNearJump);
       __ movq(RDI,
           Address(RDX,
                   kWordSize * SubtypeTestCache::kInstantiatorTypeArguments));
       __ cmpq(RDI, Address(RSP, kInstantiatorTypeArgumentsInBytes));
       __ j(EQUAL, &found, Assembler::kNearJump);
     }
   }
 
   __ Bind(&next_iteration);
   __ addq(RDX, Immediate(kWordSize * SubtypeTestCache::kTestEntryLength));
   __ jmp(&loop, Assembler::kNearJump);
   // Fall through to not found.
   __ Bind(&not_found);
-  __ movq(RCX, raw_null);
+  __ movq(RCX, R12);
   __ ret();
 
   __ Bind(&found);
   __ movq(RCX, Address(RDX, kWordSize * SubtypeTestCache::kTestResult));
   __ ret();
 }
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
@@ skipping 112 matching lines @@
   __ addq(Address(R12, count_offset), Immediate(Smi::RawValue(1)));
   __ j(NO_OVERFLOW, &compute_result);
   __ movq(Address(R12, count_offset),
           Immediate(Smi::RawValue(Smi::kMaxValue)));
 
   __ Bind(&compute_result);
   Label true_label;
   __ movq(RAX, Address(RSP, 1 * kWordSize));
   __ cmpq(RAX, Address(RSP, 2 * kWordSize));
   __ j(EQUAL, &true_label, Assembler::kNearJump);
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObject(RAX, Bool::False(), PP);
   __ ret();
   __ Bind(&true_label);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObject(RAX, Bool::True(), PP);
   __ ret();
 
   __ Bind(&get_class_id_as_smi);
   Label not_smi;
   // Test if Smi -> load Smi class for comparison.
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &not_smi, Assembler::kNearJump);
   __ movq(RAX, Immediate(Smi::RawValue(kSmiCid)));
   __ ret();
 
   __ Bind(&not_smi);
   __ LoadClassId(RAX, RAX);
   __ SmiTag(RAX);
   __ ret();
 
   __ Bind(&update_ic_data);
 
-  // RCX: ICData
+  // RBX: ICData
   __ movq(RAX, Address(RSP, 1 * kWordSize));
   __ movq(R13, Address(RSP, 2 * kWordSize));
   __ EnterStubFrame();
   __ pushq(R13);  // arg 0
   __ pushq(RAX);  // arg 1
   __ PushObject(Symbols::EqualOperator());  // Target's name.
   __ pushq(RBX);  // ICData
   __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry, 4);
   __ Drop(4);
   __ LeaveFrame();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 // Calls to the runtime to optimize the given function.
 // RDI: function to be reoptimized.
 // R10: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ EnterStubFrame();
+  __ EnterStubFrameWithPP();
+  __ LoadObject(R12, Object::Handle(), PP);
   __ pushq(R10);
-  __ pushq(raw_null);  // Setup space on stack for return value.
+  __ pushq(R12);  // Setup space on stack for return value.
   __ pushq(RDI);
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
   __ popq(RAX);  // Disard argument.
   __ popq(RAX);  // Get Code object.
   __ popq(R10);  // Restore argument descriptor.
   __ movq(RAX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
   __ jmp(RAX);
   __ int3();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t,
                            BigintCompare,
                            RawBigint* left,
                            RawBigint* right);
 
@@ skipping 102 matching lines @@
   __ movq(right, Address(RSP, 3 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right);
   __ popq(right);
   __ popq(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64