Uses an object pool on x64

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 78 matching lines @@
         (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
     ASSERT(fp_sp_dist <= 0);
     __ movq(RDI, RSP);
     __ subq(RDI, RBP);
     __ cmpq(RDI, Immediate(fp_sp_dist));
     __ j(EQUAL, &done, Assembler::kNearJump);
     __ int3();
     __ Bind(&done);
   }
 #endif
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
   __ ret();
 
-  // Generate 8 bytes of NOPs so that the debugger can patch the
+  // Generate 4 bytes of NOPs so that the debugger can patch the

[Florian Schneider, 2013/09/05 10:57:45]

How is 4 computed? The number of nops should depend on the instructions that the
debugger patches here (pattern length). Please add an assert that the number of
nops is correct.

[zra, 2013/09/05 20:29:26]

Moved this sequence into the Assembler function ReturnPatchable so that I could
write an assert on its length.

   // return pattern with a call to the debug stub.
   // Note that the nop(8) byte pattern is not recognized by the debugger.
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
-  __ nop(1);
-  __ nop(1);
-  __ nop(1);
-  __ nop(1);
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  Isolate::kNoDeoptId,
                                  token_pos());
 }
 
 
 static Condition NegateCondition(Condition condition) {
   switch (condition) {
     case EQUAL:         return NOT_EQUAL;
     case NOT_EQUAL:     return EQUAL;
@@ skipping 185 matching lines @@
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out().IsInvalid()) {
     Register result = locs()->out().reg();
-    __ LoadObject(result, value());
+    __ LoadObjectFromPool(result, value(), PP);

[Florian Schneider, 2013/09/05 10:57:45]

This should just be

LoadObject(result, value())


because LoadObject is implemented as follows:

void LoadObject(Register dst, const Object& object) {
  LoadObjectFromPool(dst, object, PP);
}

[zra, 2013/09/05 20:29:26]

Done.

   }
 }
 
 
 LocationSummary* AssertAssignableInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));  // Value.
@@ skipping 129 matching lines @@
                                        const ICData& original_ic_data) {
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id,
                                    token_pos);
   }
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Object::null_array();
   const int kNumArgumentsChecked = 2;
 
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label check_identity;
-  __ cmpq(Address(RSP, 0 * kWordSize), raw_null);
+  __ LoadObjectFromPool(TMP, Object::Handle(), PP);
+  __ cmpq(Address(RSP, 0 * kWordSize), TMP);
   __ j(EQUAL, &check_identity);
