Simplify constant pool usage in x64 code generator (by removing extra argument

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 38 matching lines @@
 
 
 void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
   // where PushArgument is handled by BindInstr::EmitNativeCode.
   if (compiler->is_optimizing()) {
     Location value = locs()->in(0);
     if (value.IsRegister()) {
       __ pushq(value.reg());
     } else if (value.IsConstant()) {
-      __ PushObject(value.constant(), PP);
+      __ PushObject(value.constant());
     } else {
       ASSERT(value.IsStackSlot());
       __ pushq(value.ToStackSlotAddress());
     }
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary(Zone* zone,
                                                   bool opt) const {
@@ skipping 20 matching lines @@
   }
 
 #if defined(DEBUG)
   __ Comment("Stack Check");
   Label done;
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ movq(RDI, RSP);
   __ subq(RDI, RBP);
-  __ CompareImmediate(RDI, Immediate(fp_sp_dist), PP);
+  __ CompareImmediate(RDI, Immediate(fp_sp_dist));
   __ j(EQUAL, &done, Assembler::kNearJump);
   __ int3();
   __ Bind(&done);
 #endif
-  __ LeaveDartFrame();
+  __ LeaveDartFrame();  // Disallows constant pool use.
   __ ret();
+  // This ReturnInstr may be emitted out of order by the optimizer. The next
+  // block may be a target expecting a properly set constant pool pointer.
+  __ set_constant_pool_allowed(true);
 }
 
 
 static Condition NegateCondition(Condition condition) {
   switch (condition) {
     case EQUAL:         return NOT_EQUAL;
     case NOT_EQUAL:     return EQUAL;
     case LESS:          return GREATER_EQUAL;
     case LESS_EQUAL:    return GREATER;
     case GREATER:       return LESS_EQUAL;
@@ skipping 59 matching lines @@
 
   __ setcc(true_condition, DL);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ shlq(RDX, Immediate(shift + kSmiTagSize));
   } else {
     __ decq(RDX);
     __ AndImmediate(RDX,
-        Immediate(Smi::RawValue(true_value) - Smi::RawValue(false_value)), PP);
+        Immediate(Smi::RawValue(true_value) - Smi::RawValue(false_value)));
     if (false_value != 0) {
-      __ AddImmediate(RDX, Immediate(Smi::RawValue(false_value)), PP);
+      __ AddImmediate(RDX, Immediate(Smi::RawValue(false_value)));
     }
   }
 }
 
 
 LocationSummary* LoadLocalInstr::MakeLocationSummary(Zone* zone,
                                                      bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t stack_index = (local().index() < 0)
       ? kFirstLocalSlotFromFp - local().index()
@@ skipping 36 matching lines @@
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out(0).IsInvalid()) {
     Register result = locs()->out(0).reg();
-    __ LoadObject(result, value(), PP);
+    __ LoadObject(result, value());
   }
 }
 
 
 LocationSummary* UnboxedConstantInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 14 matching lines @@
 
 void UnboxedConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out(0).IsInvalid()) {
     switch (representation()) {
       case kUnboxedDouble: {
         XmmRegister result = locs()->out(0).fpu_reg();
         if (Utils::DoublesBitEqual(Double::Cast(value()).value(), 0.0)) {
           __ xorps(result, result);
         } else {
-          __ LoadObject(TMP, value(), PP);
+          __ LoadObject(TMP, value());
           __ movsd(result, FieldAddress(TMP, Double::value_offset()));
         }
         break;
       }
       case kUnboxedInt32:
         __ movl(locs()->out(0).reg(),
                 Immediate(static_cast<int32_t>(Smi::Cast(value()).Value())));
         break;
       default:
         UNREACHABLE();
@@ skipping 32 matching lines @@
                               intptr_t token_pos,
                               intptr_t deopt_id,
                               LocationSummary* locs,
                               FlowGraphCompiler* compiler) {
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   ASSERT(locs->always_calls());
   Label done;
 
   if (Isolate::Current()->flags().type_checks()) {
-    __ CompareObject(reg, Bool::True(), PP);
+    __ CompareObject(reg, Bool::True());
     __ j(EQUAL, &done, Assembler::kNearJump);
-    __ CompareObject(reg, Bool::False(), PP);
+    __ CompareObject(reg, Bool::False());
     __ j(EQUAL, &done, Assembler::kNearJump);
   } else {
     ASSERT(Isolate::Current()->flags().asserts());
-    __ CompareObject(reg, Object::null_instance(), PP);
+    __ CompareObject(reg, Object::null_instance());
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   }
 
   __ pushq(reg);  // Push the source object.
   compiler->GenerateRuntimeCall(token_pos,
                                 deopt_id,
                                 kNonBoolTypeErrorRuntimeEntry,
                                 1,
                                 locs);
   // We should never return here.
@@ skipping 65 matching lines @@
   return NULL;
 }
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
   Label done;
   if (value_is_smi == NULL) {
-    __ LoadImmediate(value_cid_reg, Immediate(kSmiCid), PP);
+    __ LoadImmediate(value_cid_reg, Immediate(kSmiCid));
   }
   __ testq(value_reg, Immediate(kSmiTagMask));
   if (value_is_smi == NULL) {
     __ j(ZERO, &done, Assembler::kNearJump);
   } else {
     __ j(ZERO, value_is_smi);
   }
   __ LoadClassId(value_cid_reg, value_reg);
   __ Bind(&done);
 }
@@ skipping 41 matching lines @@
                                        const LocationSummary& locs,
                                        Token::Kind kind,
                                        BranchLabels labels) {
   Location left = locs.in(0);
   Location right = locs.in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   Condition true_condition = TokenKindToIntCondition(kind);
 
   if (left.IsConstant()) {
-    __ CompareObject(right.reg(), left.constant(), PP);
+    __ CompareObject(right.reg(), left.constant());
     true_condition = FlipCondition(true_condition);
   } else if (right.IsConstant()) {
-    __ CompareObject(left.reg(), right.constant(), PP);
+    __ CompareObject(left.reg(), right.constant());
   } else if (right.IsStackSlot()) {
     __ cmpq(left.reg(), right.ToStackSlotAddress());
   } else {
     __ cmpq(left.reg(), right.reg());
   }
   return true_condition;
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
@@ skipping 43 matching lines @@
   ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
 
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler,  true_condition, labels);
 
   Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ jmp(&done);
   __ Bind(&is_true);
-  __ LoadObject(result, Bool::True(), PP);
+  __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void EqualityCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                           BranchInstr* branch) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
 
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
@@ skipping 16 matching lines @@
 
 
 Condition TestSmiInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                            BranchLabels labels) {
   Register left_reg = locs()->in(0).reg();
   Location right = locs()->in(1);
   if (right.IsConstant()) {
     ASSERT(right.constant().IsSmi());
     const int64_t imm =
         reinterpret_cast<int64_t>(right.constant().raw());
-    __ TestImmediate(left_reg, Immediate(imm), PP);
+    __ TestImmediate(left_reg, Immediate(imm));
   } else {
     __ testq(left_reg, right.reg());
   }
   Condition true_condition = (kind() == Token::kNE) ? NOT_ZERO : ZERO;
   return true_condition;
 }
 
 
 void TestSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Never emitted outside of the BranchInstr.
