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

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #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()) {
       __ Push(value.reg());
     } else if (value.IsConstant()) {
-      __ PushObject(value.constant(), PP);
+      __ PushObject(value.constant());
     } else {
       ASSERT(value.IsStackSlot());
       const intptr_t value_offset = value.ToStackSlotOffset();
-      __ LoadFromOffset(TMP, value.base_reg(), value_offset, PP);
+      __ LoadFromOffset(TMP, value.base_reg(), value_offset);
       __ Push(TMP);
     }
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary(Zone* zone,
                                                   bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 17 matching lines @@
     return;
   }
 
 #if defined(DEBUG)
   Label stack_ok;
   __ Comment("Stack Check");
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ sub(R2, SP, Operand(FP));
-  __ CompareImmediate(R2, fp_sp_dist, PP);
+  __ CompareImmediate(R2, fp_sp_dist);
   __ b(&stack_ok, EQ);
   __ brk(0);
   __ Bind(&stack_ok);
 #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 EQ: return NE;
     case NE: return EQ;
     case LT: return GE;
     case LE: return GT;
     case GT: return LE;
@@ skipping 58 matching lines @@
   __ cset(result, true_condition);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ LslImmediate(result, result, shift + kSmiTagSize);
   } else {
     __ sub(result, result, Operand(1));
     const int64_t val =
         Smi::RawValue(true_value) - Smi::RawValue(false_value);
-    __ AndImmediate(result, result, val, PP);
+    __ AndImmediate(result, result, val);
     if (false_value != 0) {
-      __ AddImmediate(result, result, Smi::RawValue(false_value), PP);
+      __ AddImmediate(result, result, Smi::RawValue(false_value));
     }
   }
 }
 
 
 LocationSummary* ClosureCallInstr::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::kCall);
   summary->set_in(0, Location::RegisterLocation(R0));  // Function.
   summary->set_out(0, Location::RegisterLocation(R0));
   return summary;
 }
 
 
 void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Load arguments descriptor in R4.
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
                                                  argument_names()));
-  __ LoadObject(R4, arguments_descriptor, PP);
+  __ LoadObject(R4, arguments_descriptor);
 
   // R4: Arguments descriptor.
   // R0: Function.
   ASSERT(locs()->in(0).reg() == R0);
-  __ LoadFieldFromOffset(R2, R0, Function::instructions_offset(), PP);
+  __ LoadFieldFromOffset(R2, R0, Function::instructions_offset());
 
   // R2: instructions.
   // R5: Smi 0 (no IC data; the lazy-compile stub expects a GC-safe value).
-  __ LoadImmediate(R5, 0, PP);
-  __ AddImmediate(R2, R2, Instructions::HeaderSize() - kHeapObjectTag, PP);
+  __ LoadImmediate(R5, 0);
+  __ AddImmediate(R2, R2, Instructions::HeaderSize() - kHeapObjectTag);
   __ blr(R2);
   compiler->RecordSafepoint(locs());
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
   const intptr_t deopt_id_after = Isolate::ToDeoptAfter(deopt_id());
   if (compiler->is_optimizing()) {
     compiler->AddDeoptIndexAtCall(deopt_id_after, token_pos());
   }
   // Add deoptimization continuation point after the call and before the
   // arguments are removed.
   // In optimized code this descriptor is needed for exception handling.
   compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                  deopt_id_after,
                                  token_pos());
   __ Drop(argument_count);
 }
 
 
 LocationSummary* LoadLocalInstr::MakeLocationSummary(Zone* zone,
                                                      bool opt) const {
   return LocationSummary::Make(zone,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result = locs()->out(0).reg();
-  __ LoadFromOffset(result, FP, local().index() * kWordSize, PP);
+  __ LoadFromOffset(result, FP, local().index() * kWordSize);
 }
 
 
 LocationSummary* StoreLocalInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   return LocationSummary::Make(zone,
                                1,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
-  __ StoreToOffset(value, FP, local().index() * kWordSize, PP);
+  __ StoreToOffset(value, FP, local().index() * kWordSize);
 }
 
 
 LocationSummary* ConstantInstr::MakeLocationSummary(Zone* zone,
                                                     bool opt) const {
   return LocationSummary::Make(zone,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out(0).IsInvalid()) {
     const 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 Location out = (representation_ == kUnboxedInt32) ?
       Location::RequiresRegister() : Location::RequiresFpuRegister();
   return LocationSummary::Make(zone,
                                kNumInputs,
                                out,
                                LocationSummary::kNoCall);
 }
 
 
 void UnboxedConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!locs()->out(0).IsInvalid()) {
     switch (representation_) {
       case kUnboxedDouble:
         if (Utils::DoublesBitEqual(Double::Cast(value()).value(), 0.0)) {
           const VRegister dst = locs()->out(0).fpu_reg();
           __ veor(dst, dst, dst);
         } else {
           const VRegister dst = locs()->out(0).fpu_reg();
-          __ LoadDImmediate(dst, Double::Cast(value()).value(), PP);
+          __ LoadDImmediate(dst, Double::Cast(value()).value());
         }
         break;
       case kUnboxedInt32:
         __ LoadImmediate(locs()->out(0).reg(),
-                         static_cast<int32_t>(Smi::Cast(value()).Value()),
-                         PP);
+                         static_cast<int32_t>(Smi::Cast(value()).Value()));
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 LocationSummary* AssertAssignableInstr::MakeLocationSummary(Zone* zone,
@@ skipping 26 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());
     __ b(&done, EQ);
-    __ CompareObject(reg, Bool::False(), PP);
+    __ CompareObject(reg, Bool::False());
     __ b(&done, EQ);
   } else {
     ASSERT(Isolate::Current()->flags().asserts());
-    __ CompareObject(reg, Object::null_instance(), PP);
+    __ CompareObject(reg, Object::null_instance());
     __ b(&done, NE);
   }
 
   __ Push(reg);  // Push the source object.
   compiler->GenerateRuntimeCall(token_pos,
                                 deopt_id,
                                 kNonBoolTypeErrorRuntimeEntry,
                                 1,
                                 locs);
   // We should never return here.
@@ skipping 67 matching lines @@
 static Condition EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                      LocationSummary* locs,
                                      Token::Kind kind) {
   Location left = locs->in(0);
   Location right = locs->in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   Condition true_condition = TokenKindToSmiCondition(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 {
     __ CompareRegisters(left.reg(), right.reg());
   }
   return true_condition;
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
@@ skipping 71 matching lines @@
     // Special case for NaN comparison. Result is always false unless
     // relational operator is !=.
     __ b(&is_false, VS);
   }
   EmitBranchOnCondition(compiler, true_condition, labels);
   // TODO(zra): instead of branching, use the csel instruction to get
   // True or False into result.
   const Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ b(&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 21 matching lines @@
 
 
 Condition TestSmiInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                            BranchLabels labels) {
   const Register left = 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, imm, PP);
+    __ TestImmediate(left, imm);
   } else {
     __ tst(left, Operand(right.reg()));
   }
   Condition true_condition = (kind() == Token::kNE) ? NE : EQ;
   return true_condition;
 }
 
 
 void TestSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Never emitted outside of the BranchInstr.
@@ skipping 30 matching lines @@
 
   Label* deopt = CanDeoptimize() ?
       compiler->AddDeoptStub(deopt_id(), ICData::kDeoptTestCids) : NULL;
 
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   ASSERT(data[0] == kSmiCid);
   bool result = data[1] == true_result;
   __ tsti(val_reg, Immediate(kSmiTagMask));
   __ b(result ? labels.true_label : labels.false_label, EQ);