-  __ cmpq(Address(RSP, 1 * kWordSize), raw_null);
+  __ cmpq(Address(RSP, 1 * kWordSize), TMP);
   __ j(EQUAL, &check_identity);
 
   ICData& equality_ic_data = ICData::ZoneHandle(original_ic_data.raw());
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!original_ic_data.IsNull());
     if (original_ic_data.NumberOfChecks() == 0) {
       // IC call for reoptimization populates original ICData.
       equality_ic_data = original_ic_data.raw();
     } else {
       // Megamorphic call.
@@ skipping 20 matching lines @@
 
   __ Bind(&check_identity);
   Label equality_done;
   if (compiler->is_optimizing()) {
     // No need to update IC data.
     Label is_true;
     __ popq(RAX);
     __ popq(RDX);
     __ cmpq(RAX, RDX);
     __ j(EQUAL, &is_true);
-    __ LoadObject(RAX, Bool::Get(kind != Token::kEQ));
+    __ LoadObjectFromPool(RAX, Bool::Get(kind != Token::kEQ), PP);

[Florian Schneider, 2013/09/05 10:57:45]

If you require an extra parameter there is no need to rename the function
itself.

s/LoadObjectFromPool/LoadObject/

[zra, 2013/09/05 20:29:26]

Using LoadObject everywhere the pool pointer is PP since there is no longer a
distinction between patchable and non-patchable LoadObject.

     __ jmp(&equality_done);
     __ Bind(&is_true);
-    __ LoadObject(RAX, Bool::Get(kind == Token::kEQ));
+    __ LoadObjectFromPool(RAX, Bool::Get(kind == Token::kEQ), PP);
     if (kind == Token::kNE) {
       // Skip not-equal result conversion.
       __ jmp(&equality_done);
     }
   } else {
     // Call stub, load IC data in register. The stub will update ICData if
     // necessary.
     Register ic_data_reg = locs->temp(0).reg();
     ASSERT(ic_data_reg == RBX);  // Stub depends on it.
     __ LoadObject(ic_data_reg, equality_ic_data);

[Florian Schneider, 2013/09/05 10:57:45]

What about this LoadObject?

[zra, 2013/09/05 20:29:26]

Done.

     compiler->GenerateCall(token_pos,
                            &StubCode::EqualityWithNullArgLabel(),
                            PcDescriptors::kRuntimeCall,
                            locs);
     __ Drop(2);
   }
   __ Bind(&check_ne);
   if (kind == Token::kNE) {
     Label true_label, done;
     // Negate the condition: true label returns false and vice versa.
     __ CompareObject(RAX, Bool::True());
     __ j(EQUAL, &true_label, Assembler::kNearJump);
-    __ LoadObject(RAX, Bool::True());
+    __ LoadObjectFromPool(RAX, Bool::True(), PP);
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&true_label);
-    __ LoadObject(RAX, Bool::False());
+    __ LoadObjectFromPool(RAX, Bool::False(), PP);
     __ Bind(&done);
   }
   __ Bind(&equality_done);
 }
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
@@ skipping 49 matching lines @@
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpq(left, right);
       if (branch != NULL) {
         branch->EmitBranchOnCondition(compiler, cond);
       } else {
         // This case should be rare.
         Register result = locs->out().reg();
         Label load_true;
         __ j(cond, &load_true, Assembler::kNearJump);
-        __ LoadObject(result, Bool::False());
+        __ LoadObjectFromPool(result, Bool::False(), PP);
         __ jmp(&done);
         __ Bind(&load_true);
-        __ LoadObject(result, Bool::True());
+        __ LoadObjectFromPool(result, Bool::True(), PP);
       }
     } else {
       const int kNumberOfArguments = 2;
       const Array& kNoArgumentNames = Object::null_array();
       compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    target,
                                    kNumberOfArguments,
                                    kNoArgumentNames,
                                    locs);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label false_label;
           __ CompareObject(RAX, Bool::True());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
-          __ LoadObject(RAX, Bool::True());
+          __ LoadObjectFromPool(RAX, Bool::True(), PP);
           __ jmp(&done);
           __ Bind(&false_label);
-          __ LoadObject(RAX, Bool::False());
+          __ LoadObjectFromPool(RAX, Bool::False(), PP);
         }
       } else {
         if (branch->is_checked()) {
           EmitAssertBoolean(RAX, token_pos, deopt_id, locs, compiler);
         }
         __ CompareObject(RAX, Bool::True());
         branch->EmitBranchOnCondition(compiler, cond);
       }
     }
     if (i < len - 1) {
@@ skipping 13 matching lines @@
                                    BranchInstr* branch,
                                    intptr_t deopt_id) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   // 'left' is not Smi.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+
   Label identity_compare;
-  __ cmpq(right, raw_null);
+  __ CompareObject(right, Object::Handle());
   __ j(EQUAL, &identity_compare);
