Removes loads from PP from stubs on arm64.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 146 matching lines @@
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing native code.
   __ mov(CTX, R0);
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
     __ LoadFromOffset(R6, CTX, Isolate::vm_tag_offset());
-    __ CompareImmediate(R6, VMTag::kScriptTagId, PP);
+    __ CompareImmediate(R6, VMTag::kScriptTagId, kNoRegister);
     __ b(&ok, EQ);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing Native code.
   __ StoreToOffset(R5, CTX, Isolate::vm_tag_offset());
 
   // Reserve space for the native arguments structure passed on the stack (the
@@ skipping 10 matching lines @@
   // There are no native calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   // Set argc in NativeArguments: R1 already contains argc.
 
   ASSERT(argv_offset == 2 * kWordSize);
   // Set argv in NativeArguments: R2 already contains argv.
 
   // Set retval in NativeArgs.
   ASSERT(retval_offset == 3 * kWordSize);
-  __ AddImmediate(R3, FP, 2 * kWordSize, PP);
+  __ AddImmediate(R3, FP, 2 * kWordSize, kNoRegister);
 
   // TODO(regis): Should we pass the structure by value as in runtime calls?
   // It would require changing Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ StoreToOffset(R0, SP, isolate_offset);
   __ StoreToOffset(R1, SP, argc_tag_offset);
   __ StoreToOffset(R2, SP, argv_offset);
   __ StoreToOffset(R3, SP, retval_offset);
   __ mov(R0, SP);  // Pass the pointer to the NativeArguments.
 
   // Call native function (setsup scope if not leaf function).
   Label leaf_call;
   Label done;
-  __ TestImmediate(R1, NativeArguments::AutoSetupScopeMask(), PP);
+  __ TestImmediate(R1, NativeArguments::AutoSetupScopeMask(), kNoRegister);
   __ b(&leaf_call, EQ);
 
   __ mov(R1, R5);  // Pass the function entrypoint to call.
   // Call native function invocation wrapper or redirection via simulator.
 #if defined(USING_SIMULATOR)
   uword entry = reinterpret_cast<uword>(NativeEntry::NativeCallWrapper);
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
-  __ LoadImmediate(R2, entry, PP);
+  __ LoadImmediate(R2, entry, kNoRegister);
   __ blr(R2);
 #else
   __ BranchLink(&NativeEntry::NativeCallWrapperLabel());
 #endif
   __ b(&done);
 
   __ Bind(&leaf_call);
   // Call native function or redirection via simulator.
   __ blr(R5);
 
   __ Bind(&done);
 
   // Mark that the isolate is executing Dart code.
-  __ LoadImmediate(R2, VMTag::kScriptTagId, PP);
+  __ LoadImmediate(R2, VMTag::kScriptTagId, kNoRegister);
   __ StoreToOffset(R2, CTX, Isolate::vm_tag_offset());
 
   // Reset exit frame information in Isolate structure.