-  __ LoadClassId(cid_reg, val_reg, PP);
+  __ LoadClassId(cid_reg, val_reg);
 
   for (intptr_t i = 2; i < data.length(); i += 2) {
     const intptr_t test_cid = data[i];
     ASSERT(test_cid != kSmiCid);
     result = data[i + 1] == true_result;
-    __ CompareImmediate(cid_reg, test_cid, PP);
+    __ CompareImmediate(cid_reg, test_cid);
     __ b(result ? labels.true_label : labels.false_label, EQ);
   }
   // No match found, deoptimize or false.
   if (deopt == NULL) {
     Label* target = result ? labels.false_label : labels.true_label;
     if (target != labels.fall_through) {
       __ b(target);
     }
   } else {
     __ b(deopt);
@@ skipping 12 matching lines @@
 
 
 void TestCidsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result_reg = locs()->out(0).reg();
   Label is_true, is_false, done;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   EmitComparisonCode(compiler, labels);
   // TODO(zra): instead of branching, use the csel instruction to get
   // True or False into result.
   __ Bind(&is_false);
-  __ LoadObject(result_reg, Bool::False(), PP);
+  __ LoadObject(result_reg, Bool::False());
   __ b(&done);
   __ 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 36 matching lines @@
     // Special case for NaN comparison. Result is always false unless
     // relational operator is !=.
     __ b(&is_false, VS);
   }
   EmitBranchOnCondition(compiler, true_condition, labels);
   // TODO(zra): instead of branching, use the csel instruction to get
   // True or False into result.
   const Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ b(&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);
   if ((operation_cid() == kDoubleCid) && (true_condition != NE)) {
     // Special case for NaN comparison. Result is always false unless
     // relational operator is !=.
     __ b(labels.false_label, VS);
   }
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
 void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result = locs()->out(0).reg();
 
   // 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 R2.
   if (!function().HasOptionalParameters()) {
     __ AddImmediate(R2, FP, (kParamEndSlotFromFp +
-                             function().NumParameters()) * kWordSize, PP);
+                             function().NumParameters()) * kWordSize);
   } else {
-    __ AddImmediate(R2, FP, kFirstLocalSlotFromFp * kWordSize, PP);
+    __ AddImmediate(R2, FP, kFirstLocalSlotFromFp * kWordSize);
   }
   // Compute the effective address. When running under the simulator,
   // this is a redirection address that forces the simulator to call
   // into the runtime system.
   uword entry = reinterpret_cast<uword>(native_c_function());
   const intptr_t argc_tag = NativeArguments::ComputeArgcTag(function());
   const bool is_leaf_call =
     (argc_tag & NativeArguments::AutoSetupScopeMask()) == 0;
   const ExternalLabel* stub_entry;
   if (is_bootstrap_native() || is_leaf_call) {
     stub_entry = &StubCode::CallBootstrapCFunctionLabel();
 #if defined(USING_SIMULATOR)
     entry = Simulator::RedirectExternalReference(
         entry, Simulator::kBootstrapNativeCall, function().NumParameters());
 #endif
   } else {
     // In the case of non bootstrap native methods the CallNativeCFunction
     // stub generates the redirection address when running under the simulator
     // and hence we do not change 'entry' here.
     stub_entry = &StubCode::CallNativeCFunctionLabel();
 #if defined(USING_SIMULATOR)
     if (!function().IsNativeAutoSetupScope()) {
       entry = Simulator::RedirectExternalReference(
           entry, Simulator::kBootstrapNativeCall, function().NumParameters());
     }
 #endif
   }
-  __ LoadImmediate(R5, entry, PP);
-  __ LoadImmediate(R1, argc_tag, PP);
+  __ LoadImmediate(R5, entry);
+  __ LoadImmediate(R1, argc_tag);
   compiler->GenerateCall(token_pos(),
                          stub_entry,
                          RawPcDescriptors::kOther,
                          locs());
   __ Pop(result);
 }
 
 
 LocationSummary* StringFromCharCodeInstr::MakeLocationSummary(Zone* zone,
                                                               bool opt) const {
   const intptr_t kNumInputs = 1;
   // TODO(fschneider): Allow immediate operands for the char code.
   return LocationSummary::Make(zone,
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(compiler->is_optimizing());
   const Register char_code = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ LoadImmediate(
-      result, reinterpret_cast<uword>(Symbols::PredefinedAddress()), PP);
+      result, reinterpret_cast<uword>(Symbols::PredefinedAddress()));
   __ AddImmediate(
-      result, result, Symbols::kNullCharCodeSymbolOffset * kWordSize, PP);
+      result, result, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ SmiUntag(TMP, char_code);  // Untag to use scaled adress mode.
   __ ldr(result, Address(result, TMP, UXTX, Address::Scaled));
 }
 
 
 LocationSummary* StringToCharCodeInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(zone,
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringToCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(cid_ == kOneByteStringCid);
   const Register str = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
-  __ LoadFieldFromOffset(result, str, String::length_offset(), PP);
+  __ LoadFieldFromOffset(result, str, String::length_offset());
   __ ldr(TMP, FieldAddress(str, OneByteString::data_offset()), kUnsignedByte);
-  __ CompareImmediate(result, Smi::RawValue(1), PP);
-  __ LoadImmediate(result, -1, PP);
+  __ CompareImmediate(result, Smi::RawValue(1));
+  __ LoadImmediate(result, -1);
   __ csel(result, TMP, result, EQ);
   __ SmiTag(result);
 }
 
 
 LocationSummary* StringInterpolateInstr::MakeLocationSummary(Zone* zone,
                                                              bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
@@ skipping 27 matching lines @@
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register obj = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   if (object()->definition()->representation() == kUntagged) {
-    __ LoadFromOffset(result, obj, offset(), PP);
+    __ LoadFromOffset(result, obj, offset());
   } else {
     ASSERT(object()->definition()->representation() == kTagged);
-    __ LoadFieldFromOffset(result, obj, offset(), PP);
+    __ LoadFieldFromOffset(result, obj, offset());
   }
 }
 
 
 LocationSummary* LoadClassIdInstr::MakeLocationSummary(Zone* zone,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(zone,
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register object = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   static const intptr_t kSmiCidSource =
       static_cast<intptr_t>(kSmiCid) << RawObject::kClassIdTagPos;
 
-  __ LoadImmediate(TMP, reinterpret_cast<int64_t>(&kSmiCidSource) + 1, PP);
+  __ LoadImmediate(TMP, reinterpret_cast<int64_t>(&kSmiCidSource) + 1);
   __ tsti(object, Immediate(kSmiTagMask));
   __ csel(TMP, TMP, object, EQ);
-  __ LoadClassId(result, TMP, PP);
+  __ LoadClassId(result, TMP);
   __ SmiTag(result);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
     case kArrayCid:
     case kImmutableArrayCid:
       return CompileType::Dynamic();
 
@@ skipping 353 matching lines @@
         const 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()) {
         const Smi& constant = Smi::Cast(locs()->in(2).constant());
-        __ LoadImmediate(TMP, static_cast<int8_t>(constant.Value()), PP);
+        __ LoadImmediate(TMP, static_cast<int8_t>(constant.Value()));
         __ str(TMP, element_address, kUnsignedByte);
       } else {
         const Register value = locs()->in(2).reg();
         __ SmiUntag(TMP, value);
         __ str(TMP, element_address, kUnsignedByte);
       }
       break;
     }
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid: {
       if (locs()->in(2).IsConstant()) {
         const Smi& constant = Smi::Cast(locs()->in(2).constant());
         intptr_t value = constant.Value();
         // Clamp to 0x0 or 0xFF respectively.
         if (value > 0xFF) {
           value = 0xFF;
         } else if (value < 0) {
           value = 0;
         }
-        __ LoadImmediate(TMP, static_cast<int8_t>(value), PP);
+        __ LoadImmediate(TMP, static_cast<int8_t>(value));
         __ str(TMP, element_address, kUnsignedByte);
       } else {
         const Register value = locs()->in(2).reg();
-        __ CompareImmediate(value, 0x1FE, PP);  // Smi value and smi 0xFF.
+        __ CompareImmediate(value, 0x1FE);  // Smi value and smi 0xFF.
         // Clamp to 0x00 or 0xFF respectively.
         __ csetm(TMP, GT);  // TMP = value > 0x1FE ? -1 : 0.
         __ csel(TMP, value, TMP, LS);  // TMP = value in range ? value : TMP.
         __ SmiUntag(TMP);
         __ str(TMP, element_address, kUnsignedByte);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
@@ skipping 30 matching lines @@
   }
 }
 
 
 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, kSmiCid, PP);
+    __ LoadImmediate(value_cid_reg, kSmiCid);
   }
   __ tsti(value_reg, Immediate(kSmiTagMask));
   if (value_is_smi == NULL) {
     __ b(&done, EQ);
   } else {
     __ b(value_is_smi, EQ);
   }