@@ skipping 67 matching lines @@
   EmitComparisonCode(compiler, labels);
 }
 
 
 void TestCidsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result_reg = locs()->out(0).reg();
   Label is_true, is_false, done;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   EmitComparisonCode(compiler, labels);
   __ Bind(&is_false);
-  __ LoadObject(result_reg, Bool::False(), PP);
+  __ LoadObject(result_reg, Bool::False());
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&is_true);
-  __ LoadObject(result_reg, Bool::True(), PP);
+  __ LoadObject(result_reg, Bool::True());
   __ Bind(&done);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary(Zone* zone,
                                                         bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kDoubleCid) {
     LocationSummary* summary = new(zone) LocationSummary(
@@ skipping 37 matching lines @@
 
 void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 
   Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ jmp(&done);
   __ Bind(&is_true);
-  __ LoadObject(result, Bool::True(), PP);
+  __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                        BranchInstr* branch) {
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
 void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out(0).reg();
   const intptr_t argc_tag = NativeArguments::ComputeArgcTag(function());
   const bool is_leaf_call =
     (argc_tag & NativeArguments::AutoSetupScopeMask()) == 0;
 
   // Push the result place holder initialized to NULL.
-  __ PushObject(Object::null_object(), PP);
+  __ PushObject(Object::null_object());
   // Pass a pointer to the first argument in RAX.
   if (!function().HasOptionalParameters()) {
     __ leaq(RAX, Address(RBP, (kParamEndSlotFromFp +
                                function().NumParameters()) * kWordSize));
   } else {
-    __ leaq(RAX,
-            Address(RBP, kFirstLocalSlotFromFp * kWordSize));
+    __ leaq(RAX, Address(RBP, kFirstLocalSlotFromFp * kWordSize));
   }
   __ LoadImmediate(
-      RBX, Immediate(reinterpret_cast<uword>(native_c_function())), PP);
-  __ LoadImmediate(
-      R10, Immediate(argc_tag), PP);
+      RBX, Immediate(reinterpret_cast<uword>(native_c_function())));
+  __ LoadImmediate(R10, Immediate(argc_tag));
   const ExternalLabel* stub_entry = (is_bootstrap_native() || is_leaf_call) ?
       &StubCode::CallBootstrapCFunctionLabel() :
       &StubCode::CallNativeCFunctionLabel();
   compiler->GenerateCall(token_pos(),
                          stub_entry,
                          RawPcDescriptors::kOther,
                          locs());
   __ popq(result);
 }
 
@@ skipping 19 matching lines @@
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(compiler->is_optimizing());
   Register char_code = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   __ LoadImmediate(result,
-      Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())), PP);
+      Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())));
   __ movq(result, Address(result,
                           char_code,
                           TIMES_HALF_WORD_SIZE,  // Char code is a smi.
                           Symbols::kNullCharCodeSymbolOffset * kWordSize));
 }
 
 
 LocationSummary* StringToCharCodeInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 84 matching lines @@
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register object = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   Label load, done;
 
   // We don't use Assembler::LoadTaggedClassIdMayBeSmi() here---which uses
   // a conditional move instead---because it is slower, probably due to
   // branch prediction usually working just fine in this case.
   __ testq(object, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &load, Assembler::kNearJump);
-  __ LoadImmediate(result, Immediate(Smi::RawValue(kSmiCid)), PP);
+  __ LoadImmediate(result, Immediate(Smi::RawValue(kSmiCid)));
   __ jmp(&done);
   __ Bind(&load);
   __ LoadClassId(result, object);
   __ SmiTag(result);
   __ Bind(&done);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
@@ skipping 372 matching lines @@
   if ((index_scale() == 1) && index.IsRegister()) {
     __ SmiUntag(index.reg());
   }
   switch (class_id()) {
     case kArrayCid:
       if (ShouldEmitStoreBarrier()) {
         Register value = locs()->in(2).reg();
         __ StoreIntoObject(array, element_address, value);
       } else if (locs()->in(2).IsConstant()) {
         const Object& constant = locs()->in(2).constant();
-        __ StoreIntoObjectNoBarrier(array, element_address, constant, PP);
+        __ StoreIntoObjectNoBarrier(array, element_address, constant);
       } else {
         Register value = locs()->in(2).reg();
         __ StoreIntoObjectNoBarrier(array, element_address, value);
       }
       break;
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kOneByteStringCid:
       if (locs()->in(2).IsConstant()) {
@@ skipping 16 matching lines @@
           value = 0xFF;
         } else if (value < 0) {
           value = 0;
         }
         __ movb(element_address,
                 Immediate(static_cast<int8_t>(value)));
       } else {
         ASSERT(locs()->in(2).reg() == RAX);
         Label store_value, store_0xff;
         __ SmiUntag(RAX);
-        __ CompareImmediate(RAX, Immediate(0xFF), PP);
+        __ CompareImmediate(RAX, Immediate(0xFF));
         __ j(BELOW_EQUAL, &store_value, Assembler::kNearJump);
         // Clamp to 0x0 or 0xFF respectively.
         __ j(GREATER, &store_0xff);
         __ xorq(RAX, RAX);
         __ jmp(&store_value, Assembler::kNearJump);
         __ Bind(&store_0xff);
-        __ LoadImmediate(RAX, Immediate(0xFF), PP);
+        __ LoadImmediate(RAX, Immediate(0xFF));
         __ Bind(&store_value);
         __ movb(element_address, RAX);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       Register value = locs()->in(2).reg();
       __ SmiUntag(value);
       __ movw(element_address, value);
@@ skipping 88 matching lines @@
       locs()->temp(locs()->temp_count() - 1).reg() : kNoRegister;
 
   Label ok, fail_label;
 
   Label* deopt = compiler->is_optimizing() ?
       compiler->AddDeoptStub(deopt_id(), ICData::kDeoptGuardField) : NULL;
 
   Label* fail = (deopt != NULL) ? deopt : &fail_label;
 
   if (emit_full_guard) {
-    __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);
+    __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
 
     FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset());
     FieldAddress field_nullability_operand(
         field_reg, Field::is_nullable_offset());
 
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
 
       __ cmpl(value_cid_reg, field_cid_operand);
       __ j(EQUAL, &ok);
@@ skipping 48 matching lines @@
     ASSERT(deopt != NULL);
 
     // Field guard class has been initialized and is known.
     if (value_cid == kDynamicCid) {
       // 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);
-        __ CompareImmediate(value_cid_reg, Immediate(field_cid), PP);
+        __ CompareImmediate(value_cid_reg, Immediate(field_cid));
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ j(EQUAL, &ok);
-        __ CompareObject(value_reg, Object::null_object(), PP);
+        __ CompareObject(value_reg, Object::null_object());
       }
 
       __ j(NOT_EQUAL, fail);
     } else {
       // Both value's and field's class id is known.
       ASSERT((value_cid != field_cid) && (value_cid != nullability));
       __ jmp(fail);
     }
   }
   __ Bind(&ok);
