Uses an object pool on x64

runtime/vm/flow_graph_compiler_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"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 48 matching lines @@
   intptr_t slot_ix = 0;
   Environment* current = deopt_env_;
 
   // Emit all kMaterializeObject instructions describing objects to be
   // materialized on the deoptimization as a prefix to the deoptimization info.
   EmitMaterializations(deopt_env_, builder);
 
   // The real frame starts here.
   builder->MarkFrameStart();
 
-  // Callee's PC marker is not used anymore. Pass Function::null() to set to 0.
+  // Current PP, FP, and PC.
+  builder->AddPp(current->function(), slot_ix++);
   builder->AddPcMarker(Function::Handle(), slot_ix++);
-
-  // Current FP and PC.
   builder->AddCallerFp(slot_ix++);
   builder->AddReturnAddress(current->function(), deopt_id(), slot_ix++);
 
   // Emit all values that are needed for materialization as a part of the
   // expression stack for the bottom-most frame. This guarantees that GC
   // will be able to find them during materialization.
   slot_ix = builder->EmitMaterializationArguments(slot_ix);
 
   // For the innermost environment, set outgoing arguments and the locals.
   for (intptr_t i = current->Length() - 1;
        i >= current->fixed_parameter_count();
        i--) {
     builder->AddCopy(current->ValueAt(i), current->LocationAt(i), slot_ix++);
   }
 
-  // Current PC marker and caller FP.
-  builder->AddPcMarker(current->function(), slot_ix++);
-  builder->AddCallerFp(slot_ix++);
-
   Environment* previous = current;
   current = current->outer();
   while (current != NULL) {
+    // PP, FP, and PC.
+    builder->AddPp(current->function(), slot_ix++);
+    builder->AddPcMarker(previous->function(), slot_ix++);
+    builder->AddCallerFp(slot_ix++);
+
     // For any outer environment the deopt id is that of the call instruction
     // which is recorded in the outer environment.
     builder->AddReturnAddress(current->function(),
                               Isolate::ToDeoptAfter(current->deopt_id()),
                               slot_ix++);
 
     // The values of outgoing arguments can be changed from the inlined call so
     // we must read them from the previous environment.
     for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
       builder->AddCopy(previous->ValueAt(i),
                        previous->LocationAt(i),
                        slot_ix++);
     }
 
     // Set the locals, note that outgoing arguments are not in the environment.
     for (intptr_t i = current->Length() - 1;
          i >= current->fixed_parameter_count();
          i--) {
       builder->AddCopy(current->ValueAt(i),
                        current->LocationAt(i),
                        slot_ix++);
     }
 
-    // PC marker and caller FP.
-    builder->AddPcMarker(current->function(), slot_ix++);
-    builder->AddCallerFp(slot_ix++);
-
     // Iterate on the outer environment.
     previous = current;
     current = current->outer();
   }
   // The previous pointer is now the outermost environment.
   ASSERT(previous != NULL);
 
-  // For the outermost environment, set caller PC.
+  // For the outermost environment, set caller PC, caller PP, and caller FP.
+  builder->AddCallerPp(slot_ix++);
+  // PC marker.
+  builder->AddPcMarker(previous->function(), slot_ix++);
+  builder->AddCallerFp(slot_ix++);
   builder->AddCallerPc(slot_ix++);
 
   // For the outermost environment, set the incoming arguments.
   for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
     builder->AddCopy(previous->ValueAt(i), previous->LocationAt(i), slot_ix++);
   }
 
   const DeoptInfo& deopt_info = DeoptInfo::Handle(builder->CreateDeoptInfo());
   return deopt_info.raw();
 }
 
 
 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
                                              intptr_t stub_ix) {
   // Calls do not need stubs, they share a deoptimization trampoline.
   ASSERT(reason() != kDeoptAtCall);
   Assembler* assem = compiler->assembler();
 #define __ assem->
   __ Comment("Deopt stub for id %" Pd "", deopt_id());
   __ Bind(entry_label());
   if (FLAG_trap_on_deoptimization) __ int3();
 
   ASSERT(deopt_env() != NULL);
 
-  __ call(&StubCode::DeoptimizeLabel());
+  __ Call(&StubCode::DeoptimizeLabel(), PP);
   set_pc_offset(assem->CodeSize());
   __ int3();
 #undef __
 }
 
 
 #define __ assembler()->
 
 
 // Fall through if bool_register contains null.
 void FlowGraphCompiler::GenerateBoolToJump(Register bool_register,
                                            Label* is_true,
                                            Label* is_false) {
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label fall_through;
-  __ cmpq(bool_register, raw_null);
+  __ CompareObject(bool_register, Object::Handle());
   __ j(EQUAL, &fall_through, Assembler::kNearJump);
   __ CompareObject(bool_register, Bool::True());
   __ j(EQUAL, is_true);
   __ jmp(is_false);
   __ Bind(&fall_through);
 }
 
 
 // Clobbers RCX.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub(
     TypeTestStubKind test_kind,
     Register instance_reg,
     Register type_arguments_reg,
     Register temp_reg,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ LoadObject(temp_reg, type_test_cache);