-  __ LoadClassId(value_cid_reg, value_reg, PP);
+  __ LoadClassId(value_cid_reg, value_reg);
   __ Bind(&done);
 }
 
 
 LocationSummary* GuardFieldClassInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 1;
 
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t field_cid = field().guarded_cid();
@@ skipping 54 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(), kUnsignedWord);
     FieldAddress field_nullability_operand(
         field_reg, Field::is_nullable_offset(), kUnsignedWord);
 
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
       Label skip_length_check;
       __ ldr(TMP, field_cid_operand, kUnsignedWord);
       __ CompareRegisters(value_cid_reg, TMP);
       __ b(&ok, EQ);
       __ ldr(TMP, field_nullability_operand, kUnsignedWord);
       __ CompareRegisters(value_cid_reg, TMP);
     } else if (value_cid == kNullCid) {
       __ ldr(value_cid_reg, field_nullability_operand, kUnsignedWord);
-      __ CompareImmediate(value_cid_reg, value_cid, PP);
+      __ CompareImmediate(value_cid_reg, value_cid);
     } else {
       Label skip_length_check;
       __ ldr(value_cid_reg, field_cid_operand, kUnsignedWord);
-      __ CompareImmediate(value_cid_reg, value_cid, PP);
+      __ CompareImmediate(value_cid_reg, value_cid);
     }
     __ b(&ok, EQ);
 
     // Check if the tracked state of the guarded field can be initialized
     // inline. If the field needs length check we fall through to runtime
     // which is responsible for computing offset of the length field
     // based on the class id.
     // Length guard will be emitted separately when needed via GuardFieldLength
     // instruction after GuardFieldClass.
     if (!field().needs_length_check()) {
       // Uninitialized field can be handled inline. Check if the
       // field is still unitialized.
       __ ldr(TMP, field_cid_operand, kUnsignedWord);
-      __ CompareImmediate(TMP, kIllegalCid, PP);
+      __ CompareImmediate(TMP, kIllegalCid);
       __ b(fail, NE);
 
       if (value_cid == kDynamicCid) {
         __ str(value_cid_reg, field_cid_operand, kUnsignedWord);
         __ str(value_cid_reg, field_nullability_operand, kUnsignedWord);
       } else {
-        __ LoadImmediate(TMP, value_cid, PP);
+        __ LoadImmediate(TMP, value_cid);
         __ str(TMP, field_cid_operand, kUnsignedWord);
         __ str(TMP, field_nullability_operand, kUnsignedWord);
       }
 
       if (deopt == NULL) {
         ASSERT(!compiler->is_optimizing());
         __ b(&ok);
       }
     }
 
     if (deopt == NULL) {
       ASSERT(!compiler->is_optimizing());
       __ Bind(fail);
 
       __ LoadFieldFromOffset(
-          TMP, field_reg, Field::guarded_cid_offset(), PP, kUnsignedWord);
-      __ CompareImmediate(TMP, kDynamicCid, PP);
+          TMP, field_reg, Field::guarded_cid_offset(), kUnsignedWord);
+      __ CompareImmediate(TMP, kDynamicCid);
       __ b(&ok, EQ);
 
       __ Push(field_reg);
       __ Push(value_reg);
       __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
       __ Drop(2);  // Drop the field and the value.
     }
   } else {
     ASSERT(compiler->is_optimizing());
     ASSERT(deopt != NULL);
 
     // Field guard class has been initialized and is known.
     if (value_cid == kDynamicCid) {
       // Value's class id is not known.
       __ tsti(value_reg, Immediate(kSmiTagMask));
 
       if (field_cid != kSmiCid) {
         __ b(fail, EQ);
-        __ LoadClassId(value_cid_reg, value_reg, PP);
-        __ CompareImmediate(value_cid_reg, field_cid, PP);
+        __ LoadClassId(value_cid_reg, value_reg);
+        __ CompareImmediate(value_cid_reg, field_cid);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ b(&ok, EQ);
-        __ CompareObject(value_reg, Object::null_object(), PP);
+        __ CompareObject(value_reg, Object::null_object());
       }
 
       __ b(fail, NE);
     } else {
       // Both value's and field's class id is known.
       ASSERT((value_cid != field_cid) && (value_cid != nullability));
       __ b(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()));
 
     __ ldr(offset_reg,
            FieldAddress(field_reg,
                         Field::guarded_list_length_in_object_offset_offset()),
            kByte);
     __ ldr(length_reg, FieldAddress(field_reg,
         Field::guarded_list_length_offset()));
 
     __ tst(offset_reg, Operand(offset_reg));
     __ b(&ok, MI);
@@ skipping 18 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);
 
     __ ldr(TMP, FieldAddress(value_reg,
                             field().guarded_list_length_in_object_offset()));
-    __ CompareImmediate(TMP, Smi::RawValue(field().guarded_list_length()), PP);
+    __ CompareImmediate(TMP, Smi::RawValue(field().guarded_list_length()));
     __ b(deopt, NE);
   }
 }
 
 
 class BoxAllocationSlowPath : public SlowPathCode {
  public:
   BoxAllocationSlowPath(Instruction* instruction,
                         const Class& cls,
                         Register result)
@@ skipping 27 matching lines @@
     compiler->RestoreLiveRegisters(locs);
     __ b(exit_label());
   }
 
   static void Allocate(FlowGraphCompiler* compiler,
                        Instruction* instruction,
                        const Class& cls,
                        Register result,
                        Register temp) {
     if (compiler->intrinsic_mode()) {
-      __ TryAllocate(cls,
-                     compiler->intrinsic_slow_path_label(),
-                     result,
-                     temp,
-                     PP);
+      __ TryAllocate(cls, compiler->intrinsic_slow_path_label(), result, temp);
     } else {
       BoxAllocationSlowPath* slow_path =
           new BoxAllocationSlowPath(instruction, cls, result);
       compiler->AddSlowPathCode(slow_path);
 
-      __ TryAllocate(cls,
-                     slow_path->entry_label(),
-                     result,
-                     temp,
-                     PP);
+      __ TryAllocate(cls, slow_path->entry_label(), result, temp);
       __ Bind(slow_path->exit_label());
     }
   }
 
  private:
   Instruction* instruction_;
   const Class& cls_;
   const Register result_;
 };
 
 
 static void EnsureMutableBox(FlowGraphCompiler* compiler,
                              StoreInstanceFieldInstr* instruction,
                              Register box_reg,
                              const Class& cls,
                              Register instance_reg,
                              intptr_t offset,
                              Register temp) {
   Label done;
-  __ LoadFieldFromOffset(box_reg, instance_reg, offset, PP);
-  __ CompareObject(box_reg, Object::null_object(), PP);
+  __ LoadFieldFromOffset(box_reg, instance_reg, offset);
+  __ CompareObject(box_reg, Object::null_object());
   __ b(&done, NE);
   BoxAllocationSlowPath::Allocate(
       compiler, instruction, cls, box_reg, temp);
   __ mov(temp, box_reg);
-  __ StoreIntoObjectOffset(instance_reg, offset, temp, PP);
+  __ StoreIntoObjectOffset(instance_reg, offset, temp);
   __ Bind(&done);
 }
 
 
 LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary(Zone* zone,
                                                               bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps =
       (IsUnboxedStore() && opt) ? 2 :
           ((IsPotentialUnboxedStore()) ? 2 : 0);
@@ skipping 47 matching lines @@
           break;
         case kFloat64x2Cid:
           cls = &compiler->float64x2_class();
           break;
         default:
           UNREACHABLE();
       }
 
       BoxAllocationSlowPath::Allocate(compiler, this, *cls, temp, temp2);
       __ mov(temp2, temp);
-      __ StoreIntoObjectOffset(instance_reg, offset_in_bytes_, temp2, PP);
+      __ StoreIntoObjectOffset(instance_reg, offset_in_bytes_, temp2);
     } else {
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_, PP);
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_);
     }
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleStoreInstanceFieldInstr");
-        __ StoreDFieldToOffset(value, temp, Double::value_offset(), PP);
+        __ StoreDFieldToOffset(value, temp, Double::value_offset());
         break;
       case kFloat32x4Cid:
         __ Comment("UnboxedFloat32x4StoreInstanceFieldInstr");
-        __ StoreQFieldToOffset(value, temp, Float32x4::value_offset(), PP);
+        __ StoreQFieldToOffset(value, temp, Float32x4::value_offset());
         break;
       case kFloat64x2Cid:
         __ Comment("UnboxedFloat64x2StoreInstanceFieldInstr");