@@ skipping 35 matching lines @@
   const Register value_reg = locs()->in(0).reg();
 
   if (!compiler->is_optimizing() ||
       (field().guarded_list_length() == Field::kUnknownFixedLength)) {
     const Register field_reg = locs()->temp(0).reg();
     const Register offset_reg = locs()->temp(1).reg();
     const Register length_reg = locs()->temp(2).reg();
 
     Label ok;
 
-    __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);
+    __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
 
     __ movsxb(offset_reg, FieldAddress(field_reg,
         Field::guarded_list_length_in_object_offset_offset()));
     __ movq(length_reg, FieldAddress(field_reg,
         Field::guarded_list_length_offset()));
 
     __ cmpq(offset_reg, Immediate(0));
     __ j(NEGATIVE, &ok);
 
     // Load the length from the value. GuardFieldClass already verified that
@@ skipping 16 matching lines @@
     __ Bind(&ok);
   } else {
     ASSERT(compiler->is_optimizing());
     ASSERT(field().guarded_list_length() >= 0);
     ASSERT(field().guarded_list_length_in_object_offset() !=
         Field::kUnknownLengthOffset);
 
     __ CompareImmediate(
             FieldAddress(value_reg,
                          field().guarded_list_length_in_object_offset()),
-            Immediate(Smi::RawValue(field().guarded_list_length())),
-            PP);
+            Immediate(Smi::RawValue(field().guarded_list_length())));
     __ j(NOT_EQUAL, deopt);
   }
 }
 
 
 class BoxAllocationSlowPath : public SlowPathCode {
  public:
   BoxAllocationSlowPath(Instruction* instruction,
                         const Class& cls,
                         Register result)
@@ skipping 29 matching lines @@
   }
 
   static void Allocate(FlowGraphCompiler* compiler,
                        Instruction* instruction,
                        const Class& cls,
                        Register result) {
     if (compiler->intrinsic_mode()) {
       __ TryAllocate(cls,
                      compiler->intrinsic_slow_path_label(),
                      Assembler::kFarJump,
-                     result,
-                     PP);
+                     result);
     } else {
       BoxAllocationSlowPath* slow_path =
           new BoxAllocationSlowPath(instruction, cls, result);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(cls,
                      slow_path->entry_label(),
                      Assembler::kFarJump,
-                     result,
-                     PP);
+                     result);
       __ Bind(slow_path->exit_label());
     }
   }
 
  private:
   Instruction* instruction_;
   const Class& cls_;
   const Register result_;
 };
 
@@ skipping 35 matching lines @@
 
 static void EnsureMutableBox(FlowGraphCompiler* compiler,
                              StoreInstanceFieldInstr* instruction,
                              Register box_reg,
                              const Class& cls,
                              Register instance_reg,
                              intptr_t offset,
                              Register temp) {
   Label done;
   __ movq(box_reg, FieldAddress(instance_reg, offset));
-  __ CompareObject(box_reg, Object::null_object(), PP);
+  __ CompareObject(box_reg, Object::null_object());
   __ j(NOT_EQUAL, &done);
   BoxAllocationSlowPath::Allocate(compiler, instruction, cls, box_reg);
   __ movq(temp, box_reg);
   __ StoreIntoObject(instance_reg,
                      FieldAddress(instance_reg, offset),
                      temp);
 
   __ Bind(&done);
 }
 
@@ skipping 63 matching lines @@
       // Value input is a writable register and should be manually preserved
       // across allocation slow-path.
       locs()->live_registers()->Add(locs()->in(1), kTagged);
     }
 
     Label store_pointer;
     Label store_double;
     Label store_float32x4;
     Label store_float64x2;
 
-    __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);
+    __ LoadObject(temp, Field::ZoneHandle(field().raw()));
 
     __ cmpl(FieldAddress(temp, Field::is_nullable_offset()),
             Immediate(kNullCid));
     __ j(EQUAL, &store_pointer);
 
     __ movzxb(temp2, FieldAddress(temp, Field::kind_bits_offset()));
     __ testq(temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ j(ZERO, &store_pointer);
 
     __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()),