-  __ cmpq(left, raw_null);
+  __ CompareObject(left, Object::Handle());
   __ j(EQUAL, &identity_compare);
 
   __ LoadClassId(temp, left);
   const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     __ cmpq(temp, Immediate(ic_data.GetReceiverClassIdAt(i)));
     if (i == (len - 1)) {
       __ j(NOT_EQUAL, deopt);
     } else {
       __ j(EQUAL, &identity_compare);
     }
   }
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   if (branch == NULL) {
     Label done, is_equal;
     Register result = locs.out().reg();
     __ j(EQUAL, &is_equal, Assembler::kNearJump);
     // Not equal.
-    __ LoadObject(result, Bool::Get(kind != Token::kEQ));
+    __ LoadObjectFromPool(result, Bool::Get(kind != Token::kEQ), PP);
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&is_equal);
-    __ LoadObject(result, Bool::Get(kind == Token::kEQ));
+    __ LoadObjectFromPool(result, Bool::Get(kind == Token::kEQ), PP);
     __ Bind(&done);
   } else {
     Condition cond = TokenKindToSmiCondition(kind);
     branch->EmitBranchOnCondition(compiler, cond);
   }
 }
 
 
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
 // type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
                                        LocationSummary* locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Register left = locs->in(0).reg();
   Register right = locs->in(1).reg();
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+
   Label done, identity_compare, non_null_compare;
-  __ cmpq(right, raw_null);
+  __ CompareObject(right, Object::Handle());
   __ j(EQUAL, &identity_compare, Assembler::kNearJump);
-  __ cmpq(left, raw_null);
+  __ CompareObject(left, Object::Handle());
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   Condition cond = TokenKindToSmiCondition(kind);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, cond);
   } else {
     Register result = locs->out().reg();
     Label load_true;
     __ j(cond, &load_true, Assembler::kNearJump);
-    __ LoadObject(result, Bool::False());
+    __ LoadObjectFromPool(result, Bool::False(), PP);
     __ jmp(&done);
     __ Bind(&load_true);
-    __ LoadObject(result, Bool::True());
+    __ LoadObjectFromPool(result, Bool::True(), PP);
   }
   __ jmp(&done);
   __ Bind(&non_null_compare);  // Receiver is not null.
   __ pushq(left);
   __ pushq(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
                                 deopt_id, token_pos);
   __ Bind(&done);
 }
 
@@ skipping 37 matching lines @@
   } else {
     __ cmpq(left.reg(), right.reg());
   }
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
     __ j(true_condition, &is_true);
-    __ LoadObject(result, Bool::False());
+    __ LoadObjectFromPool(result, Bool::False(), PP);
     __ jmp(&done);
     __ Bind(&is_true);
-    __ LoadObject(result, Bool::True());
+    __ LoadObjectFromPool(result, Bool::True(), PP);
     __ Bind(&done);
   }
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return BELOW;
@@ skipping 707 matching lines @@
   if (!compiler->is_optimizing() || (field_cid == kIllegalCid)) {
     if (!compiler->is_optimizing() && (field_reg == kNoRegister)) {
       // Currently we can't have different location summaries for optimized
       // and non-optimized code. So instead we manually pick up a register
       // that is known to be free because we know how non-optimizing compiler
       // allocates registers.
       field_reg = RBX;
       ASSERT((field_reg != value_reg) && (field_reg != value_cid_reg));
     }
 
-    __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
+    __ LoadObjectFromPool(field_reg, Field::ZoneHandle(field().raw()), PP);
 
     FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset());
     FieldAddress field_nullability_operand(
         field_reg, Field::is_nullable_offset());
     FieldAddress field_length_operand(
         field_reg, Field::guarded_list_length_offset());
 
     if (value_cid == kDynamicCid) {
       if (value_cid_reg == kNoRegister) {
         ASSERT(!compiler->is_optimizing());
@@ skipping 125 matching lines @@
       } else {
         __ movq(field_length_operand, Immediate(Field::kNoFixedLength));
       }
     }
 
     if (!ok_is_fall_through) {
       __ jmp(&ok);
     }
   } else {
     if (field_reg != kNoRegister) {
-      __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
+      __ LoadObjectFromPool(field_reg, Field::ZoneHandle(field().raw()), PP);
     }
 
     if (value_cid == kDynamicCid) {
       // Field's guarded class id is fixed but value's class id is not known.
       __ testq(value_reg, Immediate(kSmiTagMask));
 
       if (field_cid != kSmiCid) {
         __ j(ZERO, fail);
         __ LoadClassId(value_cid_reg, value_reg);
         __ cmpq(value_cid_reg, Immediate(field_cid));
@@ skipping 15 matching lines @@
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, TypedData::length_offset()));
         }
         __ cmpq(value_cid_reg, field_length_operand);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ j(EQUAL, &ok);