-        __ StoreQFieldToOffset(value, temp, Float64x2::value_offset(), PP);
+        __ StoreQFieldToOffset(value, temp, Float64x2::value_offset());
         break;
       default:
         UNREACHABLE();
     }
 
     return;
   }
 
   if (IsPotentialUnboxedStore()) {
     const Register value_reg = locs()->in(1).reg();
     const Register temp = locs()->temp(0).reg();
     const Register temp2 = locs()->temp(1).reg();
 
     if (ShouldEmitStoreBarrier()) {
       // 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()));
 
-    __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP,
+    __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(),
                            kUnsignedWord);
-    __ CompareImmediate(temp2, kNullCid, PP);
+    __ CompareImmediate(temp2, kNullCid);
     __ b(&store_pointer, EQ);
 
     __ LoadFromOffset(
         temp2, temp, Field::kind_bits_offset() - kHeapObjectTag,
-        PP, kUnsignedByte);
+        kUnsignedByte);
     __ tsti(temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ b(&store_pointer, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP,
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(),
                            kUnsignedWord);
-    __ CompareImmediate(temp2, kDoubleCid, PP);
+    __ CompareImmediate(temp2, kDoubleCid);
     __ b(&store_double, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP,
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(),
                            kUnsignedWord);
-    __ CompareImmediate(temp2, kFloat32x4Cid, PP);
+    __ CompareImmediate(temp2, kFloat32x4Cid);
     __ b(&store_float32x4, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP,
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(),
                            kUnsignedWord);
-    __ CompareImmediate(temp2, kFloat64x2Cid, PP);
+    __ CompareImmediate(temp2, kFloat64x2Cid);
     __ b(&store_float64x2, EQ);
 
     // Fall through.
     __ b(&store_pointer);
 
     if (!compiler->is_optimizing()) {
         locs()->live_registers()->Add(locs()->in(0));
         locs()->live_registers()->Add(locs()->in(1));
     }
 
     {
       __ Bind(&store_double);
       EnsureMutableBox(compiler,
                        this,
                        temp,
                        compiler->double_class(),
                        instance_reg,
                        offset_in_bytes_,
                        temp2);
-      __ LoadDFieldFromOffset(VTMP, value_reg, Double::value_offset(), PP);
-      __ StoreDFieldToOffset(VTMP, temp, Double::value_offset(), PP);
+      __ LoadDFieldFromOffset(VTMP, value_reg, Double::value_offset());
+      __ StoreDFieldToOffset(VTMP, temp, Double::value_offset());
       __ b(&skip_store);
     }
 
     {
       __ Bind(&store_float32x4);
       EnsureMutableBox(compiler,
                        this,
                        temp,
                        compiler->float32x4_class(),
                        instance_reg,
                        offset_in_bytes_,
                        temp2);
-      __ LoadQFieldFromOffset(VTMP, value_reg, Float32x4::value_offset(), PP);
-      __ StoreQFieldToOffset(VTMP, temp, Float32x4::value_offset(), PP);
+      __ LoadQFieldFromOffset(VTMP, value_reg, Float32x4::value_offset());
+      __ StoreQFieldToOffset(VTMP, temp, Float32x4::value_offset());
       __ b(&skip_store);
     }
 
     {
       __ Bind(&store_float64x2);
       EnsureMutableBox(compiler,
                        this,
                        temp,
                        compiler->float64x2_class(),
                        instance_reg,
                        offset_in_bytes_,
                        temp2);
-      __ LoadQFieldFromOffset(VTMP, value_reg, Float64x2::value_offset(), PP);
-      __ StoreQFieldToOffset(VTMP, temp, Float64x2::value_offset(), PP);
+      __ LoadQFieldFromOffset(VTMP, value_reg, Float64x2::value_offset());
+      __ StoreQFieldToOffset(VTMP, temp, Float64x2::value_offset());
       __ b(&skip_store);
     }
 
     __ Bind(&store_pointer);
   }
 
   if (ShouldEmitStoreBarrier()) {
     const Register value_reg = locs()->in(1).reg();
     __ StoreIntoObjectOffset(
-        instance_reg, offset_in_bytes_, value_reg, PP, CanValueBeSmi());
+        instance_reg, offset_in_bytes_, value_reg, CanValueBeSmi());
   } else {
     if (locs()->in(1).IsConstant()) {
       __ StoreIntoObjectOffsetNoBarrier(
-          instance_reg,
-          offset_in_bytes_,
-          locs()->in(1).constant(),
-          PP);
+          instance_reg, offset_in_bytes_, locs()->in(1).constant());
     } else {
       const Register value_reg = locs()->in(1).reg();
       __ StoreIntoObjectOffsetNoBarrier(
-          instance_reg,
-          offset_in_bytes_,
-          value_reg,
-          PP);
+          instance_reg, offset_in_bytes_, value_reg);
     }
   }
   __ Bind(&skip_store);
 }
 
 
 LocationSummary* LoadStaticFieldInstr::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::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 // When the parser is building an implicit static getter for optimization,
 // it can generate a function body where deoptimization ids do not line up
 // with the unoptimized code.
 //
 // This is safe only so long as LoadStaticFieldInstr cannot deoptimize.
 void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register field = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
-  __ LoadFieldFromOffset(result, field, Field::value_offset(), PP);
+  __ LoadFieldFromOffset(result, field, Field::value_offset());
 }
 
 
 LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   LocationSummary* locs = new(zone) LocationSummary(
       zone, 1, 1, LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
                                               : Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const Register temp = locs()->temp(0).reg();
 
-  __ LoadObject(temp, field(), PP);
+  __ LoadObject(temp, field());
   if (this->value()->NeedsStoreBuffer()) {
     __ StoreIntoObjectOffset(
-        temp, Field::value_offset(), value, PP, CanValueBeSmi());
+        temp, Field::value_offset(), value, CanValueBeSmi());
   } else {
-    __ StoreIntoObjectOffsetNoBarrier(temp, Field::value_offset(), value, PP);
+    __ StoreIntoObjectOffsetNoBarrier(temp, Field::value_offset(), value);
   }
 }
 
 
 LocationSummary* InstanceOfInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
@@ skipping 62 matching lines @@
 
   // TODO(zra): Use stp once added.
   // Initialize all array elements to raw_null.
   // R0: new object start as a tagged pointer.
   // R3: new object end address.
   // R8: iterator which initially points to the start of the variable
   // data area to be initialized.
   // R6: null
   if (num_elements > 0) {
     const intptr_t array_size = instance_size - sizeof(RawArray);
-    __ LoadObject(R6, Object::null_object(), PP);
-    __ AddImmediate(R8, R0, sizeof(RawArray) - kHeapObjectTag, PP);
+    __ LoadObject(R6, Object::null_object());
+    __ AddImmediate(R8, R0, sizeof(RawArray) - kHeapObjectTag);
     if (array_size < (kInlineArraySize * kWordSize)) {
       intptr_t current_offset = 0;
       while (current_offset < array_size) {
         __ str(R6, Address(R8, current_offset));
         current_offset += kWordSize;
       }
     } else {
       Label end_loop, init_loop;
       __ Bind(&init_loop);
       __ CompareRegisters(R8, R3);
       __ b(&end_loop, CS);
       __ str(R6, Address(R8));
-      __ AddImmediate(R8, R8, kWordSize, kNoPP);
+      __ AddImmediate(R8, R8, kWordSize);
       __ b(&init_loop);
       __ Bind(&end_loop);
     }
   }
   __ b(done);
 }
 
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register kLengthReg = R2;
   const Register kElemTypeReg = R1;
   const Register kResultReg = R0;
 
   ASSERT(locs()->in(kElementTypePos).reg() == kElemTypeReg);
   ASSERT(locs()->in(kLengthPos).reg() == kLengthReg);
 
   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.
       __ Push(kLengthReg);  // length.
       __ Push(kElemTypeReg);
       compiler->GenerateRuntimeCall(token_pos(),
                                     deopt_id(),
                                     kAllocateArrayRuntimeEntry,
                                     2,
                                     locs());
       __ Drop(2);
       __ Pop(kResultReg);
       __ Bind(&done);
@@ skipping 32 matching lines @@
   return locs;
 }
 
 
 void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(sizeof(classid_t) == kInt32Size);
   const Register instance_reg = locs()->in(0).reg();
   if (IsUnboxedLoad() && compiler->is_optimizing()) {
     const VRegister result = locs()->out(0).fpu_reg();
     const Register temp = locs()->temp(0).reg();
-    __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes(), PP);
+    __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
     const intptr_t cid = field()->UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleLoadFieldInstr");
-        __ LoadDFieldFromOffset(result, temp, Double::value_offset(), PP);
+        __ LoadDFieldFromOffset(result, temp, Double::value_offset());
         break;
       case kFloat32x4Cid:
-        __ LoadQFieldFromOffset(result, temp, Float32x4::value_offset(), PP);
+        __ LoadQFieldFromOffset(result, temp, Float32x4::value_offset());
         break;
       case kFloat64x2Cid:
-        __ LoadQFieldFromOffset(result, temp, Float64x2::value_offset(), PP);
+        __ LoadQFieldFromOffset(result, temp, Float64x2::value_offset());
         break;
       default:
         UNREACHABLE();
     }
     return;
   }
 
   Label done;
   const Register result_reg = locs()->out(0).reg();
   if (IsPotentialUnboxedLoad()) {
     const Register temp = locs()->temp(0).reg();
 
     Label load_pointer;
     Label load_double;
     Label load_float32x4;
     Label load_float64x2;
 
-    __ LoadObject(result_reg, Field::ZoneHandle(field()->raw()), PP);
+    __ LoadObject(result_reg, Field::ZoneHandle(field()->raw()));
 
     FieldAddress field_cid_operand(
         result_reg, Field::guarded_cid_offset(), kUnsignedWord);
     FieldAddress field_nullability_operand(
         result_reg, Field::is_nullable_offset(), kUnsignedWord);
 
     __ ldr(temp, field_nullability_operand, kUnsignedWord);
-    __ CompareImmediate(temp, kNullCid, PP);
+    __ CompareImmediate(temp, kNullCid);
     __ b(&load_pointer, EQ);
 
     __ ldr(temp, field_cid_operand, kUnsignedWord);
-    __ CompareImmediate(temp, kDoubleCid, PP);
+    __ CompareImmediate(temp, kDoubleCid);
     __ b(&load_double, EQ);
 
     __ ldr(temp, field_cid_operand, kUnsignedWord);
-    __ CompareImmediate(temp, kFloat32x4Cid, PP);
+    __ CompareImmediate(temp, kFloat32x4Cid);
     __ b(&load_float32x4, EQ);
 
     __ ldr(temp, field_cid_operand, kUnsignedWord);
-    __ CompareImmediate(temp, kFloat64x2Cid, PP);
+    __ CompareImmediate(temp, kFloat64x2Cid);
     __ b(&load_float64x2, EQ);
 
     // Fall through.
     __ b(&load_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
     }
 
     {
       __ Bind(&load_double);
       BoxAllocationSlowPath::Allocate(compiler,
                                       this,
                                       compiler->double_class(),
                                       result_reg,
                                       temp);
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes(), PP);
-      __ LoadDFieldFromOffset(VTMP, temp, Double::value_offset(), PP);
-      __ StoreDFieldToOffset(VTMP, result_reg, Double::value_offset(), PP);
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
+      __ LoadDFieldFromOffset(VTMP, temp, Double::value_offset());
+      __ StoreDFieldToOffset(VTMP, result_reg, Double::value_offset());
       __ b(&done);
     }
 
     {
       __ Bind(&load_float32x4);
       BoxAllocationSlowPath::Allocate(compiler,
                                       this,
                                       compiler->float32x4_class(),
                                       result_reg,
                                       temp);
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes(), PP);
-      __ LoadQFieldFromOffset(VTMP, temp, Float32x4::value_offset(), PP);
-      __ StoreQFieldToOffset(VTMP, result_reg, Float32x4::value_offset(), PP);
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
+      __ LoadQFieldFromOffset(VTMP, temp, Float32x4::value_offset());
+      __ StoreQFieldToOffset(VTMP, result_reg, Float32x4::value_offset());
       __ b(&done);
     }
 
     {
       __ Bind(&load_float64x2);
       BoxAllocationSlowPath::Allocate(compiler,
                                       this,
                                       compiler->float64x2_class(),
                                       result_reg,
                                       temp);
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes(), PP);
-      __ LoadQFieldFromOffset(VTMP, temp, Float64x2::value_offset(), PP);
-      __ StoreQFieldToOffset(VTMP, result_reg, Float64x2::value_offset(), PP);
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
+      __ LoadQFieldFromOffset(VTMP, temp, Float64x2::value_offset());
+      __ StoreQFieldToOffset(VTMP, result_reg, Float64x2::value_offset());
       __ b(&done);
     }
 
     __ Bind(&load_pointer);
   }
-  __ LoadFieldFromOffset(result_reg, instance_reg, offset_in_bytes(), PP);
+  __ LoadFieldFromOffset(result_reg, instance_reg, offset_in_bytes());
   __ Bind(&done);
 }
 
 
 LocationSummary* InstantiateTypeInstr::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(R0));
   locs->set_out(0, Location::RegisterLocation(R0));
   return locs;
 }
 
 
 void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register instantiator_reg = locs()->in(0).reg();
   const 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());
   __ Push(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type.
   __ Pop(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());
     __ b(&type_arguments_instantiated, EQ);
   }
 
-  __ LoadObject(R2, type_arguments(), PP);
-  __ LoadFieldFromOffset(R2, R2, TypeArguments::instantiations_offset(), PP);
-  __ AddImmediate(R2, R2, Array::data_offset() - kHeapObjectTag, PP);
+  __ LoadObject(R2, type_arguments());
+  __ LoadFieldFromOffset(R2, R2, TypeArguments::instantiations_offset());
+  __ AddImmediate(R2, R2, Array::data_offset() - kHeapObjectTag);
   // 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);
-  __ LoadFromOffset(R1, R2, 0 * kWordSize, PP);  // Cached instantiator.
+  __ LoadFromOffset(R1, R2, 0 * kWordSize);  // Cached instantiator.
   __ CompareRegisters(R1, R0);
   __ b(&found, EQ);
-  __ AddImmediate(R2, R2, 2 * kWordSize, PP);
-  __ CompareImmediate(R1, Smi::RawValue(StubCode::kNoInstantiator), PP);
+  __ AddImmediate(R2, R2, 2 * kWordSize);
+  __ CompareImmediate(R1, Smi::RawValue(StubCode::kNoInstantiator));
   __ b(&loop, NE);
   __ b(&slow_case);
   __ Bind(&found);
-  __ LoadFromOffset(R0, R2, 1 * kWordSize, PP);  // Cached instantiated args.
+  __ LoadFromOffset(R0, R2, 1 * kWordSize);  // Cached instantiated args.
   __ b(&type_arguments_instantiated);
 
   __ 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());
   __ Push(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ Pop(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
 }
@@ skipping 23 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(R1, instruction_->num_context_variables(), PP);
+    __ LoadImmediate(R1, instruction_->num_context_variables());
     const ExternalLabel label(StubCode::AllocateContextEntryPoint());
     compiler->GenerateCall(instruction_->token_pos(),
                            &label,
                            RawPcDescriptors::kOther,
                            locs);
     ASSERT(instruction_->locs()->out(0).reg() == R0);
     compiler->RestoreLiveRegisters(instruction_->locs());
     __ b(exit_label());
   }
 
@@ skipping 14 matching lines @@
   compiler->AddSlowPathCode(slow_path);
   intptr_t instance_size = Context::InstanceSize(num_context_variables());
 
   __ TryAllocateArray(kContextCid, instance_size, slow_path->entry_label(),
                       result,  // instance
                       temp0,
                       temp1,
                       temp2);
 
   // Setup up number of context variables field.
-  __ LoadImmediate(temp0, num_context_variables(), PP);
+  __ LoadImmediate(temp0, num_context_variables());
   __ str(temp0, FieldAddress(result, Context::num_variables_offset()));
 
   __ Bind(slow_path->exit_label());
 }
 
 
 LocationSummary* AllocateContextInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(R1));
   locs->set_out(0, Location::RegisterLocation(R0));
   return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R1);
   ASSERT(locs()->out(0).reg() == R0);
 
-  __ LoadImmediate(R1, num_context_variables(), PP);
+  __ LoadImmediate(R1, 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(R0));
   locs->set_temp(0, Location::RegisterLocation(R1));
   return locs;
 }
 
 
 void InitStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register field = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label call_runtime, no_call;
 
   __ ldr(temp, FieldAddress(field, Field::value_offset()));
-  __ CompareObject(temp, Object::sentinel(), PP);
+  __ CompareObject(temp, Object::sentinel());
   __ b(&call_runtime, EQ);
 
-  __ CompareObject(temp, Object::transition_sentinel(), PP);
+  __ CompareObject(temp, Object::transition_sentinel());
   __ b(&no_call, NE);
 
   __ Bind(&call_runtime);
-  __ PushObject(Object::null_object(), PP);  // Make room for (unused) result.
+  __ PushObject(Object::null_object());  // Make room for (unused) result.
   __ Push(field);
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInitStaticFieldRuntimeEntry,
                                 1,
                                 locs());
   __ Drop(2);  // Remove argument and result placeholder.
   __ 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(R0));
   locs->set_out(0, Location::RegisterLocation(R0));
   return locs;
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register context_value = locs()->in(0).reg();
   const 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.
   __ Push(context_value);
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kCloneContextRuntimeEntry,
                                 1,
                                 locs());
   __ Drop(1);  // Remove argument.
   __ Pop(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchBlockEntryInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 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);
+  __ LoadPoolPointer();
 
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 
   // Restore SP from FP 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);