@@ skipping 65 matching lines @@
     Register value_reg = locs()->in(1).reg();
     __ StoreIntoObject(instance_reg,
                        FieldAddress(instance_reg, offset_in_bytes_),
                        value_reg,
                        CanValueBeSmi());
   } else {
     if (locs()->in(1).IsConstant()) {
       __ StoreIntoObjectNoBarrier(instance_reg,
                                   FieldAddress(instance_reg, offset_in_bytes_),
                                   locs()->in(1).constant(),
-                                  PP,
                                   is_object_reference_initialization_ ?
                                       Assembler::kEmptyOrSmiOrNull :
                                       Assembler::kHeapObjectOrSmi);
     } else {
       Register value_reg = locs()->in(1).reg();
       __ StoreIntoObjectNoBarrier(instance_reg,
           FieldAddress(instance_reg, offset_in_bytes_),
           value_reg,
           is_object_reference_initialization_ ?
               Assembler::kEmptyOrSmiOrNull :
@@ skipping 36 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(), PP);
+  __ LoadObject(temp, field());
   if (this->value()->NeedsStoreBuffer()) {
     __ StoreIntoObject(temp,
         FieldAddress(temp, Field::value_offset()), value, CanValueBeSmi());
   } else {
     __ StoreIntoObjectNoBarrier(
         temp, FieldAddress(temp, Field::value_offset()), value);
   }
 }
 
 
@@ skipping 65 matching lines @@
                               FieldAddress(RAX, Array::length_offset()),
                               kLengthReg);
 
   // Initialize all array elements to raw_null.
   // RAX: new object start as a tagged pointer.
   // RCX: new object end address.
   // RDI: iterator which initially points to the start of the variable
   // data area to be initialized.
   if (num_elements > 0) {
     const intptr_t array_size = instance_size - sizeof(RawArray);
-    __ LoadObject(R12, Object::null_object(), PP);
+    __ LoadObject(R12, Object::null_object());
     __ leaq(RDI, FieldAddress(RAX, sizeof(RawArray)));
     if (array_size < (kInlineArraySize * kWordSize)) {
       intptr_t current_offset = 0;
       while (current_offset < array_size) {
         __ InitializeFieldNoBarrier(RAX, Address(RDI, current_offset), R12);
         current_offset += kWordSize;
       }
     } else {
       Label init_loop;
       __ Bind(&init_loop);
@@ skipping 17 matching lines @@
 
   Label slow_path, done;
   if (compiler->is_optimizing() &&
       num_elements()->BindsToConstant() &&
       num_elements()->BoundConstant().IsSmi()) {
     const intptr_t length = Smi::Cast(num_elements()->BoundConstant()).Value();
     if ((length >= 0) && (length <= Array::kMaxElements)) {
       Label slow_path, done;
       InlineArrayAllocation(compiler, length, &slow_path, &done);
       __ Bind(&slow_path);
-      __ PushObject(Object::null_object(), PP);  // Make room for the result.
+      __ PushObject(Object::null_object());  // Make room for the result.
       __ pushq(kLengthReg);
       __ pushq(kElemTypeReg);
       compiler->GenerateRuntimeCall(token_pos(),
                                     deopt_id(),
                                     kAllocateArrayRuntimeEntry,
                                     2,
                                     locs());
       __ Drop(2);
       __ popq(kResultReg);
       __ Bind(&done);
@@ skipping 69 matching lines @@
   Register result = locs()->out(0).reg();
   if (IsPotentialUnboxedLoad()) {
     Register temp = locs()->temp(1).reg();
     XmmRegister value = locs()->temp(0).fpu_reg();
 
     Label load_pointer;
     Label load_double;
     Label load_float32x4;
     Label load_float64x2;
 
-    __ LoadObject(result, Field::ZoneHandle(field()->raw()), PP);
+    __ LoadObject(result, Field::ZoneHandle(field()->raw()));
 
     __ cmpl(FieldAddress(result, Field::is_nullable_offset()),
             Immediate(kNullCid));
     __ j(EQUAL, &load_pointer);
 
     __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kDoubleCid));
     __ j(EQUAL, &load_double);
 
     __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
@@ skipping 59 matching lines @@
   return locs;
 }
 
 
 void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out(0).reg();
 
   // 'instantiator_reg' is the instantiator TypeArguments object (or null).
   // A runtime call to instantiate the type is required.
-  __ PushObject(Object::null_object(), PP);  // Make room for the result.
-  __ PushObject(type(), PP);
+  __ PushObject(Object::null_object());  // Make room for the result.
+  __ PushObject(type());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type.
   __ popq(result_reg);  // Pop instantiated type.
   ASSERT(instantiator_reg == result_reg);
 }
@@ skipping 21 matching lines @@
   // 'instantiator_reg' is the instantiator TypeArguments 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;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    __ CompareObject(instantiator_reg, Object::null_object(), PP);
+    __ CompareObject(instantiator_reg, Object::null_object());
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
 
   // Lookup cache before calling runtime.
   // TODO(fschneider): Consider moving this into a shared stub to reduce
   // generated code size.
-  __ LoadObject(RDI, type_arguments(), PP);
+  __ LoadObject(RDI, type_arguments());
   __ movq(RDI, FieldAddress(RDI, TypeArguments::instantiations_offset()));
   __ leaq(RDI, FieldAddress(RDI, Array::data_offset()));
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   Label loop, found, slow_case;
   __ Bind(&loop);
   __ movq(RDX, Address(RDI, 0 * kWordSize));  // Cached instantiator.
   __ cmpq(RDX, RAX);
   __ j(EQUAL, &found, Assembler::kNearJump);
   __ addq(RDI, Immediate(2 * kWordSize));
   __ cmpq(RDX, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
   __ jmp(&slow_case, Assembler::kNearJump);
   __ Bind(&found);
   __ movq(RAX, Address(RDI, 1 * kWordSize));  // Cached instantiated args.
   __ jmp(&type_arguments_instantiated, Assembler::kNearJump);
 
   __ Bind(&slow_case);
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
-  __ PushObject(Object::null_object(), PP);  // Make room for the result.
-  __ PushObject(type_arguments(), PP);
+  __ PushObject(Object::null_object());  // Make room for the result.
+  __ PushObject(type_arguments());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
@@ skipping 22 matching lines @@
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("AllocateContextSlowPath");
     __ Bind(entry_label());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
 
-    __ LoadImmediate(R10, Immediate(instruction_->num_context_variables()), PP);
+    __ LoadImmediate(R10, Immediate(instruction_->num_context_variables()));
     const ExternalLabel label(StubCode::AllocateContextEntryPoint());
     compiler->GenerateCall(instruction_->token_pos(),
                            &label,
                            RawPcDescriptors::kOther,
                            locs);
     ASSERT(instruction_->locs()->out(0).reg() == RAX);
     compiler->RestoreLiveRegisters(instruction_->locs());
     __ jmp(exit_label());
   }
 
@@ skipping 34 matching lines @@
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(0, Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
   ASSERT(locs()->out(0).reg() == RAX);
 
-  __ LoadImmediate(R10, Immediate(num_context_variables()), PP);
+  __ LoadImmediate(R10, Immediate(num_context_variables()));
   const ExternalLabel label(StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          RawPcDescriptors::kOther,
                          locs());
 }
 
 
 LocationSummary* InitStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_temp(0, Location::RegisterLocation(RCX));
   return locs;
 }
 
 
 void InitStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register field = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
 
   Label call_runtime, no_call;
 
   __ movq(temp, FieldAddress(field, Field::value_offset()));
-  __ CompareObject(temp, Object::sentinel(), PP);
+  __ CompareObject(temp, Object::sentinel());
   __ j(EQUAL, &call_runtime);
 
-  __ CompareObject(temp, Object::transition_sentinel(), PP);
+  __ CompareObject(temp, Object::transition_sentinel());
   __ j(NOT_EQUAL, &no_call);
 
   __ Bind(&call_runtime);
-  __ PushObject(Object::null_object(), PP);  // Make room for (unused) result.
+  __ PushObject(Object::null_object());  // Make room for (unused) result.
   __ pushq(field);
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInitStaticFieldRuntimeEntry,
                                 1,
                                 locs());
   __ Drop(2);  // Remove argument and unused result.
   __ Bind(&no_call);
 }
 
 
 LocationSummary* CloneContextInstr::MakeLocationSummary(Zone* zone,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(0, Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
 
-  __ PushObject(Object::null_object(), PP);  // Make room for the result.
+  __ PushObject(Object::null_object());  // Make room for the result.
   __ pushq(context_value);
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kCloneContextRuntimeEntry,
                                 1,
                                 locs());
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
@@ skipping 53 matching lines @@
  public:
   explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
       uword flags_address = Isolate::Current()->stack_overflow_flags_address();
       Register temp = instruction_->locs()->temp(0).reg();
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
-      __ LoadImmediate(temp, Immediate(flags_address), PP);
+      __ LoadImmediate(temp, Immediate(flags_address));
       __ movq(Address(temp, 0), Immediate(Isolate::kOsrRequest));
     }
     __ Comment("CheckStackOverflowSlowPath");
     __ Bind(entry_label());
     compiler->SaveLiveRegisters(instruction_->locs());
     // pending_deoptimization_env_ is needed to generate a runtime call that
     // may throw an exception.
     ASSERT(compiler->pending_deoptimization_env_ == NULL);
     Environment* env = compiler->SlowPathEnvironmentFor(instruction_);
     compiler->pending_deoptimization_env_ = env;
@@ skipping 27 matching lines @@
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
   if (compiler->is_optimizing()) {
     __ LoadImmediate(
-        temp, Immediate(Isolate::Current()->stack_limit_address()), PP);
+        temp, Immediate(Isolate::Current()->stack_limit_address()));
     __ cmpq(RSP, Address(temp, 0));
   } else {
     __ LoadIsolate(temp);
     __ cmpq(RSP, Address(temp, Isolate::stack_limit_offset()));
   }
   __ 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(), PP);