-  __ LoadImmediate(R2, 0, PP);
+  __ LoadImmediate(R2, 0, kNoRegister);
   __ StoreToOffset(R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadObject(R3, Object::null_object(), PP);
   __ StoreToOffset(R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
@@ skipping 29 matching lines @@
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing native code.
   __ mov(CTX, R0);
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
     __ LoadFromOffset(R6, CTX, Isolate::vm_tag_offset());
-    __ CompareImmediate(R6, VMTag::kScriptTagId, PP);
+    __ CompareImmediate(R6, VMTag::kScriptTagId, kNoRegister);
     __ b(&ok, EQ);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing Native code.
   __ StoreToOffset(R5, CTX, Isolate::vm_tag_offset());
 
   // Reserve space for the native arguments structure passed on the stack (the
@@ skipping 10 matching lines @@
   // There are no native calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   // Set argc in NativeArguments: R1 already contains argc.
 
   ASSERT(argv_offset == 2 * kWordSize);
   // Set argv in NativeArguments: R2 already contains argv.
 
   // Set retval in NativeArgs.
   ASSERT(retval_offset == 3 * kWordSize);
-  __ AddImmediate(R3, FP, 2 * kWordSize, PP);
+  __ AddImmediate(R3, FP, 2 * kWordSize, kNoRegister);
 
   // TODO(regis): Should we pass the structure by value as in runtime calls?
   // It would require changing Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ StoreToOffset(R0, SP, isolate_offset);
   __ StoreToOffset(R1, SP, argc_tag_offset);
   __ StoreToOffset(R2, SP, argv_offset);
   __ StoreToOffset(R3, SP, retval_offset);
   __ mov(R0, SP);  // Pass the pointer to the NativeArguments.
 
   // Call native function or redirection via simulator.
   __ blr(R5);
 
   // Mark that the isolate is executing Dart code.
-  __ LoadImmediate(R2, VMTag::kScriptTagId, PP);
+  __ LoadImmediate(R2, VMTag::kScriptTagId, kNoRegister);
   __ StoreToOffset(R2, CTX, Isolate::vm_tag_offset());
 
   // Reset exit frame information in Isolate structure.
-  __ LoadImmediate(R2, 0, PP);
+  __ LoadImmediate(R2, 0, kNoRegister);
   __ StoreToOffset(R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadObject(R3, Object::null_object(), PP);
   __ StoreToOffset(R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
@@ skipping 215 matching lines @@
 
   // Load the isolate out of the context.
   // Spilled: R1, R2, R3.
   // R0: address being stored.
   __ LoadFieldFromOffset(R1, CTX, Context::isolate_offset());
 
   // Load the StoreBuffer block out of the isolate. Then load top_ out of the
   // StoreBufferBlock and add the address to the pointers_.
   // R1: isolate.
   __ LoadFromOffset(R1, R1, Isolate::store_buffer_offset());
-  __ LoadFromOffset(R2, R1, StoreBufferBlock::top_offset());
+  __ LoadFromOffset(R2, R1, StoreBufferBlock::top_offset(), kUnsignedWord);
   __ add(R3, R1, Operand(R2, LSL, 3));
   __ StoreToOffset(R0, R3, StoreBufferBlock::pointers_offset());
 
   // Increment top_ and check for overflow.
   // R2: top_.
   // R1: StoreBufferBlock.
   Label L;
   __ add(R2, R2, Operand(1));
-  __ StoreToOffset(R2, R1, StoreBufferBlock::top_offset());
-  __ CompareImmediate(R2, StoreBufferBlock::kSize, PP);
+  __ StoreToOffset(R2, R1, StoreBufferBlock::top_offset(), kUnsignedWord);
+  __ CompareImmediate(R2, StoreBufferBlock::kSize, kNoRegister);
   // Restore values.
   __ Pop(R3);
   __ Pop(R2);
   __ Pop(R1);
   __ b(&L, EQ);
   __ ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
@@ skipping 26 matching lines @@
   if (is_cls_parameterized) {
     __ ldr(R1, Address(SP));
     // R1: instantiated type arguments.
   }
   if (FLAG_inline_alloc && Heap::IsAllocatableInNewSpace(instance_size)) {
     Label slow_case;
     // Allocate the object and update top to point to
     // next object start and initialize the allocated object.
     // R1: instantiated type arguments (if is_cls_parameterized).
     Heap* heap = Isolate::Current()->heap();
-    __ LoadImmediate(R5, heap->TopAddress(), PP);
+    __ LoadImmediate(R5, heap->TopAddress(), kNoRegister);
     __ ldr(R2, Address(R5));
-    __ AddImmediate(R3, R2, instance_size, PP);
+    __ AddImmediate(R3, R2, instance_size, kNoRegister);
     // Check if the allocation fits into the remaining space.
     // R2: potential new object start.
     // R3: potential next object start.
-    __ LoadImmediate(TMP, heap->EndAddress(), PP);
+    __ LoadImmediate(TMP, heap->EndAddress(), kNoRegister);
     __ ldr(TMP, Address(TMP));
     __ CompareRegisters(R3, TMP);
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
       __ b(&slow_case, CS);  // Unsigned higher or equal.
     }
     __ str(R3, Address(R5));
-    __ UpdateAllocationStats(cls.id(), R5);
+    __ UpdateAllocationStats(cls.id(), R5, kNoRegister);
 
     // R2: new object start.
     // R3: next object start.
     // R1: new object type arguments (if is_cls_parameterized).
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
-    __ LoadImmediate(R0, tags, PP);
+    __ LoadImmediate(R0, tags, kNoRegister);
     __ StoreToOffset(R0, R2, Instance::tags_offset());
 
     // Initialize the remaining words of the object.
     __ LoadObject(R0, Object::null_object(), PP);
 
     // R0: raw null.
     // R2: new object start.
     // R3: next object start.
     // R1: new object type arguments (if is_cls_parameterized).
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
       for (intptr_t current_offset = Instance::NextFieldOffset();
            current_offset < instance_size;
            current_offset += kWordSize) {
         __ StoreToOffset(R0, R2, current_offset);
       }
     } else {
-      __ AddImmediate(R4, R2, Instance::NextFieldOffset(), PP);
+      __ AddImmediate(R4, R2, Instance::NextFieldOffset(), kNoRegister);
       // Loop until the whole object is initialized.
       // R0: raw null.
       // R2: new object.
       // R3: next object start.
       // R4: next word to be initialized.
       // R1: new object type arguments (if is_cls_parameterized).
       Label init_loop;
       Label done;
       __ Bind(&init_loop);
       __ CompareRegisters(R4, R3);
       __ b(&done, CS);
       __ str(R0, Address(R4));
-      __ AddImmediate(R4, R4, kWordSize, PP);
+      __ AddImmediate(R4, R4, kWordSize, kNoRegister);
       __ b(&init_loop);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
       // R1: new object type arguments.
       // Set the type arguments in the new object.
       __ StoreToOffset(R1, R2, cls.type_arguments_field_offset());
     }
     // Done allocating and initializing the instance.
     // R2: new object still missing its heap tag.
@@ skipping 39 matching lines @@
 
 
 // Loads function into 'temp_reg'.
 void StubCode::GenerateUsageCounterIncrement(Assembler* assembler,
                                              Register temp_reg) {
   Register ic_reg = R5;
   Register func_reg = temp_reg;
   ASSERT(temp_reg == R6);
   __ LoadFieldFromOffset(func_reg, ic_reg, ICData::owner_offset());
   __ LoadFieldFromOffset(R7, func_reg, Function::usage_counter_offset());
-  __ AddImmediate(R7, R7, 1, PP);
+  __ AddImmediate(R7, R7, 1, kNoRegister);
   __ StoreFieldToOffset(R7, func_reg, Function::usage_counter_offset());
 }
 
 
 // Generate inline cache check for 'num_args'.
 //  LR: return address.
 //  R5: inline cache data object.
 // Control flow:
 // - If receiver is null -> jump to IC miss.
 // - If receiver is Smi -> load Smi class.
 // - If receiver is not-Smi -> load receiver's class.
 // - Check if 'num_args' (including receiver) match any IC data group.
 // - Match found -> jump to target.
 // - Match not found -> jump to IC miss.
 void StubCode::GenerateNArgsCheckInlineCacheStub(
     Assembler* assembler,
     intptr_t num_args,
     const RuntimeEntry& handle_ic_miss) {
   ASSERT(num_args > 0);
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumArgsTested() == num_args.
     // 'NumArgsTested' is stored in the least significant bits of 'state_bits'.
     __ LoadFromOffset(R6, R5, ICData::state_bits_offset() - kHeapObjectTag,
                       kUnsignedWord);
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andi(R6, R6, ICData::NumArgsTestedMask());
-    __ CompareImmediate(R6, num_args, PP);
+    __ CompareImmediate(R6, num_args, kNoRegister);
     __ b(&ok, EQ);
     __ Stop("Incorrect stub for IC data");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   // Check single stepping.
   Label not_stepping;
   __ LoadFieldFromOffset(R6, CTX, Context::isolate_offset());
   __ LoadFromOffset(R6, R6, Isolate::single_step_offset(), kUnsignedByte);
-  __ CompareImmediate(R6, 0, PP);
+  __ CompareImmediate(R6, 0, kNoRegister);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
   __ Push(R5);  // Preserve IC data.
   __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ Pop(R5);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
 
   // Load arguments descriptor into R4.
   __ LoadFieldFromOffset(R4, R5, ICData::arguments_descriptor_offset());
   // Loop that checks if there is an IC data match.
   Label loop, update, test, found, get_class_id_as_smi;
   // R5: IC data object (preserved).
   __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset());
   // R6: ic_data_array with check entries: classes and target functions.
-  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag, PP);
+  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag, kNoRegister);
   // R6: points directly to the first ic data array element.
 
   // Get the receiver's class ID (first read number of arguments from
   // arguments descriptor array and then access the receiver from the stack).
   __ LoadFieldFromOffset(R7, R4, ArgumentsDescriptor::count_offset());
   __ SmiUntag(R7);  // Untag so we can use the LSL 3 addressing mode.
   __ sub(R7, R7, Operand(1));
 
   // R0 <- [SP + (R7 << 3)]
   __ ldr(R0, Address(SP, R7, UXTX, Address::Scaled));
 
   {
     // TODO(zra): Put this code in a subroutine call as with other architectures
     // when we have a bl(Label& l) instruction.
     // Instance in R0, return its class-id in R0 as Smi.
     // Test if Smi -> load Smi class for comparison.
     Label not_smi, done;
     __ tsti(R0, kSmiTagMask);
     __ b(&not_smi, NE);
-    __ LoadImmediate(R0, Smi::RawValue(kSmiCid), PP);
+    __ LoadImmediate(R0, Smi::RawValue(kSmiCid), kNoRegister);
     __ b(&done);
 
     __ Bind(&not_smi);
     __ LoadClassId(R0, R0);
     __ SmiTag(R0);
     __ Bind(&done);
   }
 
   // R7: argument_count - 1 (untagged).
   // R0: receiver's class ID (smi).
   __ ldr(R1, Address(R6));  // First class id (smi) to check.
   __ b(&test);
 
   __ Bind(&loop);
   for (int i = 0; i < num_args; i++) {
     if (i > 0) {
       // If not the first, load the next argument's class ID.
-      __ AddImmediate(R0, R7, -i, PP);
+      __ AddImmediate(R0, R7, -i, kNoRegister);
       // R0 <- [SP + (R0 << 3)]
       __ ldr(R0, Address(SP, R0, UXTX, Address::Scaled));
       {
         // Instance in R0, return its class-id in R0 as Smi.
         // Test if Smi -> load Smi class for comparison.
         Label not_smi, done;
         __ tsti(R0, kSmiTagMask);
         __ b(&not_smi, NE);
-        __ LoadImmediate(R0, Smi::RawValue(kSmiCid), PP);
+        __ LoadImmediate(R0, Smi::RawValue(kSmiCid), kNoRegister);
         __ b(&done);
 
         __ Bind(&not_smi);
         __ LoadClassId(R0, R0);
         __ SmiTag(R0);
         __ Bind(&done);
       }
       // R0: next argument class ID (smi).
       __ LoadFromOffset(R1, R6, i * kWordSize);
       // R1: next class ID to check (smi).
     }
     __ CompareRegisters(R0, R1);  // Class id match?
     if (i < (num_args - 1)) {
       __ b(&update, NE);  // Continue.
     } else {
       // Last check, all checks before matched.
       __ b(&found, EQ);  // Break.
     }
   }
   __ Bind(&update);
   // Reload receiver class ID.  It has not been destroyed when num_args == 1.
   if (num_args > 1) {
     __ ldr(R0, Address(SP, R7, UXTX, Address::Scaled));
     {
       // Instance in R0, return its class-id in R0 as Smi.
       // Test if Smi -> load Smi class for comparison.
       Label not_smi, done;
       __ tsti(R0, kSmiTagMask);
       __ b(&not_smi, NE);
-      __ LoadImmediate(R0, Smi::RawValue(kSmiCid), PP);
+      __ LoadImmediate(R0, Smi::RawValue(kSmiCid), kNoRegister);
       __ b(&done);
 
       __ Bind(&not_smi);
       __ LoadClassId(R0, R0);
       __ SmiTag(R0);
       __ Bind(&done);
     }
   }
 
   const intptr_t entry_size = ICData::TestEntryLengthFor(num_args) * kWordSize;
-  __ AddImmediate(R6, R6, entry_size, PP);  // Next entry.
+  __ AddImmediate(R6, R6, entry_size, kNoRegister);  // Next entry.
   __ ldr(R1, Address(R6));  // Next class ID.
 
   __ Bind(&test);
-  __ CompareImmediate(R1, Smi::RawValue(kIllegalCid), PP);  // Done?
+  __ CompareImmediate(R1, Smi::RawValue(kIllegalCid), kNoRegister);  // Done?
   __ b(&loop, NE);
 
   // IC miss.
   // Compute address of arguments.
   // R7: argument_count - 1 (untagged).
   // R7 <- SP + (R7 << 3)
   __ add(R7, SP, Operand(R7, UXTX, 3));  // R7 is Untagged.
   // R7: address of receiver.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
@@ skipping 25 matching lines @@
 
   __ Bind(&found);
   // R6: pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
   __ LoadFromOffset(R0, R6, target_offset);
   __ LoadFromOffset(R1, R6, count_offset);
   __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ StoreToOffset(R1, R6, count_offset);
   __ b(&call_target_function, VC);  // No overflow.
-  __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), PP);
+  __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), kNoRegister);
   __ StoreToOffset(R1, R6, count_offset);
 
   __ Bind(&call_target_function);
   // R0: target function.
   __ LoadFieldFromOffset(R2, R0, Function::code_offset());
   __ LoadFieldFromOffset(R2, R2, Code::instructions_offset());