-  __ AddImmediate(SP, FP, fp_sp_dist, PP);
+  __ AddImmediate(SP, FP, fp_sp_dist);
 
   // Restore stack and initialize the two exception variables:
   // exception and stack trace variables.
   __ StoreToOffset(kExceptionObjectReg,
-                   FP, exception_var().index() * kWordSize, PP);
+                   FP, exception_var().index() * kWordSize);
   __ StoreToOffset(kStackTraceObjectReg,
-                   FP, stacktrace_var().index() * kWordSize, PP);
+                   FP, stacktrace_var().index() * kWordSize);
 }
 
 
 LocationSummary* CheckStackOverflowInstr::MakeLocationSummary(Zone* zone,
                                                               bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
 class CheckStackOverflowSlowPath : public SlowPathCode {
  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();
       const Register value = instruction_->locs()->temp(0).reg();
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
-      __ LoadImmediate(TMP, flags_address, PP);
-      __ LoadImmediate(value, Isolate::kOsrRequest, PP);
+      __ LoadImmediate(TMP, flags_address);
+      __ LoadImmediate(value, Isolate::kOsrRequest);
       __ str(value, Address(TMP));
     }
     __ 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 23 matching lines @@
   CheckStackOverflowInstr* instruction_;
   Label osr_entry_label_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   if (compiler->is_optimizing()) {
-    __ LoadImmediate(TMP, Isolate::Current()->stack_limit_address(), PP);
+    __ LoadImmediate(TMP, Isolate::Current()->stack_limit_address());
     __ ldr(TMP, Address(TMP));
   } else {
     __ LoadIsolate(TMP);
     __ ldr(TMP, Address(TMP, Isolate::stack_limit_offset()));
   }
   __ CompareRegisters(SP, TMP);
   __ b(slow_path->entry_label(), LS);
   if (compiler->CanOSRFunction() && in_loop()) {
     const Register temp = locs()->temp(0).reg();
     // 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());
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
     __ LoadFieldFromOffset(
-        temp, temp, Function::usage_counter_offset(), PP, kWord);
-    __ CompareImmediate(temp, threshold, PP);
+        temp, temp, Function::usage_counter_offset(), kWord);
+    __ CompareImmediate(temp, threshold);
     __ b(slow_path->osr_entry_label(), GE);
   }
   if (compiler->ForceSlowPathForStackOverflow()) {
     __ b(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);
-    __ LoadImmediate(TMP, 0x20000000000000LL, PP);
+    __ LoadImmediate(TMP, 0x20000000000000LL);
     __ add(TMP2, result, Operand(TMP));
     __ cmp(TMP2, Operand(TMP, LSL, 1));
     __ b(overflow, HI);
   }
 }
 
 
 static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
                              BinarySmiOpInstr* shift_left) {
   const LocationSummary& locs = *shift_left->locs();
@@ skipping 36 matching lines @@
         __ CompareRegisters(right, ZR);
         __ b(deopt, MI);
         __ mov(result, ZR);
         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,
-            reinterpret_cast<int64_t>(Smi::New(max_right)), PP);
+            reinterpret_cast<int64_t>(Smi::New(max_right)));
         __ b(deopt, CS);
       }
       __ SmiUntag(TMP, right);
       __ lslv(result, left, TMP);
     }
     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));
   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());
         __ CompareRegisters(right, ZR);
         __ b(deopt, MI);
       }
 
       __ CompareImmediate(
-          right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)), PP);
+          right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)));
       __ csel(result, ZR, result, CS);
       __ SmiUntag(TMP, right);
       __ lslv(TMP, left, TMP);
       __ csel(result, TMP, result, CC);
     } else {
       __ SmiUntag(TMP, right);
       __ lslv(result, left, TMP);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
       __ CompareImmediate(
-          right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)), PP);
+          right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)));
       __ b(deopt, CS);
     }
     // Left is not a constant.
     // Check if count too large for handling it inlined.
     __ SmiUntag(TMP, right);
     // Overflow test (preserve left, right, and TMP);
     const Register temp = locs.temp(0).reg();
     __ lslv(temp, left, TMP);
     __ asrv(TMP2, temp, TMP);
     __ CompareRegisters(left, TMP2);
@@ skipping 58 matching lines @@
     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: {
         if (deopt == NULL) {
-          __ AddImmediate(result, left, imm, PP);
+          __ AddImmediate(result, left, imm);
         } else {
-          __ AddImmediateSetFlags(result, left, imm, PP);
+          __ AddImmediateSetFlags(result, left, imm);
           __ b(deopt, VS);
         }
         break;
       }
       case Token::kSUB: {
         if (deopt == NULL) {
-          __ AddImmediate(result, left, -imm, PP);
+          __ AddImmediate(result, left, -imm);
         } else {
           // Negating imm and using AddImmediateSetFlags would not detect the
           // overflow when imm == kMinInt64.
-          __ SubImmediateSetFlags(result, left, imm, PP);
+          __ SubImmediateSetFlags(result, left, imm);
           __ b(deopt, VS);
         }
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
         const intptr_t value = Smi::Cast(constant).Value();
-        __ LoadImmediate(TMP, value, PP);
+        __ LoadImmediate(TMP, value);
         __ mul(result, left, TMP);
         if (deopt != NULL) {
           __ smulh(TMP, left, TMP);
           // TMP: result bits 64..127.
           __ cmp(TMP, Operand(result, ASR, 63));
           __ b(deopt, NE);
         }
         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);
         __ AsrImmediate(TMP, left, 63);
         ASSERT(shift_count > 1);  // 1, -1 case handled above.
         const Register temp = TMP2;
         __ add(temp, left, Operand(TMP, LSR, 64 - shift_count));
         ASSERT(shift_count > 0);
         __ AsrImmediate(result, temp, shift_count);
         if (value < 0) {
           __ sub(result, ZR, Operand(result));
         }
         __ SmiTag(result);
         break;
       }
       case Token::kBIT_AND:
         // No overflow check.
-        __ AndImmediate(result, left, imm, PP);
+        __ AndImmediate(result, left, imm);
         break;
       case Token::kBIT_OR:
         // No overflow check.
-        __ OrImmediate(result, left, imm, PP);
+        __ OrImmediate(result, left, imm);
         break;
       case Token::kBIT_XOR:
         // No overflow check.
-        __ XorImmediate(result, left, imm, PP);
+        __ XorImmediate(result, left, imm);
         break;
       case Token::kSHR: {
         // Asr operation masks the count to 6 bits.
         const intptr_t kCountLimit = 0x3F;
         intptr_t value = Smi::Cast(constant).Value();
         __ AsrImmediate(
             result, left, Utils::Minimum(value + kSmiTagSize, kCountLimit));
         __ SmiTag(result);
         break;
       }
@@ skipping 63 matching lines @@
         __ b(deopt, EQ);
       }
       const Register temp = TMP2;
       __ SmiUntag(temp, left);
       __ SmiUntag(TMP, right);
 
       __ sdiv(result, temp, TMP);
 
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
-      __ CompareImmediate(result, 0x4000000000000000LL, kNoPP);
+      __ CompareImmediate(result, 0x4000000000000000LL);
       __ b(deopt, EQ);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ CompareRegisters(right, ZR);
         __ b(deopt, EQ);
       }