+    __ LoadObject(temp, compiler->parsed_function().function());
     int32_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
     __ cmpl(FieldAddress(temp, Function::usage_counter_offset()),
             Immediate(threshold));
     __ j(GREATER_EQUAL, slow_path->osr_entry_label());
   }
   if (compiler->ForceSlowPathForStackOverflow()) {
     __ jmp(slow_path->entry_label());
   }
   __ Bind(slow_path->exit_label());
 }
 
 
 static void EmitJavascriptOverflowCheck(FlowGraphCompiler* compiler,
                                         Range* range,
                                         Label* overflow,
                                         Register result) {
   if (!RangeUtils::IsWithin(range, -0x20000000000000LL, 0x20000000000000LL)) {
     ASSERT(overflow != NULL);
     // TODO(zra): This can be tightened to one compare/branch using:
     // overflow = (result + 2^52) > 2^53 with an unsigned comparison.
-    __ CompareImmediate(result, Immediate(-0x20000000000000LL), PP);
+    __ CompareImmediate(result, Immediate(-0x20000000000000LL));
     __ j(LESS, overflow);
-    __ CompareImmediate(result, Immediate(0x20000000000000LL), PP);
+    __ CompareImmediate(result, Immediate(0x20000000000000LL));
     __ j(GREATER, overflow);
   }
 }
 
 
 static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
                              BinarySmiOpInstr* shift_left) {
   const LocationSummary& locs = *shift_left->locs();
   Register left = locs.in(0).reg();
   Register result = locs.out(0).reg();
@@ skipping 28 matching lines @@
   // Right (locs.in(1)) is not constant.
   Register right = locs.in(1).reg();
   Range* right_range = shift_left->right()->definition()->range();
   if (shift_left->left()->BindsToConstant() && shift_left->can_overflow()) {
     // TODO(srdjan): Implement code below for is_truncating().
     // If left is constant, we know the maximal allowed size for right.
     const Object& obj = shift_left->left()->BoundConstant();
     if (obj.IsSmi()) {
       const intptr_t left_int = Smi::Cast(obj).Value();
       if (left_int == 0) {
-        __ CompareImmediate(right, Immediate(0), PP);
+        __ CompareImmediate(right, Immediate(0));
         __ j(NEGATIVE, deopt);
         return;
       }
       const intptr_t max_right = kSmiBits - Utils::HighestBit(left_int);
       const bool right_needs_check =
           !RangeUtils::IsWithin(right_range, 0, max_right - 1);
       if (right_needs_check) {
         __ CompareImmediate(right,
-            Immediate(reinterpret_cast<int64_t>(Smi::New(max_right))), PP);
+            Immediate(reinterpret_cast<int64_t>(Smi::New(max_right))));
         __ j(ABOVE_EQUAL, deopt);
       }
       __ SmiUntag(right);
       __ shlq(left, right);
     }
     if (FLAG_throw_on_javascript_int_overflow) {
       EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
     }
     return;
   }
 
   const bool right_needs_check =
       !RangeUtils::IsWithin(right_range, 0, (Smi::kBits - 1));
   ASSERT(right == RCX);  // Count must be in RCX
   if (!shift_left->can_overflow()) {
     if (right_needs_check) {
       const bool right_may_be_negative =
           (right_range == NULL) || !right_range->IsPositive();
       if (right_may_be_negative) {
         ASSERT(shift_left->CanDeoptimize());
-        __ CompareImmediate(right, Immediate(0), PP);
+        __ CompareImmediate(right, Immediate(0));
         __ j(NEGATIVE, deopt);
       }
       Label done, is_not_zero;
       __ CompareImmediate(right,
-          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))), PP);
+          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
       __ j(BELOW, &is_not_zero, Assembler::kNearJump);
       __ xorq(left, left);
       __ jmp(&done, Assembler::kNearJump);
       __ Bind(&is_not_zero);
       __ SmiUntag(right);
       __ shlq(left, right);
       __ Bind(&done);
     } else {
       __ SmiUntag(right);
       __ shlq(left, right);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
       __ CompareImmediate(right,
-          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))), PP);
+          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
       __ j(ABOVE_EQUAL, deopt);
     }
     // Left is not a constant.
     Register temp = locs.temp(0).reg();
     // Check if count too large for handling it inlined.
     __ movq(temp, left);
     __ SmiUntag(right);
     // Overflow test (preserve temp and right);
     __ shlq(left, right);
     __ sarq(left, right);
@@ skipping 112 matching lines @@
   if (CanDeoptimize()) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int64_t imm = reinterpret_cast<int64_t>(constant.raw());
     switch (op_kind()) {
       case Token::kADD: {
-        __ AddImmediate(left, Immediate(imm), PP);
+        __ AddImmediate(left, Immediate(imm));
         if (deopt != NULL) __ j(OVERFLOW, deopt);
         break;
       }
       case Token::kSUB: {
-        __ SubImmediate(left, Immediate(imm), PP);
+        __ SubImmediate(left, Immediate(imm));
         if (deopt != NULL) __ j(OVERFLOW, deopt);
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
         const intptr_t value = Smi::Cast(constant).Value();
-        __ MulImmediate(left, Immediate(value), PP);
+        __ MulImmediate(left, Immediate(value));
         if (deopt != NULL) __ j(OVERFLOW, deopt);
         break;
       }
       case Token::kTRUNCDIV: {
         const intptr_t value = Smi::Cast(constant).Value();
         ASSERT(Utils::IsPowerOfTwo(Utils::Abs(value)));
         const intptr_t shift_count =
             Utils::ShiftForPowerOfTwo(Utils::Abs(value)) + kSmiTagSize;
         ASSERT(kSmiTagSize == 1);
         Register temp = locs()->temp(0).reg();
         __ movq(temp, left);
         __ sarq(temp, Immediate(63));
         ASSERT(shift_count > 1);  // 1, -1 case handled above.
         __ shrq(temp, Immediate(64 - shift_count));
         __ addq(left, temp);
         ASSERT(shift_count > 0);
         __ sarq(left, Immediate(shift_count));
         if (value < 0) {
           __ negq(left);
         }
         __ SmiTag(left);
         break;
       }
       case Token::kBIT_AND: {
         // No overflow check.
-        __ AndImmediate(left, Immediate(imm), PP);
+        __ AndImmediate(left, Immediate(imm));
         break;
       }
       case Token::kBIT_OR: {
         // No overflow check.
-        __ OrImmediate(left, Immediate(imm), PP);
+        __ OrImmediate(left, Immediate(imm));
         break;
       }
       case Token::kBIT_XOR: {
         // No overflow check.
-        __ XorImmediate(left, Immediate(imm), PP);
+        __ XorImmediate(left, Immediate(imm));
         break;
       }
 
       case Token::kSHR: {
         // sarq operation masks the count to 6 bits.
         const intptr_t kCountLimit = 0x3F;
         const intptr_t value = Smi::Cast(constant).Value();
         __ sarq(left, Immediate(
             Utils::Minimum(value + kSmiTagSize, kCountLimit)));
         __ SmiTag(left);
@@ skipping 124 matching lines @@
       __ jmp(&done);
 
       // Divide using 64bit idiv.
       __ Bind(&not_32bit);
       __ SmiUntag(left);
       __ SmiUntag(right);
       __ cqo();  // Sign extend RAX -> RDX:RAX.
       __ idivq(right);  //  RAX: quotient, RDX: remainder.
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
-      __ CompareImmediate(result, Immediate(0x4000000000000000), PP);
+      __ CompareImmediate(result, Immediate(0x4000000000000000));
       __ j(EQUAL, deopt);
       __ Bind(&done);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
       Label not_32bit, div_done;
 
       Register temp = locs()->temp(0).reg();
       ASSERT(left == RDX);
@@ skipping 59 matching lines @@
       } else {
         // Right is negative.
         __ subq(result, right);
       }
       __ Bind(&all_done);
       __ SmiTag(result);
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
-        __ CompareImmediate(right, Immediate(0), PP);
+        __ CompareImmediate(right, Immediate(0));
         __ j(LESS, deopt);
       }
       __ SmiUntag(right);
       // sarq operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
       if ((right_range == NULL) ||
           !right_range->OnlyLessThanOrEqualTo(kCountLimit)) {
-        __ CompareImmediate(right, Immediate(kCountLimit), PP);
+        __ CompareImmediate(right, Immediate(kCountLimit));
         Label count_ok;
         __ j(LESS, &count_ok, Assembler::kNearJump);
-        __ LoadImmediate(right, Immediate(kCountLimit), PP);
+        __ LoadImmediate(right, Immediate(kCountLimit));
         __ Bind(&count_ok);
       }
       ASSERT(right == RCX);  // Count must be in RCX
       __ SmiUntag(left);
       __ sarq(left, right);
       __ SmiTag(left);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