+  __ LoadObject(temp_reg, type_test_cache, PP);
   __ pushq(temp_reg);  // Subtype test cache.
   __ pushq(instance_reg);  // Instance.
   if (test_kind == kTestTypeOneArg) {
     ASSERT(type_arguments_reg == kNoRegister);
-    __ pushq(raw_null);
-    __ call(&StubCode::Subtype1TestCacheLabel());
+    __ PushObject(Object::Handle());
+    __ Call(&StubCode::Subtype1TestCacheLabel(), PP);
   } else if (test_kind == kTestTypeTwoArgs) {
     ASSERT(type_arguments_reg == kNoRegister);
-    __ pushq(raw_null);
-    __ call(&StubCode::Subtype2TestCacheLabel());
+    __ PushObject(Object::Handle());
+    __ Call(&StubCode::Subtype2TestCacheLabel(), PP);
   } else if (test_kind == kTestTypeThreeArgs) {
     __ pushq(type_arguments_reg);
-    __ call(&StubCode::Subtype3TestCacheLabel());
+    __ Call(&StubCode::Subtype3TestCacheLabel(), PP);
   } else {
     UNREACHABLE();
   }
   // Result is in RCX: null -> not found, otherwise Bool::True or Bool::False.
   ASSERT(instance_reg != RCX);
   ASSERT(temp_reg != RCX);
   __ popq(instance_reg);  // Discard.
   __ popq(instance_reg);  // Restore receiver.
   __ popq(temp_reg);  // Discard.
   GenerateBoolToJump(RCX, is_instance_lbl, is_not_instance_lbl);
@@ skipping 124 matching lines @@
   // interfaces.
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolType()) {
     __ cmpl(kClassIdReg, Immediate(kBoolCid));
     __ j(EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
     return false;
   }
   if (type.IsFunctionType()) {
     // Check if instance is a closure.
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ LoadClassById(R13, kClassIdReg);
     __ movq(R13, FieldAddress(R13, Class::signature_function_offset()));
-    __ cmpq(R13, raw_null);
+    __ CompareObject(R13, Object::Handle());
     __ j(NOT_EQUAL, is_instance_lbl);
   }
   // Custom checking for numbers (Smi, Mint, Bigint and Double).
   // Note that instance is not Smi (checked above).
   if (type.IsSubtypeOf(Type::Handle(Type::Number()), NULL)) {
     GenerateNumberTypeCheck(
         kClassIdReg, type, is_instance_lbl, is_not_instance_lbl);
     return false;
   }
   if (type.IsStringType()) {
@@ skipping 42 matching lines @@
 // RAX: instance (preserved).
 // Clobbers RDI, RDX, R10.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   __ Comment("UninstantiatedTypeTest");
   ASSERT(!type.IsInstantiated());
   // Skip check if destination is a dynamic type.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   if (type.IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(type);
     // Load instantiator (or null) and instantiator type arguments on stack.
     __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
     // RDX: instantiator type arguments.
     // Check if type argument is dynamic.
-    __ cmpq(RDX, raw_null);
+    __ CompareObject(RDX, Object::Handle());
     __ j(EQUAL, is_instance_lbl);
     // Can handle only type arguments that are instances of TypeArguments.
     // (runtime checks canonicalize type arguments).
     Label fall_through;
     __ CompareClassId(RDX, kTypeArgumentsCid);
     __ j(NOT_EQUAL, &fall_through);
     __ movq(RDI,
         FieldAddress(RDX, TypeArguments::type_at_offset(type_param.index())));
     // RDI: Concrete type of type.
     // Check if type argument is dynamic.
     __ CompareObject(RDI, Type::ZoneHandle(Type::DynamicType()));
     __ j(EQUAL,  is_instance_lbl);
-    __ cmpq(RDI, raw_null);
+    __ CompareObject(RDI, Object::Handle());
     __ j(EQUAL,  is_instance_lbl);
     const Type& object_type = Type::ZoneHandle(Type::ObjectType());
     __ CompareObject(RDI, object_type);
     __ j(EQUAL,  is_instance_lbl);
 
     // For Smi check quickly against int and num interfaces.
     Label not_smi;
     __ testq(RAX, Immediate(kSmiTagMask));  // Value is Smi?
     __ j(NOT_ZERO, &not_smi, Assembler::kNearJump);
     __ CompareObject(RDI, Type::ZoneHandle(Type::IntType()));
@@ skipping 119 matching lines @@
 // Clobbers RCX and RDX.
 // Returns:
 // - true or false in RAX.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t token_pos,
                                            intptr_t deopt_id,
                                            const AbstractType& type,
                                            bool negate_result,
                                            LocationSummary* locs) {
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
 
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_instance, is_not_instance;
   __ pushq(RCX);  // Store instantiator on stack.
   __ pushq(RDX);  // Store instantiator type arguments.
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
     // A null object is only an instance of Object and dynamic, which has
     // already been checked above (if the type is instantiated). So we can
     // return false here if the instance is null (and if the type is
     // instantiated).
     // We can only inline this null check if the type is instantiated at compile
     // time, since an uninstantiated type at compile time could be Object or
     // dynamic at run time.
-    __ cmpq(RAX, raw_null);
+    __ CompareObject(RAX, Object::Handle());
     __ j(EQUAL, &is_not_instance);
   }
 
   // Generate inline instanceof test.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
   test_cache = GenerateInlineInstanceof(token_pos, type,
                                         &is_instance, &is_not_instance);
 
   // test_cache is null if there is no fall-through.
   Label done;
   if (!test_cache.IsNull()) {
     // Generate runtime call.
     __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
     __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
     __ PushObject(Object::ZoneHandle());  // Make room for the result.
     __ pushq(RAX);  // Push the instance.
     __ PushObject(type);  // Push the type.
     __ pushq(RCX);  // TODO(srdjan): Pass instantiator instead of null.
     __ pushq(RDX);  // Instantiator type arguments.
-    __ LoadObject(RAX, test_cache);
+    __ LoadObject(RAX, test_cache, PP);
     __ pushq(RAX);
     GenerateCallRuntime(token_pos,
                         deopt_id,
                         kInstanceofRuntimeEntry,
                         5,
                         locs);
     // Pop the parameters supplied to the runtime entry. The result of the
     // instanceof runtime call will be left as the result of the operation.
     __ Drop(5);
     if (negate_result) {
       __ popq(RDX);
-      __ LoadObject(RAX, Bool::True());
+      __ LoadObject(RAX, Bool::True(), PP);
       __ cmpq(RDX, RAX);
       __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-      __ LoadObject(RAX, Bool::False());
+      __ LoadObject(RAX, Bool::False(), PP);
     } else {
       __ popq(RAX);
     }
     __ jmp(&done, Assembler::kNearJump);
   }
   __ Bind(&is_not_instance);
-  __ LoadObject(RAX, Bool::Get(negate_result));
+  __ LoadObject(RAX, Bool::Get(negate_result), PP);
   __ jmp(&done, Assembler::kNearJump);
 
   __ Bind(&is_instance);
-  __ LoadObject(RAX, Bool::Get(!negate_result));
+  __ LoadObject(RAX, Bool::Get(!negate_result), PP);
   __ Bind(&done);
   __ popq(RDX);  // Remove pushed instantiator type arguments.
   __ popq(RCX);  // Remove pushed instantiator.
 }
 
 
 // Optimize assignable type check by adding inlined tests for:
 // - NULL -> return NULL.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