-        const Immediate& raw_null =
-            Immediate(reinterpret_cast<intptr_t>(Object::null()));
-        __ cmpq(value_reg, raw_null);
+        __ CompareObject(value_reg, Object::Handle());
       }
 
       if (ok_is_fall_through) {
         __ j(NOT_EQUAL, fail);
       } else {
         __ j(EQUAL, &ok);
       }
     } else {
       // Both value's and field's class id is known.
       if ((value_cid != field_cid) && (value_cid != nullability)) {
@@ skipping 104 matching lines @@
                                               : Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
 
-  __ LoadObject(temp, field());
+  __ LoadObjectFromPool(temp, field(), PP);
   if (this->value()->NeedsStoreBuffer()) {
     __ StoreIntoObject(temp,
         FieldAddress(temp, Field::value_offset()), value, CanValueBeSmi());
   } else {
     __ StoreIntoObjectNoBarrier(
         temp, FieldAddress(temp, Field::value_offset()), value);
   }
 }
 
 
@@ skipping 133 matching lines @@
   // (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
-    __ cmpq(instantiator_reg, raw_null);
+    __ CompareObject(instantiator_reg, Object::Handle());
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(type_arguments());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
@@ skipping 27 matching lines @@
   // instantiator_reg is the instantiator type argument vector, i.e. an
   // AbstractTypeArguments object (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   ASSERT(type_arguments().IsRawInstantiatedRaw(type_arguments().Length()));
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ cmpq(instantiator_reg, raw_null);
+
+  __ CompareObject(instantiator_reg, Object::Handle());
   __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   // Instantiate non-null type arguments.
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
-  __ LoadObject(result_reg, type_arguments());
+  __ LoadObjectFromPool(result_reg, type_arguments(), PP);
   // result_reg: uninstantiated type arguments.
 
   __ Bind(&type_arguments_instantiated);
   // result_reg: uninstantiated or instantiated type arguments.
 }
 
 
 LocationSummary*
 ExtractConstructorInstantiatorInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
@@ skipping 14 matching lines @@
   // instantiator_reg is the instantiator AbstractTypeArguments object
   // (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
 
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments and do not pass the instantiator.
   ASSERT(type_arguments().IsRawInstantiatedRaw(type_arguments().Length()));
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+
   Label instantiator_not_null;
-  __ cmpq(instantiator_reg, raw_null);
+  __ CompareObject(instantiator_reg, Object::Handle());
   __ j(NOT_EQUAL, &instantiator_not_null, Assembler::kNearJump);
   // Null was used in VisitExtractConstructorTypeArguments as the
   // instantiated type arguments, no proper instantiator needed.
   __ movq(instantiator_reg,
           Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   __ Bind(&instantiator_not_null);
   // instantiator_reg: instantiator or kNoInstantiator.
 }
 
 
@@ skipping 55 matching lines @@
 }
 
 
 void CatchBlockEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   compiler->AddExceptionHandler(catch_try_index(),
                                 try_index(),
                                 compiler->assembler()->CodeSize(),
                                 catch_handler_types_,
                                 needs_stacktrace());