@@ skipping 529 matching lines @@
   return summary;
 }
 
 
 void Float32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister v0 = locs()->in(0).fpu_reg();
   XmmRegister v1 = locs()->in(1).fpu_reg();
   XmmRegister v2 = locs()->in(2).fpu_reg();
   XmmRegister v3 = locs()->in(3).fpu_reg();
   ASSERT(v0 == locs()->out(0).fpu_reg());
-  __ AddImmediate(RSP, Immediate(-16), PP);
+  __ AddImmediate(RSP, Immediate(-16));
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 0), v0);
   __ movsd(v0, v1);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 4), v0);
   __ movsd(v0, v2);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 8), v0);
   __ movsd(v0, v3);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 12), v0);
   __ movups(v0, Address(RSP, 0));
-  __ AddImmediate(RSP, Immediate(16), PP);
+  __ AddImmediate(RSP, Immediate(16));
 }
 
 
 LocationSummary* Float32x4ZeroInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_out(0, Location::RequiresFpuRegister());
@@ skipping 233 matching lines @@
 
 void Float32x4WithInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister replacement = locs()->in(0).fpu_reg();
   XmmRegister value = locs()->in(1).fpu_reg();
 
   ASSERT(locs()->out(0).fpu_reg() == replacement);
 
   switch (op_kind()) {
     case MethodRecognizer::kFloat32x4WithX:
       __ cvtsd2ss(replacement, replacement);
-      __ AddImmediate(RSP, Immediate(-16), PP);
+      __ AddImmediate(RSP, Immediate(-16));
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over X value.
       __ movss(Address(RSP, 0), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ AddImmediate(RSP, Immediate(16), PP);
+      __ AddImmediate(RSP, Immediate(16));
       break;
     case MethodRecognizer::kFloat32x4WithY:
       __ cvtsd2ss(replacement, replacement);
-      __ AddImmediate(RSP, Immediate(-16), PP);
+      __ AddImmediate(RSP, Immediate(-16));
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over Y value.
       __ movss(Address(RSP, 4), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ AddImmediate(RSP, Immediate(16), PP);
+      __ AddImmediate(RSP, Immediate(16));
       break;
     case MethodRecognizer::kFloat32x4WithZ:
       __ cvtsd2ss(replacement, replacement);
-      __ AddImmediate(RSP, Immediate(-16), PP);
+      __ AddImmediate(RSP, Immediate(-16));
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over Z value.
       __ movss(Address(RSP, 8), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ AddImmediate(RSP, Immediate(16), PP);
+      __ AddImmediate(RSP, Immediate(16));
       break;
     case MethodRecognizer::kFloat32x4WithW:
       __ cvtsd2ss(replacement, replacement);
-      __ AddImmediate(RSP, Immediate(-16), PP);
+      __ AddImmediate(RSP, Immediate(-16));
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over W value.
       __ movss(Address(RSP, 12), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ AddImmediate(RSP, Immediate(16), PP);
+      __ AddImmediate(RSP, Immediate(16));
       break;
     default: UNREACHABLE();
   }
 }
 
 
 LocationSummary* Float32x4ToInt32x4Instr::MakeLocationSummary(Zone* zone,
                                                               bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 244 matching lines @@
   return summary;
 }
 
 
 void Int32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register v0 = locs()->in(0).reg();
   Register v1 = locs()->in(1).reg();
   Register v2 = locs()->in(2).reg();
   Register v3 = locs()->in(3).reg();
   XmmRegister result = locs()->out(0).fpu_reg();
-  __ AddImmediate(RSP, Immediate(-4 * kInt32Size), PP);
+  __ AddImmediate(RSP, Immediate(-4 * kInt32Size));
   __ movl(Address(RSP, 0 * kInt32Size), v0);
   __ movl(Address(RSP, 1 * kInt32Size), v1);
   __ movl(Address(RSP, 2 * kInt32Size), v2);
   __ movl(Address(RSP, 3 * kInt32Size), v3);
   __ movups(result, Address(RSP, 0));
-  __ AddImmediate(RSP, Immediate(4 * kInt32Size), PP);
+  __ AddImmediate(RSP, Immediate(4 * kInt32Size));
 }
 
 
 LocationSummary* Int32x4BoolConstructorInstr::MakeLocationSummary(
     Zone* zone, bool opt) const {
   const intptr_t kNumInputs = 4;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
@@ skipping 10 matching lines @@
   Register v0 = locs()->in(0).reg();
   Register v1 = locs()->in(1).reg();
   Register v2 = locs()->in(2).reg();
   Register v3 = locs()->in(3).reg();
   Register temp = locs()->temp(0).reg();
   XmmRegister result = locs()->out(0).fpu_reg();
   Label x_false, x_done;
   Label y_false, y_done;
   Label z_false, z_done;
   Label w_false, w_done;
-  __ AddImmediate(RSP, Immediate(-16), PP);
+  __ AddImmediate(RSP, Immediate(-16));
 
-  __ CompareObject(v0, Bool::True(), PP);
+  __ CompareObject(v0, Bool::True());
   __ j(NOT_EQUAL, &x_false);
-  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
   __ jmp(&x_done);
   __ Bind(&x_false);
-  __ LoadImmediate(temp, Immediate(0x0), PP);
+  __ LoadImmediate(temp, Immediate(0x0));
   __ Bind(&x_done);
   __ movl(Address(RSP, 0), temp);
 
-  __ CompareObject(v1, Bool::True(), PP);
+  __ CompareObject(v1, Bool::True());
   __ j(NOT_EQUAL, &y_false);
-  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
   __ jmp(&y_done);
   __ Bind(&y_false);
-  __ LoadImmediate(temp, Immediate(0x0), PP);
+  __ LoadImmediate(temp, Immediate(0x0));
   __ Bind(&y_done);
   __ movl(Address(RSP, 4), temp);
 
-  __ CompareObject(v2, Bool::True(), PP);
+  __ CompareObject(v2, Bool::True());
   __ j(NOT_EQUAL, &z_false);
-  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
   __ jmp(&z_done);
   __ Bind(&z_false);
-  __ LoadImmediate(temp, Immediate(0x0), PP);
+  __ LoadImmediate(temp, Immediate(0x0));
   __ Bind(&z_done);
   __ movl(Address(RSP, 8), temp);
 
-  __ CompareObject(v3, Bool::True(), PP);
+  __ CompareObject(v3, Bool::True());
   __ j(NOT_EQUAL, &w_false);
-  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
   __ jmp(&w_done);
   __ Bind(&w_false);
-  __ LoadImmediate(temp, Immediate(0x0), PP);
+  __ LoadImmediate(temp, Immediate(0x0));
   __ Bind(&w_done);
   __ movl(Address(RSP, 12), temp);
 
   __ movups(result, Address(RSP, 0));
-  __ AddImmediate(RSP, Immediate(16), PP);
+  __ AddImmediate(RSP, Immediate(16));
 }
 
 
 LocationSummary* Int32x4GetFlagInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void Int32x4GetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister value = locs()->in(0).fpu_reg();
   Register result = locs()->out(0).reg();
   Label done;
   Label non_zero;
-  __ AddImmediate(RSP, Immediate(-16), PP);
+  __ AddImmediate(RSP, Immediate(-16));
   // Move value to stack.
   __ movups(Address(RSP, 0), value);
   switch (op_kind()) {
     case MethodRecognizer::kInt32x4GetFlagX:
       __ movl(result, Address(RSP, 0));
       break;
     case MethodRecognizer::kInt32x4GetFlagY:
       __ movl(result, Address(RSP, 4));
       break;
     case MethodRecognizer::kInt32x4GetFlagZ:
       __ movl(result, Address(RSP, 8));
       break;
     case MethodRecognizer::kInt32x4GetFlagW:
       __ movl(result, Address(RSP, 12));
       break;
     default: UNREACHABLE();
   }
-  __ AddImmediate(RSP, Immediate(16), PP);
+  __ AddImmediate(RSP, Immediate(16));
   __ testl(result, result);
   __ j(NOT_ZERO, &non_zero, Assembler::kNearJump);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ jmp(&done);
   __ Bind(&non_zero);
-  __ LoadObject(result, Bool::True(), PP);
+  __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 LocationSummary* Int32x4SelectInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 38 matching lines @@
   summary->set_out(0, Location::SameAsFirstInput());
   return summary;
 }
 
 
 void Int32x4SetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister mask = locs()->in(0).fpu_reg();
   Register flag = locs()->in(1).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(mask == locs()->out(0).fpu_reg());
-  __ AddImmediate(RSP, Immediate(-16), PP);
+  __ AddImmediate(RSP, Immediate(-16));
   // Copy mask to stack.
   __ movups(Address(RSP, 0), mask);
   Label falsePath, exitPath;
-  __ CompareObject(flag, Bool::True(), PP);
+  __ CompareObject(flag, Bool::True());
   __ j(NOT_EQUAL, &falsePath);
   switch (op_kind()) {
     case MethodRecognizer::kInt32x4WithFlagX:
-      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
       __ movl(Address(RSP, 0), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ LoadImmediate(temp, Immediate(0x0), PP);
+      __ LoadImmediate(temp, Immediate(0x0));
       __ movl(Address(RSP, 0), temp);
     break;
     case MethodRecognizer::kInt32x4WithFlagY:
-      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
       __ movl(Address(RSP, 4), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ LoadImmediate(temp, Immediate(0x0), PP);
+      __ LoadImmediate(temp, Immediate(0x0));
       __ movl(Address(RSP, 4), temp);
     break;
     case MethodRecognizer::kInt32x4WithFlagZ:
-      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
       __ movl(Address(RSP, 8), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ LoadImmediate(temp, Immediate(0x0), PP);
+      __ LoadImmediate(temp, Immediate(0x0));
       __ movl(Address(RSP, 8), temp);
     break;
     case MethodRecognizer::kInt32x4WithFlagW:
-      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF));
       __ movl(Address(RSP, 12), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ LoadImmediate(temp, Immediate(0x0), PP);
+      __ LoadImmediate(temp, Immediate(0x0));
       __ movl(Address(RSP, 12), temp);
     break;
     default: UNREACHABLE();
   }
   __ Bind(&exitPath);
   // Copy mask back to register.
   __ movups(mask, Address(RSP, 0));
-  __ AddImmediate(RSP, Immediate(16), PP);
+  __ AddImmediate(RSP, Immediate(16));
 }
 
 
 LocationSummary* Int32x4ToFloat32x4Instr::MakeLocationSummary(Zone* zone,
                                                               bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
@@ skipping 154 matching lines @@
       __ negq(value);
       __ j(OVERFLOW, deopt);
       if (FLAG_throw_on_javascript_int_overflow) {
         EmitJavascriptOverflowCheck(compiler, range(), deopt, value);
       }
       break;
     }
     case Token::kBIT_NOT:
       __ notq(value);
       // Remove inverted smi-tag.
-      __ AndImmediate(value, Immediate(~kSmiTagMask), PP);
+      __ AndImmediate(value, Immediate(~kSmiTagMask));
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* UnaryDoubleOpInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 56 matching lines @@
     const Condition double_condition =
         is_min ? TokenKindToDoubleCondition(Token::kLT)
                : TokenKindToDoubleCondition(Token::kGT);
     ASSERT(left == result);
     __ j(double_condition, &done, Assembler::kNearJump);
     __ movsd(result, right);
     __ jmp(&done, Assembler::kNearJump);
 
     __ Bind(&returns_nan);
     static double kNaN = NAN;
-    __ LoadImmediate(temp, Immediate(reinterpret_cast<intptr_t>(&kNaN)), PP);
+    __ LoadImmediate(temp, Immediate(reinterpret_cast<intptr_t>(&kNaN)));
     __ movsd(result, Address(temp, 0));
     __ jmp(&done, Assembler::kNearJump);
 
     __ Bind(&are_equal);
     Label left_is_negative;
     // Check for negative zero: -0.0 is equal 0.0 but min or max must return
     // -0.0 or 0.0 respectively.
     // Check for negative left value (get the sign bit):
     // - min -> left is negative ? left : right.
     // - max -> left is negative ? right : left
@@ skipping 280 matching lines @@
 
   XmmRegister base = locs->in(0).fpu_reg();
   XmmRegister exp = locs->in(1).fpu_reg();
   XmmRegister result = locs->out(0).fpu_reg();
   Register temp =
       locs->temp(InvokeMathCFunctionInstr::kObjectTempIndex).reg();
   XmmRegister zero_temp =
       locs->temp(InvokeMathCFunctionInstr::kDoubleTempIndex).fpu_reg();
 
   __ xorps(zero_temp, zero_temp);
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)), PP);
+  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)));
   __ movsd(result, FieldAddress(temp, Double::value_offset()));
 
   Label check_base, skip_call;
   // exponent == 0.0 -> return 1.0;
   __ comisd(exp, zero_temp);
   __ j(PARITY_EVEN, &check_base, Assembler::kNearJump);
   __ j(EQUAL, &skip_call);  // 'result' is 1.0.
 
   // exponent == 1.0 ?
   __ comisd(exp, result);
   Label return_base;
   __ j(EQUAL, &return_base, Assembler::kNearJump);
 
   // exponent == 2.0 ?
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(2.0)), PP);
+  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(2.0)));
   __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
   __ comisd(exp, XMM0);
   Label return_base_times_2;
   __ j(EQUAL, &return_base_times_2, Assembler::kNearJump);
 
   // exponent == 3.0 ?
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(3.0)), PP);
+  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(3.0)));
   __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
   __ comisd(exp, XMM0);
   __ j(NOT_EQUAL, &check_base);
 
   // Base times 3.
   __ movsd(result, base);
   __ mulsd(result, base);
   __ mulsd(result, base);
   __ jmp(&skip_call);
 
