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

runtime/vm/assembler_arm64_test.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/os.h"
@@ skipping 269 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(AddExtReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(AddCarryInOut, assembler) {
-  __ LoadImmediate(R2, -1, kNoPP);
-  __ LoadImmediate(R1, 1, kNoPP);
-  __ LoadImmediate(R0, 0, kNoPP);
+  __ LoadImmediate(R2, -1);
+  __ LoadImmediate(R1, 1);
+  __ LoadImmediate(R0, 0);
   __ adds(IP0, R2, Operand(R1));  // c_out = 1.
   __ adcs(IP0, R2, R0);  // c_in = 1, c_out = 1.
   __ adc(R0, R0, R0);  // c_in = 1.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(AddCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SubCarryInOut, assembler) {
-  __ LoadImmediate(R1, 1, kNoPP);
-  __ LoadImmediate(R0, 0, kNoPP);
+  __ LoadImmediate(R1, 1);
+  __ LoadImmediate(R0, 0);
   __ subs(IP0, R0, Operand(R1));  // c_out = 1.
   __ sbcs(IP0, R0, R0);  // c_in = 1, c_out = 1.
   __ sbc(R0, R0, R0);  // c_in = 1.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SubCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Overflow, assembler) {
-  __ LoadImmediate(R0, 0, kNoPP);
-  __ LoadImmediate(R1, 1, kNoPP);
-  __ LoadImmediate(R2, 0xFFFFFFFFFFFFFFFF, kNoPP);
-  __ LoadImmediate(R3, 0x7FFFFFFFFFFFFFFF, kNoPP);
+  __ LoadImmediate(R0, 0);
+  __ LoadImmediate(R1, 1);
+  __ LoadImmediate(R2, 0xFFFFFFFFFFFFFFFF);
+  __ LoadImmediate(R3, 0x7FFFFFFFFFFFFFFF);
   __ adds(IP0, R2, Operand(R1));  // c_out = 1.
   __ adcs(IP0, R3, R0);  // c_in = 1, c_out = 1, v = 1.
   __ csinc(R0, R0, R0, VS);  // R0 = v ? R0 : R0 + 1.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(WordAddCarryInOut, assembler) {
-  __ LoadImmediate(R2, -1, kNoPP);
-  __ LoadImmediate(R1, 1, kNoPP);
-  __ LoadImmediate(R0, 0, kNoPP);
+  __ LoadImmediate(R2, -1);
+  __ LoadImmediate(R1, 1);
+  __ LoadImmediate(R0, 0);
   __ addsw(IP0, R2, Operand(R1));  // c_out = 1.
   __ adcsw(IP0, R2, R0);  // c_in = 1, c_out = 1.
   __ adcw(R0, R0, R0);  // c_in = 1.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(WordAddCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(WordSubCarryInOut, assembler) {
-  __ LoadImmediate(R1, 1, kNoPP);
-  __ LoadImmediate(R0, 0, kNoPP);
+  __ LoadImmediate(R1, 1);
+  __ LoadImmediate(R0, 0);
   __ subsw(IP0, R0, Operand(R1));  // c_out = 1.
   __ sbcsw(IP0, R0, R0);  // c_in = 1, c_out = 1.
   __ sbcw(R0, R0, R0);  // c_in = 1.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(WordSubCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x0FFFFFFFF, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(WordOverflow, assembler) {
-  __ LoadImmediate(R0, 0, kNoPP);
-  __ LoadImmediate(R1, 1, kNoPP);
-  __ LoadImmediate(R2, 0xFFFFFFFF, kNoPP);
-  __ LoadImmediate(R3, 0x7FFFFFFF, kNoPP);
+  __ LoadImmediate(R0, 0);
+  __ LoadImmediate(R1, 1);
+  __ LoadImmediate(R2, 0xFFFFFFFF);
+  __ LoadImmediate(R3, 0x7FFFFFFF);
   __ addsw(IP0, R2, Operand(R1));  // c_out = 1.
   __ adcsw(IP0, R3, R0);  // c_in = 1, c_out = 1, v = 1.
   __ csinc(R0, R0, R0, VS);  // R0 = v ? R0 : R0 + 1.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(WordOverflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
@@ skipping 115 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(LoadStoreScaledReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadSigned32Bit, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadImmediate(R1, 0xffffffff, kNoPP);
+  __ LoadImmediate(R1, 0xffffffff);
   __ str(R1, Address(SP, -4, Address::PreIndex, kWord), kWord);
   __ ldr(R0, Address(SP), kWord);
   __ ldr(R1, Address(SP, 4, Address::PostIndex, kWord), kWord);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadSigned32Bit, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SimpleLoadStorePair, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadImmediate(R2, 43, kNoPP);
-  __ LoadImmediate(R3, 42, kNoPP);
+  __ LoadImmediate(R2, 43);
+  __ LoadImmediate(R3, 42);
   __ stp(R2, R3, Address(SP, -2*kWordSize, Address::PairPreIndex));
   __ ldp(R0, R1, Address(SP, 2*kWordSize, Address::PairPostIndex));
   __ sub(R0, R0, Operand(R1));
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SimpleLoadStorePair, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadStorePairOffset, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadImmediate(R2, 43, kNoPP);
-  __ LoadImmediate(R3, 42, kNoPP);
+  __ LoadImmediate(R2, 43);
+  __ LoadImmediate(R3, 42);
   __ sub(SP, SP, Operand(4 * kWordSize));
   __ stp(R2, R3, Address::Pair(SP, 2 * kWordSize));
   __ ldp(R0, R1, Address::Pair(SP, 2 * kWordSize));
   __ add(SP, SP, Operand(4 * kWordSize));
   __ sub(R0, R0, Operand(R1));
   __ mov(CSP, SP);
   __ ret();
 }
 
 
@@ skipping 162 matching lines @@
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Clz, assembler) {
   Label error;
 
   __ clz(R1, ZR);
   __ cmp(R1, Operand(64));
   __ b(&error, NE);
-  __ LoadImmediate(R2, 42, kNoPP);
+  __ LoadImmediate(R2, 42);
   __ clz(R2, R2);
   __ cmp(R2, Operand(58));
   __ b(&error, NE);
-  __ LoadImmediate(R0, -1, kNoPP);
+  __ LoadImmediate(R0, -1);
   __ clz(R1, R0);
   __ cmp(R1, Operand(0));
   __ b(&error, NE);
   __ add(R0, ZR, Operand(R0, LSR, 3));
   __ clz(R1, R0);
   __ cmp(R1, Operand(3));
   __ b(&error, NE);
   __ mov(R0, ZR);
   __ ret();
   __ Bind(&error);
-  __ LoadImmediate(R0, 1, kNoPP);
+  __ LoadImmediate(R0, 1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Clz, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
@@ skipping 233 matching lines @@
 
 ASSEMBLER_TEST_RUN(CmpBranchIfNotZeroNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FcmpEqBranch, assembler) {
   Label l;
 
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, 234.0, kNoPP);
-  __ LoadDImmediate(V2, 234.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, 234.0);
+  __ LoadDImmediate(V2, 234.0);
 
   __ fcmpd(V1, V2);
   __ b(&l, EQ);
-  __ LoadDImmediate(V0, 0.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
   __ Bind(&l);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FcmpEqBranch, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FcmpEqBranchNotTaken, assembler) {
   Label l;
 
-  __ LoadDImmediate(V0, 0.0, kNoPP);
-  __ LoadDImmediate(V1, 233.0, kNoPP);
-  __ LoadDImmediate(V2, 234.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
+  __ LoadDImmediate(V1, 233.0);
+  __ LoadDImmediate(V2, 234.0);
 
   __ fcmpd(V1, V2);
   __ b(&l, EQ);
-  __ LoadDImmediate(V0, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
   __ Bind(&l);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FcmpEqBranchNotTaken, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FcmpLtBranch, assembler) {
   Label l;
 
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, 233.0, kNoPP);
-  __ LoadDImmediate(V2, 234.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, 233.0);
+  __ LoadDImmediate(V2, 234.0);
 
   __ fcmpd(V1, V2);
   __ b(&l, LT);
-  __ LoadDImmediate(V0, 0.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
   __ Bind(&l);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FcmpLtBranch, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FcmpLtBranchNotTaken, assembler) {
   Label l;
 
-  __ LoadDImmediate(V0, 0.0, kNoPP);
-  __ LoadDImmediate(V1, 235.0, kNoPP);
-  __ LoadDImmediate(V2, 234.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
+  __ LoadDImmediate(V1, 235.0);
+  __ LoadDImmediate(V2, 234.0);
 
   __ fcmpd(V1, V2);
   __ b(&l, LT);
-  __ LoadDImmediate(V0, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
   __ Bind(&l);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FcmpLtBranchNotTaken, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FcmpzGtBranch, assembler) {
   Label l;
 
-  __ LoadDImmediate(V0, 235.0, kNoPP);
-  __ LoadDImmediate(V1, 233.0, kNoPP);
+  __ LoadDImmediate(V0, 235.0);
+  __ LoadDImmediate(V1, 233.0);
 
   __ fcmpdz(V1);
   __ b(&l, GT);
-  __ LoadDImmediate(V0, 0.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
   __ ret();
   __ Bind(&l);
-  __ LoadDImmediate(V0, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FcmpzGtBranch, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
@@ skipping 402 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(Umaddl, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x700000001, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 // Loading immediate values without the object pool.
 ASSEMBLER_TEST_GENERATE(LoadImmediateSmall, assembler) {
-  __ LoadImmediate(R0, 42, kNoRegister);
+  __ LoadImmediate(R0, 42);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateSmall, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMed, assembler) {
-  __ LoadImmediate(R0, 0xf1234123, kNoRegister);
+  __ LoadImmediate(R0, 0xf1234123);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMed, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xf1234123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMed2, assembler) {
-  __ LoadImmediate(R0, 0x4321f1234123, kNoRegister);
+  __ LoadImmediate(R0, 0x4321f1234123);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMed2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(
       0x4321f1234123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateLarge, assembler) {
-  __ LoadImmediate(R0, 0x9287436598237465, kNoRegister);
+  __ LoadImmediate(R0, 0x9287436598237465);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateLarge, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(static_cast<int64_t>(0x9287436598237465),
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateSmallNeg, assembler) {
-  __ LoadImmediate(R0, -42, kNoRegister);
+  __ LoadImmediate(R0, -42);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateSmallNeg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg, assembler) {
-  __ LoadImmediate(R0, -0x1212341234, kNoRegister);
+  __ LoadImmediate(R0, -0x1212341234);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x1212341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg2, assembler) {
-  __ LoadImmediate(R0, -0x1212340000, kNoRegister);
+  __ LoadImmediate(R0, -0x1212340000);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x1212340000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg3, assembler) {
-  __ LoadImmediate(R0, -0x1200001234, kNoRegister);
+  __ LoadImmediate(R0, -0x1200001234);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg3, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x1200001234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg4, assembler) {
-  __ LoadImmediate(R0, -0x12341234, kNoRegister);
+  __ LoadImmediate(R0, -0x12341234);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg4, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x12341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 // Loading immediate values with the object pool.
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPSmall, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadImmediate(R0, 42, PP);
+  __ LoadPoolPointer();
+  __ LoadImmediate(R0, 42);
   __ PopAndUntagPP();
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPSmall, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadImmediate(R0, 0xf1234123, PP);
+  __ LoadPoolPointer();
+  __ LoadImmediate(R0, 0xf1234123);
   __ PopAndUntagPP();
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPMed, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xf1234123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed2, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadImmediate(R0, 0x4321f1234124, PP);
+  __ LoadPoolPointer();
+  __ LoadImmediate(R0, 0x4321f1234124);
   __ PopAndUntagPP();
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPMed2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(
       0x4321f1234124, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPLarge, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadImmediate(R0, 0x9287436598237465, PP);
+  __ LoadPoolPointer();
+  __ LoadImmediate(R0, 0x9287436598237465);
   __ PopAndUntagPP();
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPLarge, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(static_cast<int64_t>(0x9287436598237465),
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
@@ skipping 13 matching lines @@
   int64_t var_name = test_code(thread)
 #endif
 
 
 // LoadObject null.
 ASSEMBLER_TEST_GENERATE(LoadObjectNull, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ Push(THR);
   __ mov(THR, R0);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadObject(R0, Object::null_object(), PP);
+  __ LoadPoolPointer();
+  __ LoadObject(R0, Object::null_object());
   __ PopAndUntagPP();
   __ Pop(THR);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadObjectNull, test) {
   ASSEMBLER_TEST_RUN_WITH_THREAD(result);
   EXPECT_EQ(reinterpret_cast<int64_t>(Object::null()), result);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadObjectTrue, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ Push(THR);
   __ mov(THR, R0);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadObject(R0, Bool::True(), PP);
+  __ LoadPoolPointer();
+  __ LoadObject(R0, Bool::True());
   __ PopAndUntagPP();
   __ Pop(THR);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadObjectTrue, test) {
   ASSEMBLER_TEST_RUN_WITH_THREAD(result);
   EXPECT_EQ(reinterpret_cast<int64_t>(Bool::True().raw()), result);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadObjectFalse, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ Push(THR);
   __ mov(THR, R0);
   __ TagAndPushPP();  // Save caller's pool pointer and load a new one here.
-  __ LoadPoolPointer(PP);
-  __ LoadObject(R0, Bool::False(), PP);
+  __ LoadPoolPointer();
+  __ LoadObject(R0, Bool::False());
   __ PopAndUntagPP();
   __ Pop(THR);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadObjectFalse, test) {
   ASSEMBLER_TEST_RUN_WITH_THREAD(result);
   EXPECT_EQ(reinterpret_cast<int64_t>(Bool::False().raw()), result);
 }
 
 
 ASSEMBLER_TEST_GENERATE(CSelTrue, assembler) {
-  __ LoadImmediate(R1, 42, kNoRegister);
-  __ LoadImmediate(R2, 1234, kNoRegister);
+  __ LoadImmediate(R1, 42);
+  __ LoadImmediate(R2, 1234);
   __ CompareRegisters(R1, R2);
   __ csel(R0, R1, R2, LT);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CSelTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(CSelFalse, assembler) {
-  __ LoadImmediate(R1, 42, kNoRegister);
-  __ LoadImmediate(R2, 1234, kNoRegister);
+  __ LoadImmediate(R1, 42);
+  __ LoadImmediate(R2, 1234);
   __ CompareRegisters(R1, R2);
   __ csel(R0, R1, R2, GE);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CSelFalse, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(CsincFalse, assembler) {
-  __ LoadImmediate(R1, 42, kNoRegister);
-  __ LoadImmediate(R2, 1234, kNoRegister);
+  __ LoadImmediate(R1, 42);
+  __ LoadImmediate(R2, 1234);
   __ CompareRegisters(R1, R2);
   __ csinc(R0, R2, R1, GE);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CsincFalse, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(43, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(CsincTrue, assembler) {
-  __ LoadImmediate(R1, 42, kNoRegister);
-  __ LoadImmediate(R2, 1234, kNoRegister);
+  __ LoadImmediate(R1, 42);
+  __ LoadImmediate(R2, 1234);
   __ CompareRegisters(R1, R2);
   __ csinc(R0, R2, R1, LT);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CsincTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(CsinvFalse, assembler) {
-  __ LoadImmediate(R1, 42, kNoRegister);
-  __ LoadImmediate(R2, 1234, kNoRegister);
+  __ LoadImmediate(R1, 42);
+  __ LoadImmediate(R2, 1234);
   __ CompareRegisters(R1, R2);
   __ csinv(R0, R2, R1, GE);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CsinvFalse, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(~42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(CsinvTrue, assembler) {
-  __ LoadImmediate(R1, 42, kNoRegister);
-  __ LoadImmediate(R2, 1234, kNoRegister);
+  __ LoadImmediate(R1, 42);
+  __ LoadImmediate(R2, 1234);
   __ CompareRegisters(R1, R2);
   __ csinv(R0, R2, R1, LT);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CsinvTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 // Floating point move immediate, to/from integer register.
 ASSEMBLER_TEST_GENERATE(Fmovdi, assembler) {
-  __ LoadDImmediate(V0, 1.0, kNoPP);
+  __ LoadDImmediate(V0, 1.0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fmovdi, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fmovdi2, assembler) {
-  __ LoadDImmediate(V0, 123412983.1324524315, kNoPP);
+  __ LoadDImmediate(V0, 123412983.1324524315);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fmovdi2, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_FLOAT_EQ(123412983.1324524315,
       EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()), 0.0001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fmovrd, assembler) {
-  __ LoadDImmediate(V1, 1.0, kNoPP);
+  __ LoadDImmediate(V1, 1.0);
   __ fmovrd(R0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fmovrd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   const int64_t one = bit_cast<int64_t, double>(1.0);
   EXPECT_EQ(one, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fmovdr, assembler) {
-  __ LoadDImmediate(V1, 1.0, kNoPP);
+  __ LoadDImmediate(V1, 1.0);
   __ fmovrd(R1, V1);
   __ fmovdr(V0, R1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fmovdr, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdPrePostIndex, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V1, 42.0);
   __ fstrd(V1, Address(SP, -1*kWordSize, Address::PreIndex));
   __ fldrd(V0, Address(SP, 1*kWordSize, Address::PostIndex));
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrsFstrsPrePostIndex, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V1, 42.0);
   __ fcvtsd(V2, V1);
   __ fstrs(V2, Address(SP, -1*kWordSize, Address::PreIndex));
   __ fldrs(V3, Address(SP, 1*kWordSize, Address::PostIndex));
   __ fcvtds(V0, V3);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrsFstrsPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrqFstrqPrePostIndex, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V1, 21.0, kNoPP);
-  __ LoadDImmediate(V2, 21.0, kNoPP);
-  __ LoadImmediate(R1, 42, kNoPP);
+  __ LoadDImmediate(V1, 21.0);
+  __ LoadDImmediate(V2, 21.0);
+  __ LoadImmediate(R1, 42);
   __ Push(R1);
   __ PushDouble(V1);
   __ PushDouble(V2);
   __ fldrq(V3, Address(SP, 2 * kWordSize, Address::PostIndex));
   __ Pop(R0);
   __ fstrq(V3, Address(SP, -2 * kWordSize, Address::PreIndex));
   __ PopDouble(V0);
   __ PopDouble(V1);
   __ faddd(V0, V0, V1);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrqFstrqPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fcvtzds, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
   __ fcvtzds(R0, V0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fcvtzds, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Scvtfdx, assembler) {
-  __ LoadImmediate(R0, 42, kNoPP);
+  __ LoadImmediate(R0, 42);
   __ scvtfdx(V0, R0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Scvtfdx, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Scvtfdw, assembler) {
   // Fill upper 32-bits with garbage.
-  __ LoadImmediate(R0, 0x111111110000002A, kNoPP);
+  __ LoadImmediate(R0, 0x111111110000002A);
   __ scvtfdw(V0, R0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Scvtfdw, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FabsdPos, assembler) {
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V1, 42.0);
   __ fabsd(V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FabsdPos, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FabsdNeg, assembler) {
-  __ LoadDImmediate(V1, -42.0, kNoPP);
+  __ LoadDImmediate(V1, -42.0);
   __ fabsd(V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FabsdNeg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FnegdPos, assembler) {
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V1, 42.0);
   __ fnegd(V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FnegdPos, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(-42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FnegdNeg, assembler) {
-  __ LoadDImmediate(V1, -42.0, kNoPP);
+  __ LoadDImmediate(V1, -42.0);
   __ fnegd(V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FnegdNeg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fsqrtd, assembler) {
-  __ LoadDImmediate(V1, 64.0, kNoPP);
+  __ LoadDImmediate(V1, 64.0);
   __ fsqrtd(V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fsqrtd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(8.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fmuld, assembler) {
-  __ LoadDImmediate(V1, 84.0, kNoPP);
-  __ LoadDImmediate(V2, 0.5, kNoPP);
+  __ LoadDImmediate(V1, 84.0);
+  __ LoadDImmediate(V2, 0.5);
   __ fmuld(V0, V1, V2);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fmuld, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fdivd, assembler) {
-  __ LoadDImmediate(V1, 84.0, kNoPP);
-  __ LoadDImmediate(V2, 2.0, kNoPP);
+  __ LoadDImmediate(V1, 84.0);
+  __ LoadDImmediate(V2, 2.0);
   __ fdivd(V0, V1, V2);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fdivd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Faddd, assembler) {
-  __ LoadDImmediate(V1, 41.5, kNoPP);
-  __ LoadDImmediate(V2, 0.5, kNoPP);
+  __ LoadDImmediate(V1, 41.5);
+  __ LoadDImmediate(V2, 0.5);
   __ faddd(V0, V1, V2);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Faddd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Fsubd, assembler) {
-  __ LoadDImmediate(V1, 42.5, kNoPP);
-  __ LoadDImmediate(V2, 0.5, kNoPP);
+  __ LoadDImmediate(V1, 42.5);
+  __ LoadDImmediate(V2, 0.5);
   __ fsubd(V0, V1, V2);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Fsubd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdHeapTag, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 43.0, kNoPP);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
-  __ AddImmediate(SP, SP, -1 * kWordSize, kNoPP);
+  __ LoadDImmediate(V0, 43.0);
+  __ LoadDImmediate(V1, 42.0);
+  __ AddImmediate(SP, SP, -1 * kWordSize);
   __ add(R2, SP, Operand(1));
   __ fstrd(V1, Address(R2, -1));
   __ fldrd(V0, Address(R2, -1));
-  __ AddImmediate(SP, SP, 1 * kWordSize, kNoPP);
+  __ AddImmediate(SP, SP, 1 * kWordSize);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdHeapTag, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeIndex, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 43.0, kNoPP);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 43.0);
+  __ LoadDImmediate(V1, 42.0);
   // Largest negative offset that can fit in the signed 9-bit immediate field.
   __ fstrd(V1, Address(SP, -32*kWordSize, Address::PreIndex));
   // Largest positive kWordSize aligned offset that we can fit.
   __ fldrd(V0, Address(SP, 31*kWordSize, Address::PostIndex));
   // Correction.
   __ add(SP, SP, Operand(kWordSize));  // Restore SP.
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdLargeIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeOffset, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 43.0, kNoPP);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 43.0);
+  __ LoadDImmediate(V1, 42.0);
   __ sub(SP, SP, Operand(512*kWordSize));
   __ fstrd(V1, Address(SP, 512*kWordSize, Address::Offset));
   __ add(SP, SP, Operand(512*kWordSize));
   __ fldrd(V0, Address(SP));
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdLargeOffset, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdExtReg, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 43.0, kNoPP);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 43.0);
+  __ LoadDImmediate(V1, 42.0);
   __ movz(R2, Immediate(0xfff8), 0);
   __ movk(R2, Immediate(0xffff), 1);  // R2 <- -8 (int32_t).
   // This should sign extend R2, and add to SP to get address,
   // i.e. SP - kWordSize.
   __ fstrd(V1, Address(SP, R2, SXTW));
   __ sub(SP, SP, Operand(kWordSize));
   __ fldrd(V0, Address(SP));
   __ add(SP, SP, Operand(kWordSize));
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdExtReg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdScaledReg, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 43.0, kNoPP);
-  __ LoadDImmediate(V1, 42.0, kNoPP);
+  __ LoadDImmediate(V0, 43.0);
+  __ LoadDImmediate(V1, 42.0);
   __ movz(R2, Immediate(10), 0);
   __ sub(SP, SP, Operand(10*kWordSize));
   // Store V1 into SP + R2 * kWordSize.
   __ fstrd(V1, Address(SP, R2, UXTX, Address::Scaled));
   __ fldrd(V0, Address(SP, R2, UXTX, Address::Scaled));
   __ add(SP, SP, Operand(10*kWordSize));
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdScaledReg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(VinswVmovrs, assembler) {
-  __ LoadImmediate(R0, 42, kNoPP);
-  __ LoadImmediate(R1, 43, kNoPP);
-  __ LoadImmediate(R2, 44, kNoPP);
-  __ LoadImmediate(R3, 45, kNoPP);
+  __ LoadImmediate(R0, 42);
+  __ LoadImmediate(R1, 43);
+  __ LoadImmediate(R2, 44);
+  __ LoadImmediate(R3, 45);
 
   __ vinsw(V0, 0, R0);
   __ vinsw(V0, 1, R1);
   __ vinsw(V0, 2, R2);
   __ vinsw(V0, 3, R3);
 
   __ vmovrs(R4, V0, 0);
   __ vmovrs(R5, V0, 1);
   __ vmovrs(R6, V0, 2);
   __ vmovrs(R7, V0, 3);
 
   __ add(R0, R4, Operand(R5));
   __ add(R0, R0, Operand(R6));
   __ add(R0, R0, Operand(R7));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(VinswVmovrs, test) {
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(174, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(VinsxVmovrd, assembler) {
-  __ LoadImmediate(R0, 42, kNoPP);
-  __ LoadImmediate(R1, 43, kNoPP);
+  __ LoadImmediate(R0, 42);
+  __ LoadImmediate(R1, 43);
 
   __ vinsx(V0, 0, R0);
   __ vinsx(V0, 1, R1);
 
   __ vmovrd(R2, V0, 0);
   __ vmovrd(R3, V0, 1);
 
   __ add(R0, R2, Operand(R3));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(VinsxVmovrd, test) {
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(85, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vnot, assembler) {
-  __ LoadImmediate(R0, 0xfffffffe, kNoPP);
-  __ LoadImmediate(R1, 0xffffffff, kNoPP);
+  __ LoadImmediate(R0, 0xfffffffe);
+  __ LoadImmediate(R1, 0xffffffff);
   __ vinsw(V1, 0, R1);
   __ vinsw(V1, 1, R0);
   __ vinsw(V1, 2, R1);
   __ vinsw(V1, 3, R0);
 
   __ vnot(V0, V1);
 
   __ vmovrs(R2, V0, 0);
   __ vmovrs(R3, V0, 1);
   __ vmovrs(R4, V0, 2);
   __ vmovrs(R5, V0, 3);
   __ add(R0, R2, Operand(R3));
   __ add(R0, R0, Operand(R4));
   __ add(R0, R0, Operand(R5));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vnot, test) {
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vabss, assembler) {
-  __ LoadDImmediate(V1, 21.0, kNoPP);
-  __ LoadDImmediate(V2, -21.0, kNoPP);
+  __ LoadDImmediate(V1, 21.0);
+  __ LoadDImmediate(V2, -21.0);
 
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
 
   __ veor(V3, V3, V3);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 3, V2, 0);
 
   __ vabss(V4, V3);
 
   __ vinss(V5, 0, V4, 1);
   __ vinss(V6, 0, V4, 3);
 
   __ fcvtds(V5, V5);
   __ fcvtds(V6, V6);
 
   __ faddd(V0, V5, V6);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vabss, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vabsd, assembler) {
-  __ LoadDImmediate(V1, 21.0, kNoPP);
-  __ LoadDImmediate(V2, -21.0, kNoPP);
+  __ LoadDImmediate(V1, 21.0);
+  __ LoadDImmediate(V2, -21.0);
 
   __ vinsd(V3, 0, V1, 0);
   __ vinsd(V3, 1, V2, 0);
 
   __ vabsd(V4, V3);
 
   __ vinsd(V5, 0, V4, 0);
   __ vinsd(V6, 0, V4, 1);
 
   __ faddd(V0, V5, V6);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vabsd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vnegs, assembler) {
-  __ LoadDImmediate(V1, 42.0, kNoPP);
-  __ LoadDImmediate(V2, -84.0, kNoPP);
+  __ LoadDImmediate(V1, 42.0);
+  __ LoadDImmediate(V2, -84.0);
 
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
 
   __ veor(V3, V3, V3);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 3, V2, 0);
 
   __ vnegs(V4, V3);
 
   __ vinss(V5, 0, V4, 1);
   __ vinss(V6, 0, V4, 3);
 
   __ fcvtds(V5, V5);
   __ fcvtds(V6, V6);
   __ faddd(V0, V5, V6);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vnegs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vnegd, assembler) {
-  __ LoadDImmediate(V1, 42.0, kNoPP);
-  __ LoadDImmediate(V2, -84.0, kNoPP);
+  __ LoadDImmediate(V1, 42.0);
+  __ LoadDImmediate(V2, -84.0);
 
   __ vinsd(V3, 0, V1, 0);
   __ vinsd(V3, 1, V2, 0);
 
   __ vnegd(V4, V3);
 
   __ vinsd(V5, 0, V4, 0);
   __ vinsd(V6, 0, V4, 1);
 
   __ faddd(V0, V5, V6);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vnegd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vadds, assembler) {
-  __ LoadDImmediate(V0, 0.0, kNoPP);
-  __ LoadDImmediate(V1, 1.0, kNoPP);
-  __ LoadDImmediate(V2, 2.0, kNoPP);
-  __ LoadDImmediate(V3, 3.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
+  __ LoadDImmediate(V1, 1.0);
+  __ LoadDImmediate(V2, 2.0);
+  __ LoadDImmediate(V3, 3.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
   __ fcvtsd(V3, V3);
 
   __ vinss(V4, 0, V0, 0);
   __ vinss(V4, 1, V1, 0);
   __ vinss(V4, 2, V2, 0);
   __ vinss(V4, 3, V3, 0);
@@ skipping 17 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vadds, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(12.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vsubs, assembler) {
-  __ LoadDImmediate(V0, 0.0, kNoPP);
-  __ LoadDImmediate(V1, 1.0, kNoPP);
-  __ LoadDImmediate(V2, 2.0, kNoPP);
-  __ LoadDImmediate(V3, 3.0, kNoPP);
-  __ LoadDImmediate(V5, 0.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
+  __ LoadDImmediate(V1, 1.0);
+  __ LoadDImmediate(V2, 2.0);
+  __ LoadDImmediate(V3, 3.0);
+  __ LoadDImmediate(V5, 0.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
   __ fcvtsd(V3, V3);
 
   __ vinss(V4, 0, V0, 0);
   __ vinss(V4, 1, V1, 0);
   __ vinss(V4, 2, V2, 0);
   __ vinss(V4, 3, V3, 0);
@@ skipping 17 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vsubs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(-6.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vmuls, assembler) {
-  __ LoadDImmediate(V0, 0.0, kNoPP);
-  __ LoadDImmediate(V1, 1.0, kNoPP);
-  __ LoadDImmediate(V2, 2.0, kNoPP);
-  __ LoadDImmediate(V3, 3.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
+  __ LoadDImmediate(V1, 1.0);
+  __ LoadDImmediate(V2, 2.0);
+  __ LoadDImmediate(V3, 3.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
   __ fcvtsd(V3, V3);
 
   __ vinss(V4, 0, V0, 0);
   __ vinss(V4, 1, V1, 0);
   __ vinss(V4, 2, V2, 0);
   __ vinss(V4, 3, V3, 0);
@@ skipping 17 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vmuls, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(14.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vdivs, assembler) {
-  __ LoadDImmediate(V0, 0.0, kNoPP);
-  __ LoadDImmediate(V1, 1.0, kNoPP);
-  __ LoadDImmediate(V2, 2.0, kNoPP);
-  __ LoadDImmediate(V3, 3.0, kNoPP);
+  __ LoadDImmediate(V0, 0.0);
+  __ LoadDImmediate(V1, 1.0);
+  __ LoadDImmediate(V2, 2.0);
+  __ LoadDImmediate(V3, 3.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
   __ fcvtsd(V3, V3);
 
   __ vinss(V4, 0, V0, 0);
   __ vinss(V4, 1, V1, 0);
   __ vinss(V4, 2, V2, 0);
   __ vinss(V4, 3, V3, 0);
@@ skipping 17 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vdivs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(4.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vaddd, assembler) {
-  __ LoadDImmediate(V0, 2.0, kNoPP);
-  __ LoadDImmediate(V1, 3.0, kNoPP);
+  __ LoadDImmediate(V0, 2.0);
+  __ LoadDImmediate(V1, 3.0);
 
   __ vinsd(V4, 0, V0, 0);
   __ vinsd(V4, 1, V1, 0);
 
   __ vaddd(V5, V4, V4);
 
   __ vinsd(V0, 0, V5, 0);
   __ vinsd(V1, 0, V5, 1);
 
   __ faddd(V0, V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vaddd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(10.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vsubd, assembler) {
-  __ LoadDImmediate(V0, 2.0, kNoPP);
-  __ LoadDImmediate(V1, 3.0, kNoPP);
-  __ LoadDImmediate(V5, 0.0, kNoPP);
+  __ LoadDImmediate(V0, 2.0);
+  __ LoadDImmediate(V1, 3.0);
+  __ LoadDImmediate(V5, 0.0);
 
   __ vinsd(V4, 0, V0, 0);
   __ vinsd(V4, 1, V1, 0);
 
   __ vsubd(V5, V5, V4);
 
   __ vinsd(V0, 0, V5, 0);
   __ vinsd(V1, 0, V5, 1);
 
   __ faddd(V0, V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vsubd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(-5.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vmuld, assembler) {
-  __ LoadDImmediate(V0, 2.0, kNoPP);
-  __ LoadDImmediate(V1, 3.0, kNoPP);
+  __ LoadDImmediate(V0, 2.0);
+  __ LoadDImmediate(V1, 3.0);
 
   __ vinsd(V4, 0, V0, 0);
   __ vinsd(V4, 1, V1, 0);
 
   __ vmuld(V5, V4, V4);
 
   __ vinsd(V0, 0, V5, 0);
   __ vinsd(V1, 0, V5, 1);
 
   __ faddd(V0, V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vmuld, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(13.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vdivd, assembler) {
-  __ LoadDImmediate(V0, 2.0, kNoPP);
-  __ LoadDImmediate(V1, 3.0, kNoPP);
+  __ LoadDImmediate(V0, 2.0);
+  __ LoadDImmediate(V1, 3.0);
 
   __ vinsd(V4, 0, V0, 0);
   __ vinsd(V4, 1, V1, 0);
 
   __ vdivd(V5, V4, V4);
 
   __ vinsd(V0, 0, V5, 0);
   __ vinsd(V1, 0, V5, 1);
 
   __ faddd(V0, V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vdivd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(2.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vdupd, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 21.0, kNoPP);
+  __ LoadDImmediate(V0, 21.0);
   __ vdupd(V1, V0, 0);
 
   const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex));
   __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex));
 
   __ faddd(V0, V2, V3);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vdupd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vdups, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 21.0, kNoPP);
+  __ LoadDImmediate(V0, 21.0);
   __ fcvtsd(V0, V0);
   __ vdups(V1, V0, 0);
 
   const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex));
@@ skipping 13 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(Vdups, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(84.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vinsd, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V5, 42.0, kNoPP);
+  __ LoadDImmediate(V5, 42.0);
   __ vinsd(V1, 1, V5, 0);  // V1[1] <- V0[0].
 
   const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex));
   __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex));
 
   __ fmovdd(V0, V3);
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vinsd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vinss, assembler) {
   __ SetupDartSP(kTestStackSpace);
-  __ LoadDImmediate(V0, 21.0, kNoPP);
+  __ LoadDImmediate(V0, 21.0);
   __ fcvtsd(V0, V0);
   __ vinss(V1, 3, V0, 0);
   __ vinss(V1, 1, V0, 0);
 
   const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex));
@@ skipping 13 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vinss, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vand, assembler) {
-  __ LoadDImmediate(V1, 21.0, kNoPP);
-  __ LoadImmediate(R0, 0xffffffff, kNoPP);
+  __ LoadDImmediate(V1, 21.0);
+  __ LoadImmediate(R0, 0xffffffff);
 
   // V0 <- (0, 0xffffffff, 0, 0xffffffff)
   __ fmovdr(V0, R0);
   __ vinss(V0, 2, V0, 0);
 
   // V1 <- (21.0, 21.0, 21.0, 21.0)
   __ fcvtsd(V1, V1);
   __ vdups(V1, V1, 0);
 
   __ vand(V2, V1, V0);
@@ skipping 15 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vand, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vorr, assembler) {
-  __ LoadDImmediate(V1, 10.5, kNoPP);
+  __ LoadDImmediate(V1, 10.5);
   __ fcvtsd(V1, V1);
 
   // V0 <- (0, 10.5, 0, 10.5)
   __ fmovdd(V0, V1);
   __ vinss(V0, 2, V0, 0);
 
   // V1 <- (10.5, 0, 10.5, 0)
   __ veor(V1, V1, V1);
   __ vinss(V1, 1, V0, 0);
   __ vinss(V1, 3, V0, 0);
@@ skipping 17 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vorr, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Veor, assembler) {
-  __ LoadImmediate(R1, 0xffffffff, kNoPP);
-  __ LoadImmediate(R2, ~21, kNoPP);
+  __ LoadImmediate(R1, 0xffffffff);
+  __ LoadImmediate(R2, ~21);
 
   __ vinsw(V1, 0, R1);
   __ vinsw(V1, 1, R2);
   __ vinsw(V1, 2, R1);
   __ vinsw(V1, 3, R2);
 
   __ vinsw(V2, 0, R1);
   __ vinsw(V2, 1, R1);
   __ vinsw(V2, 2, R1);
   __ vinsw(V2, 3, R1);
@@ skipping 12 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Veor, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vaddw, assembler) {
-  __ LoadImmediate(R4, 21, kNoPP);
+  __ LoadImmediate(R4, 21);
 
   __ vdupw(V1, R4);
   __ vdupw(V2, R4);
 
   __ vaddw(V0, V1, V2);
 
   __ vmovrs(R0, V0, 0);
   __ vmovrs(R1, V0, 1);
   __ vmovrs(R2, V0, 2);
   __ vmovrs(R3, V0, 3);
   __ add(R0, R0, Operand(R1));
   __ add(R0, R0, Operand(R2));
   __ add(R0, R0, Operand(R3));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vaddw, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(168, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vsubw, assembler) {
-  __ LoadImmediate(R4, 31, kNoPP);
-  __ LoadImmediate(R5, 10, kNoPP);
+  __ LoadImmediate(R4, 31);
+  __ LoadImmediate(R5, 10);
 
   __ vdupw(V1, R4);
   __ vdupw(V2, R5);
 
   __ vsubw(V0, V1, V2);
 
   __ vmovrs(R0, V0, 0);
   __ vmovrs(R1, V0, 1);
   __ vmovrs(R2, V0, 2);
   __ vmovrs(R3, V0, 3);
   __ add(R0, R0, Operand(R1));
   __ add(R0, R0, Operand(R2));
   __ add(R0, R0, Operand(R3));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vsubw, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vaddx, assembler) {
-  __ LoadImmediate(R4, 21, kNoPP);
+  __ LoadImmediate(R4, 21);
 
   __ vdupx(V1, R4);
   __ vdupx(V2, R4);
 
   __ vaddx(V0, V1, V2);
 
   __ vmovrd(R0, V0, 0);
   __ vmovrd(R1, V0, 1);
   __ add(R0, R0, Operand(R1));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vaddx, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vsubx, assembler) {
-  __ LoadImmediate(R4, 31, kNoPP);
-  __ LoadImmediate(R5, 10, kNoPP);
+  __ LoadImmediate(R4, 31);
+  __ LoadImmediate(R5, 10);
 
   __ vdupx(V1, R4);
   __ vdupx(V2, R5);
 
   __ vsubx(V0, V1, V2);
 
   __ vmovrd(R0, V0, 0);
   __ vmovrd(R1, V0, 1);
   __ add(R0, R0, Operand(R1));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vsubx, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vceqs, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, -42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, -42.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
 
   __ vdups(V2, V0, 0);
   __ vinss(V3, 0, V0, 0);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 2, V0, 0);
   __ vinss(V3, 3, V1, 0);
 
@@ skipping 11 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vceqs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vceqd, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, -42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, -42.0);
 
   __ vdupd(V2, V0, 0);
   __ vinsd(V3, 0, V0, 0);
   __ vinsd(V3, 1, V1, 0);
 
   __ vceqd(V4, V2, V3);
 
   __ vmovrd(R1, V4, 0);
   __ vmovrd(R2, V4, 1);
 
   __ add(R0, R1, Operand(R2));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vceqd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vcgts, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, -42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, -42.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
 
   __ vdups(V2, V0, 0);
   __ vinss(V3, 0, V0, 0);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 2, V0, 0);
   __ vinss(V3, 3, V1, 0);
 
@@ skipping 11 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vcgts, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vcgtd, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, -42.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, -42.0);
 
   __ vdupd(V2, V0, 0);
   __ vinsd(V3, 0, V0, 0);
   __ vinsd(V3, 1, V1, 0);
 
   __ vcgtd(V4, V2, V3);
 
   __ vmovrd(R1, V4, 0);
   __ vmovrd(R2, V4, 1);
 
   __ add(R0, R1, Operand(R2));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vcgtd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vcges, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, 43.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, 43.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
 
   __ vdups(V2, V0, 0);
   __ vinss(V3, 0, V0, 0);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 2, V0, 0);
   __ vinss(V3, 3, V1, 0);
 
@@ skipping 11 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vcges, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vcged, assembler) {
-  __ LoadDImmediate(V0, 42.0, kNoPP);
-  __ LoadDImmediate(V1, 43.0, kNoPP);
+  __ LoadDImmediate(V0, 42.0);
+  __ LoadDImmediate(V1, 43.0);
 
   __ vdupd(V2, V0, 0);
   __ vinsd(V3, 0, V0, 0);
   __ vinsd(V3, 1, V1, 0);
 
   __ vcged(V4, V2, V3);
 
   __ vmovrd(R1, V4, 0);
   __ vmovrd(R2, V4, 1);
 
   __ add(R0, R1, Operand(R2));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vcged, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vmaxs, assembler) {
-  __ LoadDImmediate(V0, 10.5, kNoPP);
-  __ LoadDImmediate(V1, 10.0, kNoPP);
+  __ LoadDImmediate(V0, 10.5);
+  __ LoadDImmediate(V1, 10.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
 
   __ vdups(V2, V0, 0);
   __ vinss(V3, 0, V0, 0);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 2, V0, 0);
   __ vinss(V3, 3, V1, 0);
 
@@ skipping 16 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vmaxs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vmaxd, assembler) {
-  __ LoadDImmediate(V0, 21.0, kNoPP);
-  __ LoadDImmediate(V1, 20.5, kNoPP);
+  __ LoadDImmediate(V0, 21.0);
+  __ LoadDImmediate(V1, 20.5);
 
   __ vdupd(V2, V0, 0);
   __ vinsd(V3, 0, V0, 0);
   __ vinsd(V3, 1, V1, 0);
 
   __ vmaxd(V4, V2, V3);
 
   __ vinsd(V0, 0, V4, 0);
   __ vinsd(V1, 0, V4, 1);
 
   __ faddd(V0, V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vmaxd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vmins, assembler) {
-  __ LoadDImmediate(V0, 10.5, kNoPP);
-  __ LoadDImmediate(V1, 11.0, kNoPP);
+  __ LoadDImmediate(V0, 10.5);
+  __ LoadDImmediate(V1, 11.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
 
   __ vdups(V2, V0, 0);
   __ vinss(V3, 0, V0, 0);
   __ vinss(V3, 1, V1, 0);
   __ vinss(V3, 2, V0, 0);
   __ vinss(V3, 3, V1, 0);
 
@@ skipping 16 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vmins, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vmind, assembler) {
-  __ LoadDImmediate(V0, 21.0, kNoPP);
-  __ LoadDImmediate(V1, 21.5, kNoPP);
+  __ LoadDImmediate(V0, 21.0);
+  __ LoadDImmediate(V1, 21.5);
 
   __ vdupd(V2, V0, 0);
   __ vinsd(V3, 0, V0, 0);
   __ vinsd(V3, 1, V1, 0);
 
   __ vmind(V4, V2, V3);
 
   __ vinsd(V0, 0, V4, 0);
   __ vinsd(V1, 0, V4, 1);
 
   __ faddd(V0, V0, V1);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vmind, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vsqrts, assembler) {
-  __ LoadDImmediate(V0, 64.0, kNoPP);
-  __ LoadDImmediate(V1, 49.0, kNoPP);
+  __ LoadDImmediate(V0, 64.0);
+  __ LoadDImmediate(V1, 49.0);
 
   __ fcvtsd(V0, V0);
   __ fcvtsd(V1, V1);
 
   __ veor(V3, V3, V3);
   __ vinss(V3, 1, V0, 0);
   __ vinss(V3, 3, V1, 0);
 
   __ vsqrts(V4, V3);
 
   __ vinss(V5, 0, V4, 1);
   __ vinss(V6, 0, V4, 3);
 
   __ fcvtds(V5, V5);
   __ fcvtds(V6, V6);
 
   __ faddd(V0, V5, V6);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vsqrts, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vsqrtd, assembler) {
-  __ LoadDImmediate(V0, 64.0, kNoPP);
-  __ LoadDImmediate(V1, 49.0, kNoPP);
+  __ LoadDImmediate(V0, 64.0);
+  __ LoadDImmediate(V1, 49.0);
 
   __ vinsd(V3, 0, V0, 0);
   __ vinsd(V3, 1, V1, 0);
 
   __ vsqrtd(V4, V3);
 
   __ vinsd(V5, 0, V4, 0);
   __ vinsd(V6, 0, V4, 1);
 
   __ faddd(V0, V5, V6);
@@ skipping 36 matching lines @@
 
   // result = sign : result_exp<7:0> : estimate<51:29>
   int32_t result_bits =
       (a_bits & 0x80000000) | ((result_exp & 0xff) << 23) |
       ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff);
   return bit_cast<float, int32_t>(result_bits);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vrecpes, assembler) {
-  __ LoadDImmediate(V1, 147.0, kNoPP);
+  __ LoadDImmediate(V1, 147.0);
   __ fcvtsd(V1, V1);
   __ vinss(V2, 0, V1, 0);
   __ vinss(V2, 1, V1, 0);
   __ vinss(V2, 2, V1, 0);
   __ vinss(V2, 3, V1, 0);
   __ vrecpes(V0, V2);
   __ fcvtds(V0, V0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vrecpes, test) {
   EXPECT(test != NULL);
   typedef double (*DoubleReturn)() DART_UNUSED;
   float res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(arm_recip_estimate(147.0), res, 0.0001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vrecpss, assembler) {
-  __ LoadDImmediate(V1, 5.0, kNoPP);
-  __ LoadDImmediate(V2, 10.0, kNoPP);
+  __ LoadDImmediate(V1, 5.0);
+  __ LoadDImmediate(V2, 10.0);
 
   __ fcvtsd(V1, V1);
   __ fcvtsd(V2, V2);
 
   __ vrecpss(V0, V1, V2);
 
   __ fcvtds(V0, V0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vrecpss, test) {
   EXPECT(test != NULL);
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(2.0 - 10.0 * 5.0, res, 0.0001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(VRecps, assembler) {
-  __ LoadDImmediate(V0, 1.0 / 10.5, kNoPP);
+  __ LoadDImmediate(V0, 1.0 / 10.5);
   __ fcvtsd(V0, V0);
 
   __ vdups(V1, V0, 0);
 
   __ VRecps(V2, V1);
 
   __ vinss(V0, 0, V2, 0);
   __ vinss(V1, 0, V2, 1);
   __ vinss(V2, 0, V2, 2);
   __ vinss(V3, 0, V2, 3);
@@ skipping 62 matching lines @@
   ASSERT((estimate >= 1.0) && (estimate <= (511.0/256.0)));
 
   // result = 0 : result_exp<7:0> : estimate<51:29>
   int32_t result_bits = ((result_exp & 0xff) << 23) |
       ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff);
   return bit_cast<float, int32_t>(result_bits);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vrsqrtes, assembler) {
-  __ LoadDImmediate(V1, 147.0, kNoPP);
+  __ LoadDImmediate(V1, 147.0);
   __ fcvtsd(V1, V1);
 
   __ vrsqrtes(V0, V1);
 
   __ fcvtds(V0, V0);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vrsqrtes, test) {
   EXPECT(test != NULL);
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(arm_reciprocal_sqrt_estimate(147.0), res, 0.0001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vrsqrtss, assembler) {
-    __ LoadDImmediate(V1, 5.0, kNoPP);
-    __ LoadDImmediate(V2, 10.0, kNoPP);
+    __ LoadDImmediate(V1, 5.0);
+    __ LoadDImmediate(V2, 10.0);
 
     __ fcvtsd(V1, V1);
     __ fcvtsd(V2, V2);
 
     __ vrsqrtss(V0, V1, V2);
 
     __ fcvtds(V0, V0);
     __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vrsqrtss, test) {
   EXPECT(test != NULL);
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ((3.0 - 10.0 * 5.0)/2.0, res, 0.0001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(ReciprocalSqrt, assembler) {
-    __ LoadDImmediate(V1, 147000.0, kNoPP);
+    __ LoadDImmediate(V1, 147000.0);
     __ fcvtsd(V1, V1);
 
     __ VRSqrts(V0, V1);
 
     __ fcvtds(V0, V0);
     __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ReciprocalSqrt, test) {
   EXPECT(test != NULL);
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(1.0/sqrt(147000.0), res, 0.0001);
 }
 
 
 // Called from assembler_test.cc.
 // LR: return address.
 // R0: context.
 // R1: value.
 // R2: growable array.
 // R3: current thread.
 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ TagAndPushPP();
-  __ LoadPoolPointer(PP);
+  __ LoadPoolPointer();
   __ Push(THR);
   __ Push(CTX);
   __ Push(LR);
   __ mov(CTX, R0);
   __ mov(THR, R3);
   __ StoreIntoObject(R2,
                      FieldAddress(R2, GrowableObjectArray::data_offset()),
                      R1);
   __ Pop(LR);
   __ Pop(CTX);
   __ Pop(THR);
   __ PopAndUntagPP();
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_GENERATE(ComputeRange, assembler) {
   __ SetupDartSP(kTestStackSpace);
   __ TagAndPushPP();
-  __ LoadPoolPointer(PP);
+  __ LoadPoolPointer();
   Label miss, done;
   __ mov(R1, R0);
   __ ComputeRange(R0, R1, R2, &miss);
   __ b(&done);
 
   __ Bind(&miss);
-  __ LoadImmediate(R0, -1, kNoPP);
+  __ LoadImmediate(R0, -1);
 
   __ Bind(&done);
   __ PopAndUntagPP();
   __ mov(CSP, SP);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ComputeRange, test) {
   typedef intptr_t (*ComputeRange)(intptr_t value) DART_UNUSED;
@@ skipping 32 matching lines @@
 
   EXPECT_EQ(-1, RANGE_OF(Bool::True().raw()));
 
 #undef RANGE_OF
 }
 
 
 }  // namespace dart
 
 #endif  // defined(TARGET_ARCH_ARM64)