+
+  // Restore the pool pointer.
+  __ LoadPoolPointer(PP);
+
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 
   // Restore RSP from RBP as we are coming from a throw and the code for
   // popping arguments has not been run.
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ leaq(RSP, Address(RBP, fp_sp_dist));
@@ skipping 60 matching lines @@
 
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
   __ movq(temp, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(temp, 0));
   __ j(BELOW_EQUAL, slow_path->entry_label());
   if (compiler->CanOSRFunction() && in_loop()) {
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
-    __ LoadObject(temp, compiler->parsed_function().function());
+    __ LoadObjectFromPool(temp, compiler->parsed_function().function(), PP);
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
     __ cmpq(FieldAddress(temp, Function::usage_counter_offset()),
             Immediate(threshold));
     __ j(GREATER_EQUAL, slow_path->entry_label());
   }
   __ Bind(slow_path->exit_label());
 }
 
 
@@ skipping 1426 matching lines @@
       __ movl(result, Address(RSP, 8));
       break;
     case MethodRecognizer::kUint32x4GetFlagW:
       __ movl(result, Address(RSP, 12));
       break;
     default: UNREACHABLE();
   }
   __ addq(RSP, Immediate(16));
   __ testl(result, result);
   __ j(NOT_ZERO, &non_zero, Assembler::kNearJump);
-  __ LoadObject(result, Bool::False());
+  __ LoadObjectFromPool(result, Bool::False(), PP);
   __ jmp(&done);
   __ Bind(&non_zero);
-  __ LoadObject(result, Bool::True());
+  __ LoadObjectFromPool(result, Bool::True(), PP);
   __ Bind(&done);
 }
 
 
 LocationSummary* Uint32x4SelectInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
@@ skipping 493 matching lines @@
     //    return double.NAN;
     // }
     XmmRegister base = locs()->in(0).fpu_reg();
     XmmRegister exp = locs()->in(1).fpu_reg();
     XmmRegister result = locs()->out().fpu_reg();
     Register temp = locs()->temp(0).reg();
     XmmRegister zero_temp = locs()->temp(1).fpu_reg();
 
     Label check_base_is_one;
     // Check if exponent is 0.0 -> return 1.0;
-    __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0)));
+    __ LoadObjectFromPool(temp, Double::ZoneHandle(Double::NewCanonical(0)),
+        PP);
     __ movsd(zero_temp, FieldAddress(temp, Double::value_offset()));
-    __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)));
+    __ LoadObjectFromPool(temp, Double::ZoneHandle(Double::NewCanonical(1)),
+        PP);
     __ movsd(result, FieldAddress(temp, Double::value_offset()));
     // 'result' contains 1.0.
     __ comisd(exp, zero_temp);
     __ j(PARITY_EVEN, &check_base_is_one, Assembler::kNearJump);  // NaN.
     __ j(EQUAL, &skip_call, Assembler::kNearJump);  // exp is 0, result is 1.0.
 
     Label base_is_nan;
     __ Bind(&check_base_is_one);
     // Checks if base == 1.0.
     __ comisd(base, result);
@@ skipping 77 matching lines @@
     summary->AddTemp(Location::RequiresRegister());
   }
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (IsNullCheck()) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                           kDeoptCheckClass);
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
-    __ cmpq(locs()->in(0).reg(), raw_null);
+    __ CompareObject(locs()->in(0).reg(),
+                     Object::Handle());
     __ j(EQUAL, deopt);
     return;
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckClass);
@@ skipping 189 matching lines @@
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id_,
                                    Scanner::kDummyTokenIndex);
     // Add an edge counter.
     const Array& counter = Array::ZoneHandle(Array::New(1, Heap::kOld));
     counter.SetAt(0, Smi::Handle(Smi::New(0)));
     Label done;
     __ Comment("Edge counter");
-    __ LoadObject(RAX, counter);
+    __ LoadObjectFromPool(RAX, counter, PP);
     __ addq(FieldAddress(RAX, Array::element_offset(0)),
             Immediate(Smi::RawValue(1)));
     __ j(NO_OVERFLOW, &done);
     __ movq(FieldAddress(RAX, Array::element_offset(0)),
             Immediate(Smi::RawValue(Smi::kMaxValue)));
     __ Bind(&done);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