@@ skipping 28 matching lines @@
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareRegisters(right, ZR);
         __ b(deopt, LT);
       }
       __ SmiUntag(TMP, right);
       // sarl operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
       if ((right_range == NULL) ||
           !right_range->OnlyLessThanOrEqualTo(kCountLimit)) {
-        __ LoadImmediate(TMP2, kCountLimit, PP);
+        __ LoadImmediate(TMP2, kCountLimit);
         __ CompareRegisters(TMP, TMP2);
         __ csel(TMP, TMP2, TMP, GT);
       }
       const Register temp = locs()->temp(0).reg();
       __ SmiUntag(temp, left);
       __ asrv(result, temp, TMP);
       __ SmiTag(result);
       break;
     }
     case Token::kDIV: {
@@ skipping 74 matching lines @@
 
   BoxAllocationSlowPath::Allocate(
       compiler,
       this,
       compiler->BoxClassFor(from_representation()),
       out_reg,
       temp_reg);
 
   switch (from_representation()) {
     case kUnboxedDouble:
-      __ StoreDFieldToOffset(value, out_reg, ValueOffset(), PP);
+      __ StoreDFieldToOffset(value, out_reg, ValueOffset());
       break;
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4:
-      __ StoreQFieldToOffset(value, out_reg, ValueOffset(), PP);
+      __ StoreQFieldToOffset(value, out_reg, ValueOffset());
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 LocationSummary* UnboxInstr::MakeLocationSummary(Zone* zone,
                                                  bool opt) const {
@@ skipping 11 matching lines @@
   const Register box = locs()->in(0).reg();
 
   switch (representation()) {
     case kUnboxedMint: {
       UNIMPLEMENTED();
       break;
     }
 
     case kUnboxedDouble: {
       const VRegister result = locs()->out(0).fpu_reg();
-      __ LoadDFieldFromOffset(result, box, ValueOffset(), PP);
+      __ LoadDFieldFromOffset(result, box, ValueOffset());
       break;
     }
 
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4: {
       const VRegister result = locs()->out(0).fpu_reg();
-      __ LoadQFieldFromOffset(result, box, ValueOffset(), PP);
+      __ LoadQFieldFromOffset(result, box, ValueOffset());
       break;
     }
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
@@ skipping 29 matching lines @@
   } else if (CanConvertSmi() && (value_cid == kSmiCid)) {
     EmitSmiConversion(compiler);
   } else {
     const Register box = locs()->in(0).reg();
     Label* deopt = compiler->AddDeoptStub(GetDeoptId(),
                                           ICData::kDeoptCheckClass);
     Label is_smi;
 
     if ((value()->Type()->ToNullableCid() == box_cid) &&
         value()->Type()->is_nullable()) {
-      __ CompareObject(box, Object::null_object(), PP);
+      __ CompareObject(box, Object::null_object());
       __ b(deopt, EQ);
     } else {
       __ tsti(box, Immediate(kSmiTagMask));
       __ b(CanConvertSmi() ? &is_smi : deopt, EQ);
-      __ CompareClassId(box, box_cid, PP);
+      __ CompareClassId(box, box_cid);
       __ b(deopt, NE);
     }
 
     EmitLoadFromBox(compiler);
 
     if (is_smi.IsLinked()) {
       Label done;
       __ b(&done);
       __ Bind(&is_smi);
       EmitSmiConversion(compiler);
@@ skipping 55 matching lines @@
 void UnboxInteger32Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register out = locs()->out(0).reg();
   const Register value = locs()->in(0).reg();
   Label* deopt = CanDeoptimize() ?
       compiler->AddDeoptStub(GetDeoptId(), ICData::kDeoptUnboxInteger) : NULL;
 
   if (value_cid == kSmiCid) {
     __ SmiUntag(out, value);
   } else if (value_cid == kMintCid) {
-    __ LoadFieldFromOffset(out, value, Mint::value_offset(), PP);
+    __ LoadFieldFromOffset(out, value, Mint::value_offset());
   } else if (!CanDeoptimize()) {
     // Type information is not conclusive, but range analysis found
     // the value to be in int64 range. Therefore it must be a smi
     // or mint value.
     ASSERT(is_truncating());
     Label done;
     __ SmiUntag(out, value);
-    __ TestImmediate(value, kSmiTagMask, PP);
+    __ TestImmediate(value, kSmiTagMask);
     __ b(&done, EQ);
-    __ LoadFieldFromOffset(out, value, Mint::value_offset(), PP);
+    __ LoadFieldFromOffset(out, value, Mint::value_offset());
     __ Bind(&done);
   } else {
     Label done;
     __ SmiUntag(out, value);
-    __ TestImmediate(value, kSmiTagMask, PP);
+    __ TestImmediate(value, kSmiTagMask);
     __ b(&done, EQ);
-    __ CompareClassId(value, kMintCid, PP);
+    __ CompareClassId(value, kMintCid);
     __ b(deopt, NE);
-    __ LoadFieldFromOffset(out, value, Mint::value_offset(), PP);
+    __ LoadFieldFromOffset(out, value, Mint::value_offset());
     __ Bind(&done);
   }
 
   // TODO(vegorov): as it is implemented right now truncating unboxing would
   // leave "garbage" in the higher word.
   if (!is_truncating() && (deopt != NULL)) {
     ASSERT(representation() == kUnboxedInt32);
     __ cmp(out, Operand(out, SXTW, 0));
     __ b(deopt, NE);
   }
@@ skipping 815 matching lines @@
 
 void Int32x4BoolConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register v0 = locs()->in(0).reg();
   const Register v1 = locs()->in(1).reg();
   const Register v2 = locs()->in(2).reg();
   const Register v3 = locs()->in(3).reg();
   const Register temp = locs()->temp(0).reg();
   const VRegister result = locs()->out(0).fpu_reg();
 
   __ veor(result, result, result);
-  __ LoadImmediate(temp, 0xffffffff, PP);
-  __ LoadObject(TMP2, Bool::True(), PP);
+  __ LoadImmediate(temp, 0xffffffff);
+  __ LoadObject(TMP2, Bool::True());
 
-  // __ CompareObject(v0, Bool::True(), PP);
+  // __ CompareObject(v0, Bool::True());
   __ CompareRegisters(v0, TMP2);
   __ csel(TMP, temp, ZR, EQ);
   __ vinsw(result, 0, TMP);
 
-  // __ CompareObject(v1, Bool::True(), PP);
+  // __ CompareObject(v1, Bool::True());
   __ CompareRegisters(v1, TMP2);
   __ csel(TMP, temp, ZR, EQ);
   __ vinsw(result, 1, TMP);
 
-  // __ CompareObject(v2, Bool::True(), PP);
+  // __ CompareObject(v2, Bool::True());
   __ CompareRegisters(v2, TMP2);
   __ csel(TMP, temp, ZR, EQ);
   __ vinsw(result, 2, TMP);
 
-  // __ CompareObject(v3, Bool::True(), PP);
+  // __ CompareObject(v3, Bool::True());
   __ CompareRegisters(v3, TMP2);
   __ csel(TMP, temp, ZR, EQ);
   __ vinsw(result, 3, TMP);
 }
 
 
 LocationSummary* Int32x4GetFlagInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 19 matching lines @@
     case MethodRecognizer::kInt32x4GetFlagZ:
       __ vmovrs(result, value, 2);
       break;
     case MethodRecognizer::kInt32x4GetFlagW:
       __ vmovrs(result, value, 3);
       break;
     default: UNREACHABLE();
   }
 
   __ tst(result, Operand(result));
-  __ LoadObject(result, Bool::True(), PP);
-  __ LoadObject(TMP, Bool::False(), PP);
+  __ LoadObject(result, Bool::True());
+  __ LoadObject(TMP, Bool::False());
   __ csel(result, TMP, result, EQ);
 }
 
 
 LocationSummary* Int32x4SelectInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 41 matching lines @@
 
 void Int32x4SetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const VRegister mask = locs()->in(0).fpu_reg();
   const Register flag = locs()->in(1).reg();
   const VRegister result = locs()->out(0).fpu_reg();
 
   if (result != mask) {
     __ vmov(result, mask);
   }
 
-  __ CompareObject(flag, Bool::True(), PP);
-  __ LoadImmediate(TMP, 0xffffffff, PP);
+  __ CompareObject(flag, Bool::True());
+  __ LoadImmediate(TMP, 0xffffffff);
   __ csel(TMP, TMP, ZR, EQ);
   switch (op_kind()) {
     case MethodRecognizer::kInt32x4WithFlagX:
       __ vinsw(result, 0, TMP);
       break;
     case MethodRecognizer::kInt32x4WithFlagY:
       __ vinsw(result, 1, TMP);
       break;
     case MethodRecognizer::kInt32x4WithFlagZ:
       __ vinsw(result, 2, TMP);
@@ skipping 158 matching lines @@
     __ b(&are_equal, EQ);
     const Condition double_condition =
         is_min ? TokenKindToDoubleCondition(Token::kLTE)
                : TokenKindToDoubleCondition(Token::kGTE);
     ASSERT(left == result);
     __ b(&done, double_condition);
     __ fmovdd(result, right);
     __ b(&done);
 
     __ Bind(&returns_nan);
-    __ LoadDImmediate(result, NAN, PP);
+    __ LoadDImmediate(result, NAN);
     __ b(&done);
 
     __ Bind(&are_equal);
     // 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
     // Check the sign bit.
     __ fmovrd(TMP, left);  // Sign bit is in bit 63 of TMP.
-    __ CompareImmediate(TMP, 0, PP);
+    __ CompareImmediate(TMP, 0);
     if (is_min) {
       ASSERT(left == result);
       __ b(&done, LT);
       __ fmovdd(result, right);
     } else {
       __ b(&done, GE);
       __ fmovdd(result, right);
       ASSERT(left == result);
     }
     __ Bind(&done);
@@ skipping 132 matching lines @@
   result->set_out(0, Location::RegisterLocation(R0));
   return result;
 }
 
 
 void DoubleToIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result = locs()->out(0).reg();
   const Register value_obj = locs()->in(0).reg();
   ASSERT(result == R0);
   ASSERT(result != value_obj);
-  __ LoadDFieldFromOffset(VTMP, value_obj, Double::value_offset(), PP);
+  __ LoadDFieldFromOffset(VTMP, value_obj, Double::value_offset());
 
   Label do_call, done;
   // First check for NaN. Checking for minint after the conversion doesn't work
   // on ARM64 because fcvtzds gives 0 for NaN.
   __ fcmpd(VTMP, VTMP);
   __ b(&do_call, VS);
 
   __ fcvtzds(result, VTMP);
   // Overflow is signaled with minint.
 
   // Check for overflow and that it fits into Smi.
-  __ CompareImmediate(result, 0xC000000000000000, PP);
+  __ CompareImmediate(result, 0xC000000000000000);
   __ b(&do_call, MI);
   __ SmiTag(result);
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptOverflowCheck(compiler, range(), &do_call, result);
   }
   __ b(&done);
   __ Bind(&do_call);
   __ Push(value_obj);
   ASSERT(instance_call()->HasICData());
   const ICData& ic_data = *instance_call()->ic_data();
@@ skipping 29 matching lines @@
   const Register result = locs()->out(0).reg();
   const VRegister value = locs()->in(0).fpu_reg();
   // First check for NaN. Checking for minint after the conversion doesn't work
   // on ARM64 because fcvtzds gives 0 for NaN.
   // TODO(zra): Check spec that this is true.
   __ fcmpd(value, value);
   __ b(deopt, VS);
 
   __ fcvtzds(result, value);
   // Check for overflow and that it fits into Smi.
-  __ CompareImmediate(result, 0xC000000000000000, PP);
+  __ CompareImmediate(result, 0xC000000000000000);
   __ b(deopt, MI);
   __ SmiTag(result);
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptOverflowCheck(compiler, range(), deopt, result);
   }
 }
 
 
 LocationSummary* DoubleToDoubleInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
@@ skipping 87 matching lines @@
   LocationSummary* locs = instr->locs();
 
   const VRegister base = locs->in(0).fpu_reg();
   const VRegister exp = locs->in(1).fpu_reg();
   const VRegister result = locs->out(0).fpu_reg();
   const VRegister saved_base = locs->temp(0).fpu_reg();
   ASSERT((base == result) && (result != saved_base));
 
   Label skip_call, try_sqrt, check_base, return_nan, do_pow;
   __ fmovdd(saved_base, base);