-  __ AddImmediate(R2, R2, Instructions::HeaderSize() - kHeapObjectTag, PP);
+  __ AddImmediate(
+      R2, R2, Instructions::HeaderSize() - kHeapObjectTag, kNoRegister);
   __ br(R2);
 }
 
 
 // Use inline cache data array to invoke the target or continue in inline
 // cache miss handler. Stub for 1-argument check (receiver class).
 //  LR: return address.
 //  R5: inline cache data object.
 // Inline cache data object structure:
 // 0: function-name
@@ skipping 51 matching lines @@
 void StubCode::GenerateZeroArgsUnoptimizedStaticCallStub(Assembler* assembler) {
   GenerateUsageCounterIncrement(assembler, R6);
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumArgsTested() == 0.
     // 'NumArgsTested' is stored in the least significant bits of 'state_bits'.
     __ LoadFromOffset(R6, R5, ICData::state_bits_offset() - kHeapObjectTag,
                       kUnsignedWord);
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andi(R6, R6, ICData::NumArgsTestedMask());
-    __ CompareImmediate(R6, 0, PP);
+    __ CompareImmediate(R6, 0, kNoRegister);
     __ b(&ok, EQ);
     __ Stop("Incorrect IC data for unoptimized static call");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   // Check single stepping.
   Label not_stepping;
   __ LoadFieldFromOffset(R6, CTX, Context::isolate_offset());
   __ LoadFromOffset(R6, R6, Isolate::single_step_offset(), kUnsignedByte);
-  __ CompareImmediate(R6, 0, PP);
+  __ CompareImmediate(R6, 0, kNoRegister);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
   __ Push(R5);  // Preserve IC data.
   __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ Pop(R5);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
 
   // R5: IC data object (preserved).
   __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset());
   // R6: ic_data_array with entries: target functions and count.