@@ skipping 10 matching lines @@
     // Add deoptimization descriptor for deoptimizing instructions that may
     // be inserted before this instruction.
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    GetDeoptId(),
                                    0);  // No token position.
     // Add an edge counter.
     const Array& counter = Array::ZoneHandle(Array::New(1, Heap::kOld));
     counter.SetAt(0, Smi::Handle(Smi::New(0)));
     Label done;
     __ Comment("Edge counter");
-    __ LoadObject(RAX, counter);
+    __ LoadObjectFromPool(RAX, counter, PP);
     __ addq(FieldAddress(RAX, Array::element_offset(0)),
             Immediate(Smi::RawValue(1)));
     __ j(NO_OVERFLOW, &done);
     __ movq(FieldAddress(RAX, Array::element_offset(0)),
             Immediate(Smi::RawValue(Smi::kMaxValue)));
     __ Bind(&done);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
@@ skipping 62 matching lines @@
 // Special code for numbers (compare values instead of references.)
 void StrictCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Location left = locs()->in(0);
   Location right = locs()->in(1);
   if (left.IsConstant() && right.IsConstant()) {
     // TODO(vegorov): should be eliminated earlier by constant propagation.
     const bool result = (kind() == Token::kEQ_STRICT) ?
         left.constant().raw() == right.constant().raw() :
         left.constant().raw() != right.constant().raw();
-    __ LoadObject(locs()->out().reg(), Bool::Get(result));
+    __ LoadObjectFromPool(locs()->out().reg(), Bool::Get(result), PP);
     return;
   }
   if (left.IsConstant()) {
     compiler->EmitEqualityRegConstCompare(right.reg(),
                                           left.constant(),
                                           needs_number_check(),
                                           token_pos());
   } else if (right.IsConstant()) {
     compiler->EmitEqualityRegConstCompare(left.reg(),
                                           right.constant(),
                                           needs_number_check(),
                                           token_pos());
   } else {
     compiler->EmitEqualityRegRegCompare(left.reg(),
                                        right.reg(),
                                        needs_number_check(),
                                        token_pos());
   }
 
   Register result = locs()->out().reg();
   Label load_true, done;
   Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
   __ j(true_condition, &load_true, Assembler::kNearJump);
-  __ LoadObject(result, Bool::False());
+  __ LoadObjectFromPool(result, Bool::False(), PP);
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&load_true);
-  __ LoadObject(result, Bool::True());
+  __ LoadObjectFromPool(result, Bool::True(), PP);
   __ Bind(&done);
 }
 
 
 void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                         BranchInstr* branch) {
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Location left = locs()->in(0);
   Location right = locs()->in(1);
   if (left.IsConstant() && right.IsConstant()) {
@@ skipping 38 matching lines @@
 
 
 void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The arguments to the stub include the closure, as does the arguments
   // descriptor.
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
                                                  argument_names()));
-  __ LoadObject(temp_reg, arguments_descriptor);
+  __ LoadObjectFromPool(temp_reg, arguments_descriptor, PP);
   ASSERT(temp_reg == R10);
   compiler->GenerateDartCall(deopt_id(),
                              token_pos(),
                              &StubCode::CallClosureFunctionLabel(),
                              PcDescriptors::kClosureCall,
                              locs());
   __ Drop(argument_count);
 }
 
 
 LocationSummary* BooleanNegateInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   Label done;
-  __ LoadObject(result, Bool::True());
+  __ LoadObjectFromPool(result, Bool::True(), PP);
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-  __ LoadObject(result, Bool::False());
+  __ LoadObjectFromPool(result, Bool::False(), PP);
   __ Bind(&done);
 }
 
 
 LocationSummary* StoreVMFieldInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
@@ skipping 49 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64