-  __ LoadDImmediate(result, 1.0, PP);
+  __ LoadDImmediate(result, 1.0);
   // exponent == 0.0 -> return 1.0;
   __ fcmpdz(exp);
   __ b(&check_base, VS);  // NaN -> check base.
   __ b(&skip_call, EQ);  // exp is 0.0, result is 1.0.
 
   // exponent == 1.0 ?
   __ fcmpd(exp, result);
   Label return_base;
   __ b(&return_base, EQ);
 
   // exponent == 2.0 ?
-  __ LoadDImmediate(VTMP, 2.0, PP);
+  __ LoadDImmediate(VTMP, 2.0);
   __ fcmpd(exp, VTMP);
   Label return_base_times_2;
   __ b(&return_base_times_2, EQ);
 
   // exponent == 3.0 ?
-  __ LoadDImmediate(VTMP, 3.0, PP);
+  __ LoadDImmediate(VTMP, 3.0);
   __ fcmpd(exp, VTMP);
   __ b(&check_base, NE);
 
   // base_times_3.
   __ fmuld(result, saved_base, saved_base);
   __ fmuld(result, result, saved_base);
   __ b(&skip_call);
 
   __ Bind(&return_base);
   __ fmovdd(result, saved_base);
   __ b(&skip_call);
 
   __ Bind(&return_base_times_2);
   __ fmuld(result, saved_base, saved_base);
   __ b(&skip_call);
 
   __ Bind(&check_base);
   // Note: 'exp' could be NaN.
   // base == 1.0 -> return 1.0;
   __ fcmpd(saved_base, result);
   __ b(&return_nan, VS);
   __ b(&skip_call, EQ);  // base is 1.0, result is 1.0.
 
   __ fcmpd(saved_base, exp);
   __ b(&try_sqrt, VC);  // // Neither 'exp' nor 'base' is NaN.
 
   __ Bind(&return_nan);
-  __ LoadDImmediate(result, NAN, PP);
+  __ LoadDImmediate(result, NAN);
   __ b(&skip_call);
 
   Label return_zero;
   __ Bind(&try_sqrt);
 
   // Before calling pow, check if we could use sqrt instead of pow.
-  __ LoadDImmediate(result, kNegInfinity, PP);
+  __ LoadDImmediate(result, kNegInfinity);
 
   // base == -Infinity -> call pow;
   __ fcmpd(saved_base, result);
   __ b(&do_pow, EQ);
 
   // exponent == 0.5 ?
-  __ LoadDImmediate(result, 0.5, PP);
+  __ LoadDImmediate(result, 0.5);
   __ fcmpd(exp, result);
   __ b(&do_pow, NE);
 
   // base == 0 -> return 0;
   __ fcmpdz(saved_base);
   __ b(&return_zero, EQ);
 
   __ fsqrtd(result, saved_base);
   __ b(&skip_call);
 
   __ Bind(&return_zero);
-  __ LoadDImmediate(result, 0.0, PP);
+  __ LoadDImmediate(result, 0.0);
   __ b(&skip_call);
 
   __ Bind(&do_pow);
   __ fmovdd(base, saved_base);  // Restore base.
 
   __ CallRuntime(instr->TargetFunction(), kInputCount);
   __ Bind(&skip_call);
 }
 
 
@@ skipping 94 matching lines @@
       __ b(deopt, EQ);
     }
 
     __ SmiUntag(result_mod, left);
     __ SmiUntag(TMP, right);
 
     __ sdiv(result_div, result_mod, TMP);
 
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
-    __ CompareImmediate(result_div, 0x4000000000000000, PP);
+    __ CompareImmediate(result_div, 0x4000000000000000);
     __ b(deopt, EQ);
     // result_mod <- left - right * result_div.
     __ msub(result_mod, TMP, result_div, result_mod);
     __ SmiTag(result_div);
     __ SmiTag(result_mod);
     // Correct MOD result:
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
@@ skipping 58 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);
+    __ CompareObject(locs()->in(0).reg(), Object::null_object());
     ASSERT(DeoptIfNull() || DeoptIfNotNull());
     Condition cond = DeoptIfNull() ? EQ : NE;
     __ b(deopt, cond);
     return;
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   const Register value = locs()->in(0).reg();
   const Register temp = locs()->temp(0).reg();
   Label is_ok;
   if (unary_checks().GetReceiverClassIdAt(0) == kSmiCid) {
     __ tsti(value, Immediate(kSmiTagMask));
     __ b(&is_ok, EQ);
   } else {
     __ tsti(value, Immediate(kSmiTagMask));
     __ b(deopt, EQ);
   }
-  __ LoadClassId(temp, value, PP);
+  __ LoadClassId(temp, value);
 
   if (IsDenseSwitch()) {
     ASSERT(cids_[0] < cids_[cids_.length() - 1]);
-    __ AddImmediate(temp, temp, -cids_[0], PP);
-    __ CompareImmediate(temp, cids_[cids_.length() - 1] - cids_[0], PP);
+    __ AddImmediate(temp, temp, -cids_[0]);
+    __ CompareImmediate(temp, cids_[cids_.length() - 1] - cids_[0]);
     __ b(deopt, HI);
 
     intptr_t mask = ComputeCidMask();
     if (!IsDenseMask(mask)) {
       // Only need mask if there are missing numbers in the range.
       ASSERT(cids_.length() > 2);
       Register mask_reg = locs()->temp(1).reg();
-      __ LoadImmediate(mask_reg, 1, PP);
+      __ LoadImmediate(mask_reg, 1);
       __ lslv(mask_reg, mask_reg, temp);
-      __ TestImmediate(mask_reg, mask, PP);
+      __ TestImmediate(mask_reg, mask);
       __ b(deopt, EQ);
     }
 
   } else {
     GrowableArray<CidTarget> sorted_ic_data;
     FlowGraphCompiler::SortICDataByCount(unary_checks(),
                                          &sorted_ic_data,
                                          /* drop_smi = */ true);
     const intptr_t num_checks = sorted_ic_data.length();
     for (intptr_t i = 0; i < num_checks; i++) {
       const intptr_t cid = sorted_ic_data[i].cid;
       ASSERT(cid != kSmiCid);
-      __ CompareImmediate(temp, cid, PP);
+      __ CompareImmediate(temp, cid);
       if (i == (num_checks - 1)) {
         __ b(deopt, NE);
       } else {
         __ b(&is_ok, EQ);
       }
     }
   }
   __ Bind(&is_ok);
 }
 
 
 LocationSummary* CheckClassIdInstr::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::RequiresRegister());
   return summary;
 }
 
 
 void CheckClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckClass);
-  __ CompareImmediate(value, Smi::RawValue(cid_), PP);
+  __ CompareImmediate(value, Smi::RawValue(cid_));
   __ b(deopt, NE);
 }
 
 
 LocationSummary* CheckSmiInstr::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);
@@ skipping 48 matching lines @@
            (Smi::Cast(index_loc.constant()).Value() < 0));
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ b(deopt);
     return;
   }
 
   if (index_loc.IsConstant()) {
     const Register length = length_loc.reg();
     const Smi& index = Smi::Cast(index_loc.constant());
-    __ CompareImmediate(length, reinterpret_cast<int64_t>(index.raw()), PP);
+    __ CompareImmediate(length, reinterpret_cast<int64_t>(index.raw()));
     __ b(deopt, LS);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     const Register index = index_loc.reg();
     if (length.Value() == Smi::kMaxValue) {
       __ tst(index, Operand(index));
       __ b(deopt, MI);
     } else {
-      __ CompareImmediate(index, reinterpret_cast<int64_t>(length.raw()), PP);
+      __ CompareImmediate(index, reinterpret_cast<int64_t>(length.raw()));
       __ b(deopt, CS);
     }
   } else {
     const Register length = length_loc.reg();
     const Register index = index_loc.reg();
     __ CompareRegisters(index, length);
     __ b(deopt, CS);
   }
 }
 
@@ skipping 295 matching lines @@
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
 
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 
   const Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
-  __ LoadObject(result, Bool::False(), PP);
+  __ LoadObject(result, Bool::False());
   __ b(&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);
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* BooleanNegateInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   return LocationSummary::Make(zone,
                                1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
 
-  __ LoadObject(result, Bool::True(), PP);
-  __ LoadObject(TMP, Bool::False(), PP);
+  __ LoadObject(result, Bool::True());
+  __ LoadObject(TMP, Bool::False());
   __ CompareRegisters(result, value);
   __ csel(result, TMP, result, EQ);
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   return MakeCallSummary(zone);
 }
 
@@ skipping 27 matching lines @@
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(R0));
   locs->set_out(0, Location::RegisterLocation(R0));
   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());
   __ Push(typed_data);
   compiler->GenerateRuntimeCall(Scanner::kNoSourcePos,  // No token position.
                                 deopt_id(),
                                 kGrowRegExpStackRuntimeEntry,
                                 1,
                                 locs());
   __ Drop(1);
   __ Pop(result);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64