@@ skipping 12 matching lines @@
                                                  LocationSummary* locs) {
   ASSERT(token_pos >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformed() || dst_type.IsMalbounded() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
   __ pushq(RCX);  // Store instantiator.
   __ pushq(RDX);  // Store instantiator type arguments.
   // A null object is always assignable and is returned as result.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_assignable, runtime_call;
-  __ cmpq(RAX, raw_null);
+  __ CompareObject(RAX, Object::Handle());
   __ j(EQUAL, &is_assignable);
 
   if (!FLAG_eliminate_type_checks || dst_type.IsMalformed()) {
     // If type checks are not eliminated during the graph building then
     // a transition sentinel can be seen here.
     __ CompareObject(RAX, Object::transition_sentinel());
     __ j(EQUAL, &is_assignable);
   }
 
   // Generate throw new TypeError() if the type is malformed or malbounded.
@@ skipping 32 matching lines @@
 
   __ Bind(&runtime_call);
   __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
   __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(RAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   __ pushq(RCX);  // Instantiator.
   __ pushq(RDX);  // Instantiator type arguments.
   __ PushObject(dst_name);  // Push the name of the destination.
-  __ LoadObject(RAX, test_cache);
+  __ LoadObject(RAX, test_cache, PP);
   __ pushq(RAX);
   GenerateCallRuntime(token_pos, deopt_id, kTypeCheckRuntimeEntry, 6, locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(6);
   __ popq(RAX);
 
   __ Bind(&is_assignable);
   __ popq(RDX);  // Remove pushed instantiator type arguments.
   __ popq(RCX);  // Remove pushed instantiator.
@@ skipping 24 matching lines @@
 
 void FlowGraphCompiler::EmitTrySyncMove(intptr_t dest_offset,
                                         Location loc,
                                         bool* push_emitted) {
   const Address dest(RBP, dest_offset);
   if (loc.IsConstant()) {
     if (!*push_emitted) {
       __ pushq(RAX);
       *push_emitted = true;
     }
-    __ LoadObject(RAX, loc.constant());
+    __ LoadObject(RAX, loc.constant(), PP);
     __ movq(dest, RAX);
   } else if (loc.IsRegister()) {
     if (*push_emitted && loc.reg() == RAX) {
       __ movq(RAX, Address(RSP, 0));
       __ movq(dest, RAX);
     } else {
       __ movq(dest, loc.reg());
     }
   } else {
     Address src = loc.ToStackSlotAddress();
@@ skipping 109 matching lines @@
   const Address argument_addr(RBX, RCX, TIMES_8, 0);
   const Address copy_addr(RDI, RCX, TIMES_8, 0);
   __ Bind(&loop);
   __ movq(RAX, argument_addr);
   __ movq(copy_addr, RAX);
   __ Bind(&loop_condition);
   __ decq(RCX);
   __ j(POSITIVE, &loop, Assembler::kNearJump);
 
   // Copy or initialize optional named arguments.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label all_arguments_processed;
 #ifdef DEBUG
     const bool check_correct_named_args = true;
 #else
     const bool check_correct_named_args = function.IsClosureFunction();
 #endif
   if (num_opt_named_params > 0) {
     // Start by alphabetically sorting the names of the optional parameters.
     LocalVariable** opt_param = new LocalVariable*[num_opt_named_params];
     int* opt_param_position = new int[num_opt_named_params];
@@ skipping 41 matching lines @@
       __ addq(RDI, Immediate(ArgumentsDescriptor::named_entry_size()));
       __ negq(RAX);
       Address argument_addr(RBX, RAX, TIMES_4, 0);  // RAX is a negative Smi.
       __ movq(RAX, argument_addr);
       __ jmp(&assign_optional_parameter, Assembler::kNearJump);
       __ Bind(&load_default_value);
       // Load RAX with default argument.
       const Object& value = Object::ZoneHandle(
           parsed_function().default_parameter_values().At(
               param_pos - num_fixed_params));
-      __ LoadObject(RAX, value);
+      __ LoadObject(RAX, value, PP);
       __ Bind(&assign_optional_parameter);
       // Assign RAX to fp[kFirstLocalSlotFromFp - param_pos].
       // We do not use the final allocation index of the variable here, i.e.
       // scope->VariableAt(i)->index(), because captured variables still need
       // to be copied to the context that is not yet allocated.
       const intptr_t computed_param_pos = kFirstLocalSlotFromFp - param_pos;
       const Address param_addr(RBP, computed_param_pos * kWordSize);
       __ movq(param_addr, RAX);
     }
     delete[] opt_param;
     delete[] opt_param_position;
     if (check_correct_named_args) {
       // Check that RDI now points to the null terminator in the arguments
       // descriptor.
-      __ cmpq(Address(RDI, 0), raw_null);
+      __ LoadObject(TMP, Object::Handle(), PP);
+      __ cmpq(Address(RDI, 0), TMP);
       __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
     }
   } else {
     ASSERT(num_opt_pos_params > 0);
     __ movq(RCX,
             FieldAddress(R10, ArgumentsDescriptor::positional_count_offset()));
     __ SmiUntag(RCX);
     for (int i = 0; i < num_opt_pos_params; i++) {
       Label next_parameter;
       // Handle this optional positional parameter only if k or fewer positional
       // arguments have been passed, where k is param_pos, the position of this
       // optional parameter in the formal parameter list.
       const int param_pos = num_fixed_params + i;
       __ cmpq(RCX, Immediate(param_pos));
       __ j(GREATER, &next_parameter, Assembler::kNearJump);
       // Load RAX with default argument.
       const Object& value = Object::ZoneHandle(
           parsed_function().default_parameter_values().At(i));
-      __ LoadObject(RAX, value);
+      __ LoadObject(RAX, value, PP);
       // Assign RAX to fp[kFirstLocalSlotFromFp - param_pos].
       // We do not use the final allocation index of the variable here, i.e.
       // scope->VariableAt(i)->index(), because captured variables still need
       // to be copied to the context that is not yet allocated.
       const intptr_t computed_param_pos = kFirstLocalSlotFromFp - param_pos;
       const Address param_addr(RBP, computed_param_pos * kWordSize);
       __ movq(param_addr, RAX);
       __ Bind(&next_parameter);
     }
     if (check_correct_named_args) {
       __ movq(RBX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
       __ SmiUntag(RBX);
       // Check that RCX equals RBX, i.e. no named arguments passed.
       __ cmpq(RCX, RBX);
       __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
     }
   }
 
   __ Bind(&wrong_num_arguments);
   if (function.IsClosureFunction()) {
     // Invoke noSuchMethod function passing "call" as the original name.
     const int kNumArgsChecked = 1;
     const ICData& ic_data = ICData::ZoneHandle(
         ICData::New(function, Symbols::Call(), Object::empty_array(),
                     Isolate::kNoDeoptId, kNumArgsChecked));
-    __ LoadObject(RBX, ic_data);
-    __ LeaveFrame();  // The arguments are still on the stack.
+    __ LoadObject(RBX, ic_data, PP);
+    __ LeaveFrameWithPP();  // The arguments are still on the stack.
     __ jmp(&StubCode::CallNoSuchMethodFunctionLabel());
     // The noSuchMethod call may return to the caller, but not here.
     __ int3();
   } else if (check_correct_named_args) {
     __ Stop("Wrong arguments");
   }
 
   __ Bind(&all_arguments_processed);
   // Nullify originally passed arguments only after they have been copied and
   // checked, otherwise noSuchMethod would not see their original values.
   // This step can be skipped in case we decide that formal parameters are
   // implicitly final, since garbage collecting the unmodified value is not
   // an issue anymore.
 
   // R10 : arguments descriptor array.
   __ movq(RCX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ SmiUntag(RCX);
+  __ LoadObject(R12, Object::Handle(), PP);
   Label null_args_loop, null_args_loop_condition;
   __ jmp(&null_args_loop_condition, Assembler::kNearJump);
   const Address original_argument_addr(
       RBP, RCX, TIMES_8, (kParamEndSlotFromFp + 1) * kWordSize);
   __ Bind(&null_args_loop);
-  __ movq(original_argument_addr, raw_null);
+  __ movq(original_argument_addr, R12);
   __ Bind(&null_args_loop_condition);
   __ decq(RCX);
   __ j(POSITIVE, &null_args_loop, Assembler::kNearJump);
 }
 
 
 void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
   // TOS: return address.
   // +1 : receiver.
   // Sequence node has one return node, its input is load field node.
   __ movq(RAX, Address(RSP, 1 * kWordSize));
   __ movq(RAX, FieldAddress(RAX, offset));
   __ ret();
 }
 
 
 void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
   // TOS: return address.
   // +1 : value
   // +2 : receiver.
   // Sequence node has one store node and one return NULL node.
   __ movq(RAX, Address(RSP, 2 * kWordSize));  // Receiver.
   __ movq(RBX, Address(RSP, 1 * kWordSize));  // Value.
   __ StoreIntoObject(RAX, FieldAddress(RAX, offset), RBX);
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ movq(RAX, raw_null);
+  __ LoadObject(RAX, Object::Handle(), PP);
   __ ret();
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
+  Register new_pp = kNoRegister;
+  Register new_pc = kNoRegister;
   if (CanOptimizeFunction() &&
       function.is_optimizable() &&
       (!is_optimizing() || may_reoptimize())) {
     const Register function_reg = RDI;
-    __ LoadObject(function_reg, function);
+    new_pp = R13;
+    new_pc = R12;
+
+    Label next;
+    __ nop(4);  // Need a fixed size sequence on frame entry.
+    __ call(&next);
+    __ Bind(&next);
+
+    const intptr_t object_pool_pc_dist =
+        Instructions::HeaderSize() - Instructions::object_pool_offset() +
+        __ CodeSize();
+    const intptr_t offset =
+        Assembler::kEntryPointToPcMarkerOffset - __ CodeSize();
+    __ popq(new_pc);
+    if (offset != 0) {
+      __ addq(new_pc, Immediate(offset));
+    }
+
+    // Load callee's pool pointer.
+    __ movq(new_pp, Address(new_pc, -object_pool_pc_dist - offset));
+
+    // Load function object using the callee's pool pointer.
+    __ LoadObject(function_reg, function, new_pp);
+
     // Patch point is after the eventually inlined function object.
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
     if (is_optimizing()) {
       // Reoptimization of an optimized function is triggered by counting in
       // IC stubs, but not at the entry of the function.
       __ cmpq(FieldAddress(function_reg, Function::usage_counter_offset()),
               Immediate(FLAG_reoptimization_counter_threshold));
     } else {
       __ incq(FieldAddress(function_reg, Function::usage_counter_offset()));
       __ cmpq(FieldAddress(function_reg, Function::usage_counter_offset()),
               Immediate(FLAG_optimization_counter_threshold));
     }
     ASSERT(function_reg == RDI);
-    __ j(GREATER_EQUAL, &StubCode::OptimizeFunctionLabel());
+    __ J(GREATER_EQUAL, &StubCode::OptimizeFunctionLabel(), R13);
   } else if (!flow_graph().IsCompiledForOsr()) {
+    // We have to load the PP here too because a load of an external label
+    // may be patched at the AddCurrentDescriptor below.
+    new_pp = R13;
+    new_pc = R12;
+
+    Label next;
+    __ nop(4);  // Need a fixed size sequence on frame entry.
+    __ call(&next);
+    __ Bind(&next);
+
+    const intptr_t object_pool_pc_dist =
+        Instructions::HeaderSize() - Instructions::object_pool_offset() +
+        __ CodeSize();
+    const intptr_t offset =
+        Assembler::kEntryPointToPcMarkerOffset - __ CodeSize();
+    __ popq(new_pc);
+    if (offset != 0) {
+      __ addq(new_pc, Immediate(offset));
+    }
+
+    // Load callee's pool pointer.
+    __ movq(new_pp, Address(new_pc, -object_pool_pc_dist - offset));
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
   }
   __ Comment("Enter frame");
   if (flow_graph().IsCompiledForOsr()) {
     intptr_t extra_slots = StackSize()
         - flow_graph().num_stack_locals()
         - flow_graph().num_copied_params();
     ASSERT(extra_slots >= 0);
-    __ EnterOsrFrame(extra_slots * kWordSize);
+    __ EnterOsrFrame(extra_slots * kWordSize, new_pp, new_pc);
   } else {
     ASSERT(StackSize() >= 0);
-    __ EnterDartFrame(StackSize() * kWordSize);
+    __ EnterDartFrameWithInfo(StackSize() * kWordSize, new_pp, new_pc);
   }
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
 
   TryIntrinsify();
 
   EmitFrameEntry();
@@ skipping 33 matching lines @@
         // Invoke noSuchMethod function passing the original function name.
         // For closure functions, use "call" as the original name.
         const String& name =
             String::Handle(function.IsClosureFunction()
                              ? Symbols::Call().raw()
                              : function.name());
         const int kNumArgsChecked = 1;
         const ICData& ic_data = ICData::ZoneHandle(
             ICData::New(function, name, Object::empty_array(),
                         Isolate::kNoDeoptId, kNumArgsChecked));
-        __ LoadObject(RBX, ic_data);
-        __ LeaveFrame();  // The arguments are still on the stack.
+        __ LoadObject(RBX, ic_data, PP);
+        __ LeaveFrameWithPP();  // The arguments are still on the stack.
         __ jmp(&StubCode::CallNoSuchMethodFunctionLabel());
         // The noSuchMethod call may return to the caller, but not here.
         __ int3();
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&correct_num_arguments);
     }
   } else if (!flow_graph().IsCompiledForOsr()) {
     CopyParameters();
   }
 
   // In unoptimized code, initialize (non-argument) stack allocated slots to
   // null.
   if (!is_optimizing() && (num_locals > 0)) {
     __ Comment("Initialize spill slots");
     const intptr_t slot_base = parsed_function().first_stack_local_index();
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
-    __ movq(RAX, raw_null);
+    __ LoadObject(RAX, Object::Handle(), PP);
     for (intptr_t i = 0; i < num_locals; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (slot_base - i) * kWordSize), RAX);
     }
   }
 
   if (FLAG_print_scopes) {
     // Print the function scope (again) after generating the prologue in order
     // to see annotations such as allocation indices of locals.
     if (FLAG_print_ast) {
       // Second printing.
       OS::Print("Annotated ");
     }
     AstPrinter::PrintFunctionScope(parsed_function());
   }
 
   ASSERT(!block_order().is_empty());
   VisitBlocks();
 
   __ int3();
   GenerateDeferredCode();
   // Emit function patching code. This will be swapped with the first 13 bytes
   // at entry point.
   AddCurrentDescriptor(PcDescriptors::kPatchCode,
                        Isolate::kNoDeoptId,
                        0);  // No token position.