@@ skipping 14 matching lines @@
   __ comisd(base, result);
   __ j(PARITY_EVEN, &return_nan, Assembler::kNearJump);
   __ j(EQUAL, &skip_call, Assembler::kNearJump);
   // Note: 'base' could be NaN.
   __ comisd(exp, base);
   // Neither 'exp' nor 'base' is NaN.
   Label try_sqrt;
   __ j(PARITY_ODD, &try_sqrt, Assembler::kNearJump);
   // Return NaN.
   __ Bind(&return_nan);
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(NAN)), PP);
+  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(NAN)));
   __ movsd(result, FieldAddress(temp, Double::value_offset()));
   __ jmp(&skip_call);
 
   Label do_pow, return_zero;
   __ Bind(&try_sqrt);
   // Before calling pow, check if we could use sqrt instead of pow.
   __ LoadObject(temp,
-      Double::ZoneHandle(Double::NewCanonical(kNegInfinity)), PP);
+      Double::ZoneHandle(Double::NewCanonical(kNegInfinity)));
   __ movsd(result, FieldAddress(temp, Double::value_offset()));
   // base == -Infinity -> call pow;
   __ comisd(base, result);
   __ j(EQUAL, &do_pow, Assembler::kNearJump);
 
   // exponent == 0.5 ?
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0.5)), PP);
+  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0.5)));
   __ movsd(result, FieldAddress(temp, Double::value_offset()));
   __ comisd(exp, result);
   __ j(NOT_EQUAL, &do_pow, Assembler::kNearJump);
 
   // base == 0 -> return 0;
   __ comisd(base, zero_temp);
   __ j(EQUAL, &return_zero, Assembler::kNearJump);
 
   __ sqrtsd(result, base);
   __ jmp(&skip_call, Assembler::kNearJump);