-  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag, PP);
+  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag, kNoRegister);
   // R6: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(0) * kWordSize;
 
   // Increment count for this call.
   Label increment_done;
   __ LoadFromOffset(R1, R6, count_offset);
   __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ StoreToOffset(R1, R6, count_offset);
   __ b(&increment_done, VC);  // No overflow.
-  __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), PP);
+  __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), kNoRegister);
   __ StoreToOffset(R1, R6, count_offset);
   __ Bind(&increment_done);
 
   // Load arguments descriptor into R4.
   __ LoadFieldFromOffset(R4, R5, ICData::arguments_descriptor_offset());
 
   // Get function and call it, if possible.
   __ LoadFromOffset(R0, R6, target_offset);
   __ LoadFieldFromOffset(R2, R0, Function::code_offset());
 
   // R0: function.
   // R2: target code.
   __ LoadFieldFromOffset(R2, R2, Code::instructions_offset());
-  __ AddImmediate(R2, R2, Instructions::HeaderSize() - kHeapObjectTag, PP);
+  __ AddImmediate(
+      R2, R2, Instructions::HeaderSize() - kHeapObjectTag, kNoRegister);
   __ br(R2);
 }
 
 
 void StubCode::GenerateTwoArgsUnoptimizedStaticCallStub(Assembler* assembler) {
   __ Stop("GenerateTwoArgsUnoptimizedStaticCallStub");
 }
 
 
 // Stub for compiling a function and jumping to the compiled code.
 // R5: IC-Data (for methods).
 // R4: Arguments descriptor.
 // R0: Function.
 void StubCode::GenerateLazyCompileStub(Assembler* assembler) {
   // Preserve arg desc. and IC data object.
   __ EnterStubFrame();
   __ Push(R5);  // Save IC Data.
   __ Push(R4);  // Save arg. desc.
   __ Push(R0);  // Pass function.
   __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ Pop(R0);  // Restore argument.
   __ Pop(R4);  // Restore arg desc.
   __ Pop(R5);  // Restore IC Data.
   __ LeaveStubFrame();
 
   __ LoadFieldFromOffset(R2, R0, Function::code_offset());
   __ LoadFieldFromOffset(R2, R2, Code::instructions_offset());
-  __ AddImmediate(R2, R2, Instructions::HeaderSize() - kHeapObjectTag, PP);
+  __ AddImmediate(
+      R2, R2, Instructions::HeaderSize() - kHeapObjectTag, kNoRegister);
   __ br(R2);
 }
 
 
 void StubCode::GenerateBreakpointRuntimeStub(Assembler* assembler) {
   __ Stop("GenerateBreakpointRuntimeStub");
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 void StubCode::GenerateDebugStepCheckStub(
     Assembler* assembler) {
   // Check single stepping.
   Label not_stepping;
   __ LoadFieldFromOffset(R1, CTX, Context::isolate_offset());
   __ LoadFromOffset(R1, R1, Isolate::single_step_offset(), kUnsignedByte);
-  __ CompareImmediate(R1, 0, PP);
+  __ CompareImmediate(R1, 0, kNoRegister);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
   __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
   __ ret();
 }
 
 
 void StubCode::GenerateSubtype1TestCacheStub(Assembler* assembler) {
@@ skipping 96 matching lines @@
 // LR: return address.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Return Zero condition flag set if equal.
 void StubCode::GenerateUnoptimizedIdenticalWithNumberCheckStub(
     Assembler* assembler) {
   // Check single stepping.
   Label not_stepping;
   __ LoadFieldFromOffset(R1, CTX, Context::isolate_offset());
   __ LoadFromOffset(R1, R1, Isolate::single_step_offset(), kUnsignedByte);
-  __ CompareImmediate(R1, 0, PP);
+  __ CompareImmediate(R1, 0, kNoRegister);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
   __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
 
   const Register left = R1;
   const Register right = R0;
   __ LoadFromOffset(left, SP, 1 * kWordSize);
   __ LoadFromOffset(right, SP, 0 * kWordSize);
   GenerateIdenticalWithNumberCheckStub(assembler, left, right);
   __ ret();
 }
 
 
 void StubCode::GenerateOptimizedIdenticalWithNumberCheckStub(
     Assembler* assembler) {
   __ Stop("GenerateOptimizedIdenticalWithNumberCheckStub");
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64