-  __ jmp(&StubCode::FixCallersTargetLabel());
+  // This is patched up to a point in FrameEntry where the PP for the
+  // current function is in R13 instead of PP.
+  __ JmpPatchable(&StubCode::FixCallersTargetLabel(), R13);
+
+  // TOOD(zra): Is this descriptor used?
   AddCurrentDescriptor(PcDescriptors::kLazyDeoptJump,
                        Isolate::kNoDeoptId,
                        0);  // No token position.
-  __ jmp(&StubCode::DeoptimizeLazyLabel());
+  __ Jmp(&StubCode::DeoptimizeLazyLabel(), PP);
 }
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind,
                                      LocationSummary* locs) {
-  __ call(label);
+  __ Call(label, PP);
   AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
 }
 
 
 void FlowGraphCompiler::GenerateDartCall(intptr_t deopt_id,
                                          intptr_t token_pos,
                                          const ExternalLabel* label,
                                          PcDescriptors::Kind kind,
                                          LocationSummary* locs) {
-  __ call(label);
+  __ CallPatchable(label);
   AddCurrentDescriptor(kind, deopt_id, token_pos);
   RecordSafepoint(locs);
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
   const intptr_t deopt_id_after = Isolate::ToDeoptAfter(deopt_id);
   if (is_optimizing()) {
     AddDeoptIndexAtCall(deopt_id_after, token_pos);
   } else {
     // Add deoptimization continuation point after the call and before the
     // arguments are removed.
@@ skipping 18 matching lines @@
       AddDeoptIndexAtCall(deopt_id_after, token_pos);
     } else {
       // Add deoptimization continuation point after the call and before the
       // arguments are removed.
       AddCurrentDescriptor(PcDescriptors::kDeopt, deopt_id_after, token_pos);
     }
   }
 }
 
 