@@ skipping 176 matching lines @@
     __ jmp(&done);
 
     // Divide using 64bit idiv.
     __ Bind(&not_32bit);
     __ SmiUntag(left);
     __ SmiUntag(right);
     __ cqo();  // Sign extend RAX -> RDX:RAX.
     __ idivq(right);  //  RAX: quotient, RDX: remainder.
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
-    __ CompareImmediate(RAX, Immediate(0x4000000000000000), PP);
+    __ CompareImmediate(RAX, Immediate(0x4000000000000000));
     __ j(EQUAL, deopt);
     __ Bind(&done);
 
     // Modulo correction (RDX).
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
     //    } else {
     //      res = res + right;
@@ skipping 103 matching lines @@
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         ICData::kDeoptCheckClass,
                                         licm_hoisted_ ? ICData::kHoisted : 0);
   if (IsNullCheck()) {
     __ CompareObject(locs()->in(0).reg(),
-                     Object::null_object(), PP);
+                     Object::null_object());
     Condition cond = DeoptIfNull() ? EQUAL : NOT_EQUAL;
     __ j(cond, 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 is_ok;
@@ skipping 74 matching lines @@
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckClass);
-  __ CompareImmediate(value, Immediate(Smi::RawValue(cid_)), PP);
+  __ CompareImmediate(value, Immediate(Smi::RawValue(cid_)));
   __ j(NOT_ZERO, deopt);
 }
 
 
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 21 matching lines @@
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ jmp(deopt);
     return;
   }
 
   if (index_loc.IsConstant()) {
     Register length = length_loc.reg();
     const Smi& index = Smi::Cast(index_loc.constant());
     __ CompareImmediate(
-        length, Immediate(reinterpret_cast<int64_t>(index.raw())), PP);
+        length, Immediate(reinterpret_cast<int64_t>(index.raw())));
     __ j(BELOW_EQUAL, deopt);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     Register index = index_loc.reg();
     if (length.Value() == Smi::kMaxValue) {
       __ testq(index, index);
       __ j(NEGATIVE, deopt);
     } else {
       __ CompareImmediate(
-          index, Immediate(reinterpret_cast<int64_t>(length.raw())), PP);
+          index, Immediate(reinterpret_cast<int64_t>(length.raw())));
       __ j(ABOVE_EQUAL, deopt);
     }
   } else {
     Register length = length_loc.reg();
     Register index = index_loc.reg();
     __ cmpq(index, length);
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
@@ skipping 636 matching lines @@
 
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
 
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 
   Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ jmp(&done);
   __ Bind(&is_true);
-  __ LoadObject(result, Bool::True(), PP);
+  __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                         BranchInstr* branch) {
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
 
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
@@ skipping 12 matching lines @@
   return summary;
 }
 
 
 void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Arguments descriptor is expected in R10.
   intptr_t argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
                                                  argument_names()));
-  __ LoadObject(R10, arguments_descriptor, PP);
+  __ LoadObject(R10, arguments_descriptor);
 
   // Function in RAX.
   ASSERT(locs()->in(0).reg() == RAX);
   __ movq(RCX, FieldAddress(RAX, Function::instructions_offset()));
 
   // RAX: Function.
   // R10: Arguments descriptor array.
   // RBX: Smi 0 (no IC data; the lazy-compile stub expects a GC-safe value).
   __ xorq(RBX, RBX);
   __ addq(RCX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
@@ skipping 22 matching lines @@
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
 
   Label done;
-  __ LoadObject(result, Bool::True(), PP);
+  __ LoadObject(result, Bool::True());
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ Bind(&done);
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
@@ skipping 28 matching lines @@
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(0, Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void GrowRegExpStackInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register typed_data = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
-  __ PushObject(Object::null_object(), PP);
+  __ PushObject(Object::null_object());
   __ pushq(typed_data);
   compiler->GenerateRuntimeCall(Scanner::kNoSourcePos,  // No token position.
                                 deopt_id(),
                                 kGrowRegExpStackRuntimeEntry,
                                 1,
                                 locs());
   __ Drop(1);
   __ popq(result);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64