+void FlowGraphCompiler::EmitUnoptimizedStaticCall(
+    const Function& target_function,
+    const Array& arguments_descriptor,
+    intptr_t argument_count,
+    intptr_t deopt_id,
+    intptr_t token_pos,
+    LocationSummary* locs) {
+  // TODO(srdjan): Improve performance of function recognition.
+  MethodRecognizer::Kind recognized_kind =
+      MethodRecognizer::RecognizeKind(target_function);
+  int num_args_checked = 0;
+  if ((recognized_kind == MethodRecognizer::kMathMin) ||
+      (recognized_kind == MethodRecognizer::kMathMax)) {
+    num_args_checked = 2;
+  }
+  const ICData& ic_data = ICData::ZoneHandle(
+      ICData::New(parsed_function().function(),  // Caller function.
+                  String::Handle(target_function.name()),
+                  arguments_descriptor,
+                  deopt_id,
+                  num_args_checked));  // No arguments checked.
+  ic_data.AddTarget(target_function);
+  uword label_address = 0;
+  if (ic_data.num_args_tested() == 0) {
+    label_address = StubCode::ZeroArgsUnoptimizedStaticCallEntryPoint();
+  } else if (ic_data.num_args_tested() == 2) {
+    label_address = StubCode::TwoArgsUnoptimizedStaticCallEntryPoint();
+  } else {
+    UNIMPLEMENTED();
+  }
+  ExternalLabel target_label("StaticCallICStub", label_address);
+  __ LoadObject(RBX, ic_data, PP);
+  GenerateDartCall(deopt_id,
+                   token_pos,
+                   &target_label,
+                   PcDescriptors::kUnoptStaticCall,
+                   locs);
+  __ Drop(argument_count);
+}
+
+
 void FlowGraphCompiler::EmitOptimizedInstanceCall(
     ExternalLabel* target_label,
     const ICData& ic_data,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
   // Each ICData propagated from unoptimized to optimized code contains the
   // function that corresponds to the Dart function of that IC call. Due
   // to inlining in optimized code, that function may not correspond to the
   // top-level function (parsed_function().function()) which could be
   // reoptimized and which counter needs to be incremented.
   // Pass the function explicitly, it is used in IC stub.
-  __ LoadObject(RDI, parsed_function().function());
-  __ LoadObject(RBX, ic_data);
+  __ LoadObject(RDI, parsed_function().function(), PP);
+  __ LoadObject(RBX, ic_data, PP);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    PcDescriptors::kIcCall,
                    locs);
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                          const ICData& ic_data,
                                          intptr_t argument_count,
                                          intptr_t deopt_id,
                                          intptr_t token_pos,
                                          LocationSummary* locs) {
-  __ LoadObject(RBX, ic_data);
+  __ LoadObject(RBX, ic_data, PP);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    PcDescriptors::kIcCall,
                    locs);
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitMegamorphicInstanceCall(
@@ skipping 15 matching lines @@
   __ j(NOT_ZERO, &not_smi, Assembler::kNearJump);
   __ movq(RAX, Immediate(Smi::RawValue(kSmiCid)));
   __ jmp(&load_cache);
 
   __ Bind(&not_smi);
   __ LoadClassId(RAX, RAX);
   __ SmiTag(RAX);
 
   // RAX: class ID of the receiver (smi).
   __ Bind(&load_cache);
-  __ LoadObject(RBX, cache);
+  __ LoadObject(RBX, cache, PP);
   __ movq(RDI, FieldAddress(RBX, MegamorphicCache::buckets_offset()));
   __ movq(RBX, FieldAddress(RBX, MegamorphicCache::mask_offset()));
   // RDI: cache buckets array.
   // RBX: mask.
   __ movq(RCX, RAX);
 
   Label loop, update, call_target_function;
   __ jmp(&loop);
 
   __ Bind(&update);
@@ skipping 11 matching lines @@
   __ j(NOT_EQUAL, &update, Assembler::kNearJump);
 
   __ Bind(&call_target_function);
   // Call the target found in the cache.  For a class id match, this is a
   // proper target for the given name and arguments descriptor.  If the
   // illegal class id was found, the target is a cache miss handler that can
   // be invoked as a normal Dart function.
   __ movq(RAX, FieldAddress(RDI, RCX, TIMES_8, base + kWordSize));
   __ movq(RAX, FieldAddress(RAX, Function::code_offset()));
   __ movq(RAX, FieldAddress(RAX, Code::instructions_offset()));
-  __ LoadObject(RBX, ic_data);
-  __ LoadObject(R10, arguments_descriptor);
+  __ LoadObject(RBX, ic_data, PP);
+  __ LoadObject(R10, arguments_descriptor, PP);
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ call(RAX);
   AddCurrentDescriptor(PcDescriptors::kOther, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
   AddDeoptIndexAtCall(Isolate::ToDeoptAfter(deopt_id), token_pos);
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitOptimizedStaticCall(
     const Function& function,
     const Array& arguments_descriptor,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
-  __ LoadObject(R10, arguments_descriptor);
+  __ LoadObject(R10, arguments_descriptor, PP);
   // Do not use the code from the function, but let the code be patched so that
   // we can record the outgoing edges to other code.
   GenerateDartCall(deopt_id,
                    token_pos,
                    &StubCode::CallStaticFunctionLabel(),
                    PcDescriptors::kOptStaticCall,
                    locs);
   AddStaticCallTarget(function);
   __ Drop(argument_count);
 }
@@ skipping 12 matching lines @@
   if (obj.IsSmi() && (Smi::Cast(obj).Value() == 0)) {
     ASSERT(!needs_number_check);
     __ testq(reg, reg);
     return;
   }
 
   if (needs_number_check) {
     __ pushq(reg);
     __ PushObject(obj);
     if (is_optimizing()) {
-      __ call(&StubCode::OptimizedIdenticalWithNumberCheckLabel());
+      __ CallPatchable(&StubCode::OptimizedIdenticalWithNumberCheckLabel());
     } else {
-      __ call(&StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
+      __ CallPatchable(&StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
     }
     AddCurrentDescriptor(PcDescriptors::kRuntimeCall,
                          Isolate::kNoDeoptId,
                          token_pos);
     __ popq(reg);  // Discard constant.
     __ popq(reg);  // Restore 'reg'.
     return;
   }
 
   __ CompareObject(reg, obj);
 }
 
 
 void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left,
                                                   Register right,
                                                   bool needs_number_check,
                                                   intptr_t token_pos) {
   if (needs_number_check) {
     __ pushq(left);
     __ pushq(right);
     if (is_optimizing()) {
-      __ call(&StubCode::OptimizedIdenticalWithNumberCheckLabel());
+      __ CallPatchable(&StubCode::OptimizedIdenticalWithNumberCheckLabel());
     } else {
-      __ call(&StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
+      __ CallPatchable(&StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
     }
     AddCurrentDescriptor(PcDescriptors::kRuntimeCall,
                          Isolate::kNoDeoptId,
                          token_pos);
     // Stub returns result in flags (result of a cmpl, we need ZF computed).
     __ popq(right);
     __ popq(left);
   } else {
     __ cmpl(left, right);
   }
@@ skipping 69 matching lines @@
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Label match_found;
   const intptr_t len = ic_data.NumberOfChecks();
   GrowableArray<CidTarget> sorted(len);
   SortICDataByCount(ic_data, &sorted);
   ASSERT(class_id_reg != R10);
   ASSERT(len > 0);  // Why bother otherwise.
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
                                                  argument_names));
-  __ LoadObject(R10, arguments_descriptor);
+  __ LoadObject(R10, arguments_descriptor, PP);
   for (intptr_t i = 0; i < len; i++) {
     const bool is_last_check = (i == (len - 1));
     Label next_test;
     assembler()->cmpl(class_id_reg, Immediate(sorted[i].cid));
     if (is_last_check) {
       assembler()->j(NOT_EQUAL, deopt);
     } else {
       assembler()->j(NOT_EQUAL, &next_test);
     }
     // Do not use the code from the function, but let the code be patched so
@@ skipping 21 matching lines @@
                                                 BranchInstr* branch) {
   ASSERT(branch != NULL);
   assembler()->comisd(left, right);
   BlockEntryInstr* nan_result = (true_condition == NOT_EQUAL) ?
       branch->true_successor() : branch->false_successor();
   assembler()->j(PARITY_EVEN, GetJumpLabel(nan_result));
   branch->EmitBranchOnCondition(this, true_condition);
 }
 
 
-
 void FlowGraphCompiler::EmitDoubleCompareBool(Condition true_condition,
                                               FpuRegister left,
                                               FpuRegister right,
                                               Register result) {
   assembler()->comisd(left, right);
   Label is_false, is_true, done;
   assembler()->j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN false;
   assembler()->j(true_condition, &is_true, Assembler::kNearJump);
   assembler()->Bind(&is_false);
-  assembler()->LoadObject(result, Bool::False());
+  assembler()->LoadObject(result, Bool::False(), PP);
   assembler()->jmp(&done);
   assembler()->Bind(&is_true);
-  assembler()->LoadObject(result, Bool::True());
+  assembler()->LoadObject(result, Bool::True(), PP);
   assembler()->Bind(&done);
 }
 
 
 FieldAddress FlowGraphCompiler::ElementAddressForIntIndex(intptr_t cid,
                                                           intptr_t index_scale,
                                                           Register array,
                                                           intptr_t index) {
   const int64_t disp =
       static_cast<int64_t>(index) * index_scale + DataOffsetFor(cid);
@@ skipping 100 matching lines @@
       __ movups(XMM0, source.ToStackSlotAddress());
       __ movups(destination.ToStackSlotAddress(), XMM0);
     }
   } else {
     ASSERT(source.IsConstant());
     if (destination.IsRegister()) {
       const Object& constant = source.constant();
       if (constant.IsSmi() && (Smi::Cast(constant).Value() == 0)) {
         __ xorq(destination.reg(), destination.reg());
       } else {
-        __ LoadObject(destination.reg(), constant);
+        __ LoadObject(destination.reg(), constant, PP);
       }
     } else {
       ASSERT(destination.IsStackSlot());
       StoreObject(destination.ToStackSlotAddress(), source.constant());
     }
   }
 
   move->Eliminate();
 }
 
@@ skipping 128 matching lines @@
   __ movups(reg, Address(RSP, 0));
   __ addq(RSP, Immediate(kFpuRegisterSize));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64