[arm64] Don't use x18 (platform register) in assembler tests

This fixes the assembler tests on Windows arm64, that were previously crashing.

Bug: v8:9235
Change-Id: I616e6eb00bb71d70195787f80f8b54a9ae33abe6
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1634919
Commit-Queue: Martyn Capewell <martyn.capewell@arm.com>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61981}

test/cctest/test-assembler-arm64.cc

@@ -370,7 +370,7 @@ TEST(mov) {
   __ Mov(w13, Operand(w11, LSL, 1));
   __ Mov(x14, Operand(x12, LSL, 2));
   __ Mov(w15, Operand(w11, LSR, 3));
-  __ Mov(x18, Operand(x12, LSR, 4));
+  __ Mov(x28, Operand(x12, LSR, 4));
   __ Mov(w19, Operand(w11, ASR, 11));
   __ Mov(x20, Operand(x12, ASR, 12));
   __ Mov(w21, Operand(w11, ROR, 13));
@@ -399,7 +399,7 @@ TEST(mov) {
   CHECK_EQUAL_64(0x00001FFE, x13);
   CHECK_EQUAL_64(0x0000000000003FFCUL, x14);
   CHECK_EQUAL_64(0x000001FF, x15);
-  CHECK_EQUAL_64(0x00000000000000FFUL, x18);
+  CHECK_EQUAL_64(0x00000000000000FFUL, x28);
   CHECK_EQUAL_64(0x00000001, x19);
   CHECK_EQUAL_64(0x0, x20);
   CHECK_EQUAL_64(0x7FF80000, x21);
@@ -517,7 +517,7 @@ TEST(mov_imm_x) {
   __ Mov(x13, 0x0000000000001234L);
   __ Mov(x14, 0x0000000012345678L);
   __ Mov(x15, 0x0000123400005678L);
-  __ Mov(x18, 0x1234000000005678L);
+  __ Mov(x30, 0x1234000000005678L);
   __ Mov(x19, 0x1234000056780000L);
   __ Mov(x20, 0x1234567800000000L);
   __ Mov(x21, 0x1234000000000000L);
@@ -547,7 +547,7 @@ TEST(mov_imm_x) {
   CHECK_EQUAL_64(0x0000000000001234L, x13);
   CHECK_EQUAL_64(0x0000000012345678L, x14);
   CHECK_EQUAL_64(0x0000123400005678L, x15);
-  CHECK_EQUAL_64(0x1234000000005678L, x18);
+  CHECK_EQUAL_64(0x1234000000005678L, x30);
   CHECK_EQUAL_64(0x1234000056780000L, x19);
   CHECK_EQUAL_64(0x1234567800000000L, x20);
   CHECK_EQUAL_64(0x1234000000000000L, x21);
@@ -1095,27 +1095,27 @@ TEST(mul) {
   START();
   __ Mov(x16, 0);
   __ Mov(x17, 1);
-  __ Mov(x18, 0xFFFFFFFF);
+  __ Mov(x15, 0xFFFFFFFF);
   __ Mov(x19, 0xFFFFFFFFFFFFFFFFUL);
 
   __ Mul(w0, w16, w16);
   __ Mul(w1, w16, w17);
-  __ Mul(w2, w17, w18);
-  __ Mul(w3, w18, w19);
+  __ Mul(w2, w17, w15);
+  __ Mul(w3, w15, w19);
   __ Mul(x4, x16, x16);
-  __ Mul(x5, x17, x18);
-  __ Mul(x6, x18, x19);
+  __ Mul(x5, x17, x15);
+  __ Mul(x6, x15, x19);
   __ Mul(x7, x19, x19);
-  __ Smull(x8, w17, w18);
-  __ Smull(x9, w18, w18);
+  __ Smull(x8, w17, w15);
+  __ Smull(x9, w15, w15);
   __ Smull(x10, w19, w19);
   __ Mneg(w11, w16, w16);
   __ Mneg(w12, w16, w17);
-  __ Mneg(w13, w17, w18);
-  __ Mneg(w14, w18, w19);
+  __ Mneg(w13, w17, w15);
+  __ Mneg(w14, w15, w19);
   __ Mneg(x20, x16, x16);
-  __ Mneg(x21, x17, x18);
-  __ Mneg(x22, x18, x19);
+  __ Mneg(x21, x17, x15);
+  __ Mneg(x22, x15, x19);
   __ Mneg(x23, x19, x19);
   END();
 
@@ -1170,33 +1170,33 @@ TEST(madd) {
   START();
   __ Mov(x16, 0);
   __ Mov(x17, 1);
-  __ Mov(x18, 0xFFFFFFFF);
+  __ Mov(x28, 0xFFFFFFFF);
   __ Mov(x19, 0xFFFFFFFFFFFFFFFFUL);
 
   __ Madd(w0, w16, w16, w16);
   __ Madd(w1, w16, w16, w17);
-  __ Madd(w2, w16, w16, w18);
+  __ Madd(w2, w16, w16, w28);
   __ Madd(w3, w16, w16, w19);
   __ Madd(w4, w16, w17, w17);
-  __ Madd(w5, w17, w17, w18);
+  __ Madd(w5, w17, w17, w28);
   __ Madd(w6, w17, w17, w19);
-  __ Madd(w7, w17, w18, w16);
-  __ Madd(w8, w17, w18, w18);
-  __ Madd(w9, w18, w18, w17);
-  __ Madd(w10, w18, w19, w18);
+  __ Madd(w7, w17, w28, w16);
+  __ Madd(w8, w17, w28, w28);
+  __ Madd(w9, w28, w28, w17);
+  __ Madd(w10, w28, w19, w28);
   __ Madd(w11, w19, w19, w19);
 
   __ Madd(x12, x16, x16, x16);
   __ Madd(x13, x16, x16, x17);
-  __ Madd(x14, x16, x16, x18);
+  __ Madd(x14, x16, x16, x28);
   __ Madd(x15, x16, x16, x19);
   __ Madd(x20, x16, x17, x17);
-  __ Madd(x21, x17, x17, x18);
+  __ Madd(x21, x17, x17, x28);
   __ Madd(x22, x17, x17, x19);
-  __ Madd(x23, x17, x18, x16);
-  __ Madd(x24, x17, x18, x18);
-  __ Madd(x25, x18, x18, x17);
-  __ Madd(x26, x18, x19, x18);
+  __ Madd(x23, x17, x28, x16);
+  __ Madd(x24, x17, x28, x28);
+  __ Madd(x25, x28, x28, x17);
+  __ Madd(x26, x28, x19, x28);
   __ Madd(x27, x19, x19, x19);
 
   END();
@@ -1237,33 +1237,33 @@ TEST(msub) {
   START();
   __ Mov(x16, 0);
   __ Mov(x17, 1);
-  __ Mov(x18, 0xFFFFFFFF);
+  __ Mov(x28, 0xFFFFFFFF);
   __ Mov(x19, 0xFFFFFFFFFFFFFFFFUL);
 
   __ Msub(w0, w16, w16, w16);
   __ Msub(w1, w16, w16, w17);
-  __ Msub(w2, w16, w16, w18);
+  __ Msub(w2, w16, w16, w28);
   __ Msub(w3, w16, w16, w19);
   __ Msub(w4, w16, w17, w17);
-  __ Msub(w5, w17, w17, w18);
+  __ Msub(w5, w17, w17, w28);
   __ Msub(w6, w17, w17, w19);
-  __ Msub(w7, w17, w18, w16);
-  __ Msub(w8, w17, w18, w18);
-  __ Msub(w9, w18, w18, w17);
-  __ Msub(w10, w18, w19, w18);
+  __ Msub(w7, w17, w28, w16);
+  __ Msub(w8, w17, w28, w28);
+  __ Msub(w9, w28, w28, w17);
+  __ Msub(w10, w28, w19, w28);
   __ Msub(w11, w19, w19, w19);
 
   __ Msub(x12, x16, x16, x16);
   __ Msub(x13, x16, x16, x17);
-  __ Msub(x14, x16, x16, x18);
+  __ Msub(x14, x16, x16, x28);
   __ Msub(x15, x16, x16, x19);
   __ Msub(x20, x16, x17, x17);
-  __ Msub(x21, x17, x17, x18);
+  __ Msub(x21, x17, x17, x28);
   __ Msub(x22, x17, x17, x19);
-  __ Msub(x23, x17, x18, x16);
-  __ Msub(x24, x17, x18, x18);
-  __ Msub(x25, x18, x18, x17);
-  __ Msub(x26, x18, x19, x18);
+  __ Msub(x23, x17, x28, x16);
+  __ Msub(x24, x17, x28, x28);
+  __ Msub(x25, x28, x28, x17);
+  __ Msub(x26, x28, x19, x28);
   __ Msub(x27, x19, x19, x19);
 
   END();
@@ -1349,17 +1349,17 @@ TEST(smaddl_umaddl) {
 
   START();
   __ Mov(x17, 1);
-  __ Mov(x18, 0xFFFFFFFF);
+  __ Mov(x28, 0xFFFFFFFF);
   __ Mov(x19, 0xFFFFFFFFFFFFFFFFUL);
   __ Mov(x20, 4);
   __ Mov(x21, 0x200000000UL);
 
-  __ Smaddl(x9, w17, w18, x20);
-  __ Smaddl(x10, w18, w18, x20);
+  __ Smaddl(x9, w17, w28, x20);
+  __ Smaddl(x10, w28, w28, x20);
   __ Smaddl(x11, w19, w19, x20);
   __ Smaddl(x12, w19, w19, x21);
-  __ Umaddl(x13, w17, w18, x20);
-  __ Umaddl(x14, w18, w18, x20);
+  __ Umaddl(x13, w17, w28, x20);
+  __ Umaddl(x14, w28, w28, x20);
   __ Umaddl(x15, w19, w19, x20);
   __ Umaddl(x22, w19, w19, x21);
   END();
@@ -1382,17 +1382,17 @@ TEST(smsubl_umsubl) {
 
   START();
   __ Mov(x17, 1);
-  __ Mov(x18, 0xFFFFFFFF);
+  __ Mov(x28, 0xFFFFFFFF);
   __ Mov(x19, 0xFFFFFFFFFFFFFFFFUL);
   __ Mov(x20, 4);
   __ Mov(x21, 0x200000000UL);
 
-  __ Smsubl(x9, w17, w18, x20);
-  __ Smsubl(x10, w18, w18, x20);
+  __ Smsubl(x9, w17, w28, x20);
+  __ Smsubl(x10, w28, w28, x20);
   __ Smsubl(x11, w19, w19, x20);
   __ Smsubl(x12, w19, w19, x21);
-  __ Umsubl(x13, w17, w18, x20);
-  __ Umsubl(x14, w18, w18, x20);
+  __ Umsubl(x13, w17, w28, x20);
+  __ Umsubl(x14, w28, w28, x20);
   __ Umsubl(x15, w19, w19, x20);
   __ Umsubl(x22, w19, w19, x21);
   END();
@@ -1416,7 +1416,7 @@ TEST(div) {
   START();
   __ Mov(x16, 1);
   __ Mov(x17, 0xFFFFFFFF);
-  __ Mov(x18, 0xFFFFFFFFFFFFFFFFUL);
+  __ Mov(x30, 0xFFFFFFFFFFFFFFFFUL);
   __ Mov(x19, 0x80000000);
   __ Mov(x20, 0x8000000000000000UL);
   __ Mov(x21, 2);
@@ -1425,13 +1425,13 @@ TEST(div) {
   __ Udiv(w1, w17, w16);
   __ Sdiv(w2, w16, w16);
   __ Sdiv(w3, w16, w17);
-  __ Sdiv(w4, w17, w18);
+  __ Sdiv(w4, w17, w30);
 
   __ Udiv(x5, x16, x16);
-  __ Udiv(x6, x17, x18);
+  __ Udiv(x6, x17, x30);
   __ Sdiv(x7, x16, x16);
   __ Sdiv(x8, x16, x17);
-  __ Sdiv(x9, x17, x18);
+  __ Sdiv(x9, x17, x30);
 
   __ Udiv(w10, w19, w21);
   __ Sdiv(w11, w19, w21);
@@ -1442,16 +1442,16 @@ TEST(div) {
 
   __ Udiv(w22, w19, w17);
   __ Sdiv(w23, w19, w17);
-  __ Udiv(x24, x20, x18);
-  __ Sdiv(x25, x20, x18);
+  __ Udiv(x24, x20, x30);
+  __ Sdiv(x25, x20, x30);
 
   __ Udiv(x26, x16, x21);
   __ Sdiv(x27, x16, x21);
-  __ Udiv(x28, x18, x21);
-  __ Sdiv(x29, x18, x21);
+  __ Udiv(x28, x30, x21);
+  __ Sdiv(x29, x30, x21);
 
   __ Mov(x17, 0);
-  __ Udiv(w18, w16, w17);
+  __ Udiv(w30, w16, w17);
   __ Sdiv(w19, w16, w17);
   __ Udiv(x20, x16, x17);
   __ Sdiv(x21, x16, x17);
@@ -1483,7 +1483,7 @@ TEST(div) {
   CHECK_EQUAL_64(0, x27);
   CHECK_EQUAL_64(0x7FFFFFFFFFFFFFFFUL, x28);
   CHECK_EQUAL_64(0, x29);
-  CHECK_EQUAL_64(0, x18);
+  CHECK_EQUAL_64(0, x30);
   CHECK_EQUAL_64(0, x19);
   CHECK_EQUAL_64(0, x20);
   CHECK_EQUAL_64(0, x21);
@@ -1899,17 +1899,17 @@ TEST(compare_branch) {
   __ Mov(x3, 1);
   __ Bind(&nzf_end);
 
-  __ Mov(x18, 0xFFFFFFFF00000000UL);
+  __ Mov(x19, 0xFFFFFFFF00000000UL);
 
   Label a, a_end;
-  __ Cbz(w18, &a);
+  __ Cbz(w19, &a);
   __ B(&a_end);
   __ Bind(&a);
   __ Mov(x4, 1);
   __ Bind(&a_end);
 
   Label b, b_end;
-  __ Cbnz(w18, &b);
+  __ Cbnz(w19, &b);
   __ B(&b_end);
   __ Bind(&b);
   __ Mov(x5, 1);
@@ -2357,17 +2357,17 @@ TEST(ldr_str_offset) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x19, dst_base);
   __ Ldr(w0, MemOperand(x17));
-  __ Str(w0, MemOperand(x18));
+  __ Str(w0, MemOperand(x19));
   __ Ldr(w1, MemOperand(x17, 4));
-  __ Str(w1, MemOperand(x18, 12));
+  __ Str(w1, MemOperand(x19, 12));
   __ Ldr(x2, MemOperand(x17, 8));
-  __ Str(x2, MemOperand(x18, 16));
+  __ Str(x2, MemOperand(x19, 16));
   __ Ldrb(w3, MemOperand(x17, 1));
-  __ Strb(w3, MemOperand(x18, 25));
+  __ Strb(w3, MemOperand(x19, 25));
   __ Ldrh(w4, MemOperand(x17, 2));
-  __ Strh(w4, MemOperand(x18, 33));
+  __ Strh(w4, MemOperand(x19, 33));
   END();
 
   RUN();
@@ -2383,7 +2383,7 @@ TEST(ldr_str_offset) {
   CHECK_EQUAL_64(0x7654, x4);
   CHECK_EQUAL_64(0x765400, dst[4]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base, x18);
+  CHECK_EQUAL_64(dst_base, x19);
 }
 
 TEST(ldr_str_wide) {
@@ -2443,7 +2443,7 @@ TEST(ldr_str_preindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base);
   __ Mov(x20, dst_base);
   __ Mov(x21, src_base + 16);
@@ -2453,7 +2453,7 @@ TEST(ldr_str_preindex) {
   __ Mov(x25, src_base);
   __ Mov(x26, dst_base);
   __ Ldr(w0, MemOperand(x17, 4, PreIndex));
-  __ Str(w0, MemOperand(x18, 12, PreIndex));
+  __ Str(w0, MemOperand(x28, 12, PreIndex));
   __ Ldr(x1, MemOperand(x19, 8, PreIndex));
   __ Str(x1, MemOperand(x20, 16, PreIndex));
   __ Ldr(w2, MemOperand(x21, -4, PreIndex));
@@ -2477,7 +2477,7 @@ TEST(ldr_str_preindex) {
   CHECK_EQUAL_64(0x9876, x4);
   CHECK_EQUAL_64(0x987600, dst[5]);
   CHECK_EQUAL_64(src_base + 4, x17);
-  CHECK_EQUAL_64(dst_base + 12, x18);
+  CHECK_EQUAL_64(dst_base + 12, x28);
   CHECK_EQUAL_64(src_base + 8, x19);
   CHECK_EQUAL_64(dst_base + 16, x20);
   CHECK_EQUAL_64(src_base + 12, x21);
@@ -2499,7 +2499,7 @@ TEST(ldr_str_postindex) {
 
   START();
   __ Mov(x17, src_base + 4);
-  __ Mov(x18, dst_base + 12);
+  __ Mov(x28, dst_base + 12);
   __ Mov(x19, src_base + 8);
   __ Mov(x20, dst_base + 16);
   __ Mov(x21, src_base + 8);
@@ -2509,7 +2509,7 @@ TEST(ldr_str_postindex) {
   __ Mov(x25, src_base + 3);
   __ Mov(x26, dst_base + 41);
   __ Ldr(w0, MemOperand(x17, 4, PostIndex));
-  __ Str(w0, MemOperand(x18, 12, PostIndex));
+  __ Str(w0, MemOperand(x28, 12, PostIndex));
   __ Ldr(x1, MemOperand(x19, 8, PostIndex));
   __ Str(x1, MemOperand(x20, 16, PostIndex));
   __ Ldr(x2, MemOperand(x21, -8, PostIndex));
@@ -2533,7 +2533,7 @@ TEST(ldr_str_postindex) {
   CHECK_EQUAL_64(0x9876, x4);
   CHECK_EQUAL_64(0x987600, dst[5]);
   CHECK_EQUAL_64(src_base + 8, x17);
-  CHECK_EQUAL_64(dst_base + 24, x18);
+  CHECK_EQUAL_64(dst_base + 24, x28);
   CHECK_EQUAL_64(src_base + 16, x19);
   CHECK_EQUAL_64(dst_base + 32, x20);
   CHECK_EQUAL_64(src_base, x21);
@@ -2591,7 +2591,7 @@ TEST(load_store_regoffset) {
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
-  __ Mov(x18, src_base + 3 * sizeof(src[0]));
+  __ Mov(x21, src_base + 3 * sizeof(src[0]));
   __ Mov(x19, dst_base + 3 * sizeof(dst[0]));
   __ Mov(x20, dst_base + 4 * sizeof(dst[0]));
   __ Mov(x24, 0);
@@ -2603,9 +2603,9 @@ TEST(load_store_regoffset) {
 
   __ Ldr(w0, MemOperand(x16, x24));
   __ Ldr(x1, MemOperand(x16, x25));
-  __ Ldr(w2, MemOperand(x18, x26));
-  __ Ldr(w3, MemOperand(x18, x27, SXTW));
-  __ Ldr(w4, MemOperand(x18, x28, SXTW, 2));
+  __ Ldr(w2, MemOperand(x21, x26));
+  __ Ldr(w3, MemOperand(x21, x27, SXTW));
+  __ Ldr(w4, MemOperand(x21, x28, SXTW, 2));
   __ Str(w0, MemOperand(x17, x24));
   __ Str(x1, MemOperand(x17, x25));
   __ Str(w2, MemOperand(x20, x29, SXTW, 2));
@@ -2635,13 +2635,13 @@ TEST(load_store_float) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base);
   __ Mov(x20, dst_base);
   __ Mov(x21, src_base);
   __ Mov(x22, dst_base);
   __ Ldr(s0, MemOperand(x17, sizeof(src[0])));
-  __ Str(s0, MemOperand(x18, sizeof(dst[0]), PostIndex));
+  __ Str(s0, MemOperand(x28, sizeof(dst[0]), PostIndex));
   __ Ldr(s1, MemOperand(x19, sizeof(src[0]), PostIndex));
   __ Str(s1, MemOperand(x20, 2 * sizeof(dst[0]), PreIndex));
   __ Ldr(s2, MemOperand(x21, 2 * sizeof(src[0]), PreIndex));
@@ -2657,7 +2657,7 @@ TEST(load_store_float) {
   CHECK_EQUAL_FP32(3.0, s2);
   CHECK_EQUAL_FP32(3.0, dst[1]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x18);
+  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x28);
   CHECK_EQUAL_64(src_base + sizeof(src[0]), x19);
   CHECK_EQUAL_64(dst_base + 2 * sizeof(dst[0]), x20);
   CHECK_EQUAL_64(src_base + 2 * sizeof(src[0]), x21);
@@ -2675,13 +2675,13 @@ TEST(load_store_double) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base);
   __ Mov(x20, dst_base);
   __ Mov(x21, src_base);
   __ Mov(x22, dst_base);
   __ Ldr(d0, MemOperand(x17, sizeof(src[0])));
-  __ Str(d0, MemOperand(x18, sizeof(dst[0]), PostIndex));
+  __ Str(d0, MemOperand(x28, sizeof(dst[0]), PostIndex));
   __ Ldr(d1, MemOperand(x19, sizeof(src[0]), PostIndex));
   __ Str(d1, MemOperand(x20, 2 * sizeof(dst[0]), PreIndex));
   __ Ldr(d2, MemOperand(x21, 2 * sizeof(src[0]), PreIndex));
@@ -2697,7 +2697,7 @@ TEST(load_store_double) {
   CHECK_EQUAL_FP64(3.0, d2);
   CHECK_EQUAL_FP64(3.0, dst[1]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x18);
+  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x28);
   CHECK_EQUAL_64(src_base + sizeof(src[0]), x19);
   CHECK_EQUAL_64(dst_base + 2 * sizeof(dst[0]), x20);
   CHECK_EQUAL_64(src_base + 2 * sizeof(src[0]), x21);
@@ -2715,13 +2715,13 @@ TEST(load_store_b) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base);
   __ Mov(x20, dst_base);
   __ Mov(x21, src_base);
   __ Mov(x22, dst_base);
   __ Ldr(b0, MemOperand(x17, sizeof(src[0])));
-  __ Str(b0, MemOperand(x18, sizeof(dst[0]), PostIndex));
+  __ Str(b0, MemOperand(x28, sizeof(dst[0]), PostIndex));
   __ Ldr(b1, MemOperand(x19, sizeof(src[0]), PostIndex));
   __ Str(b1, MemOperand(x20, 2 * sizeof(dst[0]), PreIndex));
   __ Ldr(b2, MemOperand(x21, 2 * sizeof(src[0]), PreIndex));
@@ -2737,7 +2737,7 @@ TEST(load_store_b) {
   CHECK_EQUAL_128(0, 0x34, q2);
   CHECK_EQUAL_64(0x34, dst[1]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x18);
+  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x28);
   CHECK_EQUAL_64(src_base + sizeof(src[0]), x19);
   CHECK_EQUAL_64(dst_base + 2 * sizeof(dst[0]), x20);
   CHECK_EQUAL_64(src_base + 2 * sizeof(src[0]), x21);
@@ -2755,13 +2755,13 @@ TEST(load_store_h) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base);
   __ Mov(x20, dst_base);
   __ Mov(x21, src_base);
   __ Mov(x22, dst_base);
   __ Ldr(h0, MemOperand(x17, sizeof(src[0])));
-  __ Str(h0, MemOperand(x18, sizeof(dst[0]), PostIndex));
+  __ Str(h0, MemOperand(x28, sizeof(dst[0]), PostIndex));
   __ Ldr(h1, MemOperand(x19, sizeof(src[0]), PostIndex));
   __ Str(h1, MemOperand(x20, 2 * sizeof(dst[0]), PreIndex));
   __ Ldr(h2, MemOperand(x21, 2 * sizeof(src[0]), PreIndex));
@@ -2777,7 +2777,7 @@ TEST(load_store_h) {
   CHECK_EQUAL_128(0, 0x3456, q2);
   CHECK_EQUAL_64(0x3456, dst[1]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x18);
+  CHECK_EQUAL_64(dst_base + sizeof(dst[0]), x28);
   CHECK_EQUAL_64(src_base + sizeof(src[0]), x19);
   CHECK_EQUAL_64(dst_base + 2 * sizeof(dst[0]), x20);
   CHECK_EQUAL_64(src_base + 2 * sizeof(src[0]), x21);
@@ -2800,13 +2800,13 @@ TEST(load_store_q) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base);
   __ Mov(x20, dst_base);
   __ Mov(x21, src_base);
   __ Mov(x22, dst_base);
   __ Ldr(q0, MemOperand(x17, 16));
-  __ Str(q0, MemOperand(x18, 16, PostIndex));
+  __ Str(q0, MemOperand(x28, 16, PostIndex));
   __ Ldr(q1, MemOperand(x19, 16, PostIndex));
   __ Str(q1, MemOperand(x20, 32, PreIndex));
   __ Ldr(q2, MemOperand(x21, 32, PreIndex));
@@ -2825,7 +2825,7 @@ TEST(load_store_q) {
   CHECK_EQUAL_64(0x02E0CEAC8A684624, dst[2]);
   CHECK_EQUAL_64(0x200EECCAA8866442, dst[3]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base + 16, x18);
+  CHECK_EQUAL_64(dst_base + 16, x28);
   CHECK_EQUAL_64(src_base + 16, x19);
   CHECK_EQUAL_64(dst_base + 32, x20);
   CHECK_EQUAL_64(src_base + 32, x21);
@@ -2892,7 +2892,7 @@ TEST(neon_ld1_d_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
@@ -2900,7 +2900,7 @@ TEST(neon_ld1_d_postindex) {
   __ Mov(x23, 1);
   __ Ldr(q2, MemOperand(x17));  // Initialise top 64-bits of Q register.
   __ Ld1(v2.V8B(), MemOperand(x17, x23, PostIndex));
-  __ Ld1(v3.V8B(), v4.V8B(), MemOperand(x18, 16, PostIndex));
+  __ Ld1(v3.V8B(), v4.V8B(), MemOperand(x28, 16, PostIndex));
   __ Ld1(v5.V4H(), v6.V4H(), v7.V4H(), MemOperand(x19, 24, PostIndex));
   __ Ld1(v16.V2S(), v17.V2S(), v18.V2S(), v19.V2S(),
          MemOperand(x20, 32, PostIndex));
@@ -2931,7 +2931,7 @@ TEST(neon_ld1_d_postindex) {
   CHECK_EQUAL_128(0, 0x1C1B1A1918171615, q22);
   CHECK_EQUAL_128(0, 0x24232221201F1E1D, q23);
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 16, x18);
+  CHECK_EQUAL_64(src_base + 1 + 16, x28);
   CHECK_EQUAL_64(src_base + 2 + 24, x19);
   CHECK_EQUAL_64(src_base + 3 + 32, x20);
   CHECK_EQUAL_64(src_base + 4 + 32, x21);
@@ -2991,13 +2991,13 @@ TEST(neon_ld1_q_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
   __ Mov(x22, 1);
   __ Ld1(v2.V16B(), MemOperand(x17, x22, PostIndex));
-  __ Ld1(v3.V16B(), v4.V16B(), MemOperand(x18, 32, PostIndex));
+  __ Ld1(v3.V16B(), v4.V16B(), MemOperand(x28, 32, PostIndex));
   __ Ld1(v5.V8H(), v6.V8H(), v7.V8H(), MemOperand(x19, 48, PostIndex));
   __ Ld1(v16.V4S(), v17.V4S(), v18.V4S(), v19.V4S(),
          MemOperand(x20, 64, PostIndex));
@@ -3022,7 +3022,7 @@ TEST(neon_ld1_q_postindex) {
   CHECK_EQUAL_128(0x333231302F2E2D2C, 0x2B2A292827262524, q0);
   CHECK_EQUAL_128(0x434241403F3E3D3C, 0x3B3A393837363534, q1);
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 32, x18);
+  CHECK_EQUAL_64(src_base + 1 + 32, x28);
   CHECK_EQUAL_64(src_base + 2 + 48, x19);
   CHECK_EQUAL_64(src_base + 3 + 64, x20);
   CHECK_EQUAL_64(src_base + 4 + 64, x21);
@@ -3135,13 +3135,13 @@ TEST(neon_ld2_d_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
   __ Mov(x22, 1);
   __ Ld2(v2.V8B(), v3.V8B(), MemOperand(x17, x22, PostIndex));
-  __ Ld2(v4.V8B(), v5.V8B(), MemOperand(x18, 16, PostIndex));
+  __ Ld2(v4.V8B(), v5.V8B(), MemOperand(x28, 16, PostIndex));
   __ Ld2(v5.V4H(), v6.V4H(), MemOperand(x19, 16, PostIndex));
   __ Ld2(v16.V2S(), v17.V2S(), MemOperand(x20, 16, PostIndex));
   __ Ld2(v31.V2S(), v0.V2S(), MemOperand(x21, 16, PostIndex));
@@ -3160,7 +3160,7 @@ TEST(neon_ld2_d_postindex) {
   CHECK_EQUAL_128(0, 0x131211100B0A0908, q0);
 
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 16, x18);
+  CHECK_EQUAL_64(src_base + 1 + 16, x28);
   CHECK_EQUAL_64(src_base + 2 + 16, x19);
   CHECK_EQUAL_64(src_base + 3 + 16, x20);
   CHECK_EQUAL_64(src_base + 4 + 16, x21);
@@ -3215,13 +3215,13 @@ TEST(neon_ld2_q_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
   __ Mov(x22, 1);
   __ Ld2(v2.V16B(), v3.V16B(), MemOperand(x17, x22, PostIndex));
-  __ Ld2(v4.V16B(), v5.V16B(), MemOperand(x18, 32, PostIndex));
+  __ Ld2(v4.V16B(), v5.V16B(), MemOperand(x28, 32, PostIndex));
   __ Ld2(v6.V8H(), v7.V8H(), MemOperand(x19, 32, PostIndex));
   __ Ld2(v16.V4S(), v17.V4S(), MemOperand(x20, 32, PostIndex));
   __ Ld2(v31.V2D(), v0.V2D(), MemOperand(x21, 32, PostIndex));
@@ -3241,7 +3241,7 @@ TEST(neon_ld2_q_postindex) {
   CHECK_EQUAL_128(0x232221201F1E1D1C, 0x131211100F0E0D0C, q0);
 
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 32, x18);
+  CHECK_EQUAL_64(src_base + 1 + 32, x28);
   CHECK_EQUAL_64(src_base + 2 + 32, x19);
   CHECK_EQUAL_64(src_base + 3 + 32, x20);
   CHECK_EQUAL_64(src_base + 4 + 32, x21);
@@ -3337,7 +3337,7 @@ TEST(neon_ld2_lane_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Mov(x19, src_base);
   __ Mov(x20, src_base);
   __ Mov(x21, src_base);
@@ -3351,7 +3351,7 @@ TEST(neon_ld2_lane_postindex) {
   }
 
   for (int i = 7; i >= 0; i--) {
-    __ Ld2(v2.H(), v3.H(), i, MemOperand(x18, 4, PostIndex));
+    __ Ld2(v2.H(), v3.H(), i, MemOperand(x28, 4, PostIndex));
   }
 
   for (int i = 3; i >= 0; i--) {
@@ -3409,7 +3409,7 @@ TEST(neon_ld2_lane_postindex) {
   CHECK_EQUAL_128(0x0F0E0D0C0B0A0908, 0x1716151413121110, q15);
 
   CHECK_EQUAL_64(src_base + 32, x17);
-  CHECK_EQUAL_64(src_base + 32, x18);
+  CHECK_EQUAL_64(src_base + 32, x28);
   CHECK_EQUAL_64(src_base + 32, x19);
   CHECK_EQUAL_64(src_base + 32, x20);
   CHECK_EQUAL_64(src_base + 1, x21);
@@ -3430,7 +3430,6 @@ TEST(neon_ld2_alllanes) {
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
   __ Ld2r(v0.V8B(), v1.V8B(), MemOperand(x17));
   __ Add(x17, x17, 2);
   __ Ld2r(v2.V16B(), v3.V16B(), MemOperand(x17));
@@ -3476,12 +3475,12 @@ TEST(neon_ld2_alllanes_postindex) {
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
+  __ Mov(x19, 1);
   __ Ld2r(v0.V8B(), v1.V8B(), MemOperand(x17, 2, PostIndex));
-  __ Ld2r(v2.V16B(), v3.V16B(), MemOperand(x17, x18, PostIndex));
-  __ Ld2r(v4.V4H(), v5.V4H(), MemOperand(x17, x18, PostIndex));
+  __ Ld2r(v2.V16B(), v3.V16B(), MemOperand(x17, x19, PostIndex));
+  __ Ld2r(v4.V4H(), v5.V4H(), MemOperand(x17, x19, PostIndex));
   __ Ld2r(v6.V8H(), v7.V8H(), MemOperand(x17, 4, PostIndex));
-  __ Ld2r(v8_.V2S(), v9.V2S(), MemOperand(x17, x18, PostIndex));
+  __ Ld2r(v8_.V2S(), v9.V2S(), MemOperand(x17, x19, PostIndex));
   __ Ld2r(v10.V4S(), v11.V4S(), MemOperand(x17, 8, PostIndex));
   __ Ld2r(v12.V2D(), v13.V2D(), MemOperand(x17, 16, PostIndex));
   END();
@@ -3554,13 +3553,13 @@ TEST(neon_ld3_d_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
   __ Mov(x22, 1);
   __ Ld3(v2.V8B(), v3.V8B(), v4.V8B(), MemOperand(x17, x22, PostIndex));
-  __ Ld3(v5.V8B(), v6.V8B(), v7.V8B(), MemOperand(x18, 24, PostIndex));
+  __ Ld3(v5.V8B(), v6.V8B(), v7.V8B(), MemOperand(x28, 24, PostIndex));
   __ Ld3(v8_.V4H(), v9.V4H(), v10.V4H(), MemOperand(x19, 24, PostIndex));
   __ Ld3(v11.V2S(), v12.V2S(), v13.V2S(), MemOperand(x20, 24, PostIndex));
   __ Ld3(v31.V2S(), v0.V2S(), v1.V2S(), MemOperand(x21, 24, PostIndex));
@@ -3585,7 +3584,7 @@ TEST(neon_ld3_d_postindex) {
   CHECK_EQUAL_128(0, 0x1B1A19180F0E0D0C, q1);
 
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 24, x18);
+  CHECK_EQUAL_64(src_base + 1 + 24, x28);
   CHECK_EQUAL_64(src_base + 2 + 24, x19);
   CHECK_EQUAL_64(src_base + 3 + 24, x20);
   CHECK_EQUAL_64(src_base + 4 + 24, x21);
@@ -3645,14 +3644,14 @@ TEST(neon_ld3_q_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
   __ Mov(x22, 1);
 
   __ Ld3(v2.V16B(), v3.V16B(), v4.V16B(), MemOperand(x17, x22, PostIndex));
-  __ Ld3(v5.V16B(), v6.V16B(), v7.V16B(), MemOperand(x18, 48, PostIndex));
+  __ Ld3(v5.V16B(), v6.V16B(), v7.V16B(), MemOperand(x28, 48, PostIndex));
   __ Ld3(v8_.V8H(), v9.V8H(), v10.V8H(), MemOperand(x19, 48, PostIndex));
   __ Ld3(v11.V4S(), v12.V4S(), v13.V4S(), MemOperand(x20, 48, PostIndex));
   __ Ld3(v31.V2D(), v0.V2D(), v1.V2D(), MemOperand(x21, 48, PostIndex));
@@ -3677,7 +3676,7 @@ TEST(neon_ld3_q_postindex) {
   CHECK_EQUAL_128(0x333231302F2E2D2C, 0x1B1A191817161514, q1);
 
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 48, x18);
+  CHECK_EQUAL_64(src_base + 1 + 48, x28);
   CHECK_EQUAL_64(src_base + 2 + 48, x19);
   CHECK_EQUAL_64(src_base + 3 + 48, x20);
   CHECK_EQUAL_64(src_base + 4 + 48, x21);
@@ -3781,7 +3780,7 @@ TEST(neon_ld3_lane_postindex) {
 
   // Test loading whole register by element.
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Mov(x19, src_base);
   __ Mov(x20, src_base);
   __ Mov(x21, src_base);
@@ -3793,7 +3792,7 @@ TEST(neon_ld3_lane_postindex) {
   }
 
   for (int i = 7; i >= 0; i--) {
-    __ Ld3(v3.H(), v4.H(), v5.H(), i, MemOperand(x18, 6, PostIndex));
+    __ Ld3(v3.H(), v4.H(), v5.H(), i, MemOperand(x28, 6, PostIndex));
   }
 
   for (int i = 3; i >= 0; i--) {
@@ -3863,7 +3862,7 @@ TEST(neon_ld3_lane_postindex) {
   CHECK_EQUAL_128(0x1716151413121110, 0x2726252423222120, q23);
 
   CHECK_EQUAL_64(src_base + 48, x17);
-  CHECK_EQUAL_64(src_base + 48, x18);
+  CHECK_EQUAL_64(src_base + 48, x28);
   CHECK_EQUAL_64(src_base + 48, x19);
   CHECK_EQUAL_64(src_base + 48, x20);
   CHECK_EQUAL_64(src_base + 1, x21);
@@ -3884,7 +3883,6 @@ TEST(neon_ld3_alllanes) {
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
   __ Ld3r(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x17));
   __ Add(x17, x17, 3);
   __ Ld3r(v3.V16B(), v4.V16B(), v5.V16B(), MemOperand(x17));
@@ -3934,17 +3932,15 @@ TEST(neon_ld3_alllanes_postindex) {
     src[i] = i;
   }
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
-  __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
+  __ Mov(x19, 1);
   __ Ld3r(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x17, 3, PostIndex));
-  __ Ld3r(v3.V16B(), v4.V16B(), v5.V16B(), MemOperand(x17, x18, PostIndex));
-  __ Ld3r(v6.V4H(), v7.V4H(), v8_.V4H(), MemOperand(x17, x18, PostIndex));
+  __ Ld3r(v3.V16B(), v4.V16B(), v5.V16B(), MemOperand(x17, x19, PostIndex));
+  __ Ld3r(v6.V4H(), v7.V4H(), v8_.V4H(), MemOperand(x17, x19, PostIndex));
   __ Ld3r(v9.V8H(), v10.V8H(), v11.V8H(), MemOperand(x17, 6, PostIndex));
-  __ Ld3r(v12.V2S(), v13.V2S(), v14.V2S(), MemOperand(x17, x18, PostIndex));
+  __ Ld3r(v12.V2S(), v13.V2S(), v14.V2S(), MemOperand(x17, x19, PostIndex));
   __ Ld3r(v15.V4S(), v16.V4S(), v17.V4S(), MemOperand(x17, 12, PostIndex));
   __ Ld3r(v18.V2D(), v19.V2D(), v20.V2D(), MemOperand(x17, 24, PostIndex));
   END();
@@ -4027,7 +4023,7 @@ TEST(neon_ld4_d_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
@@ -4035,7 +4031,7 @@ TEST(neon_ld4_d_postindex) {
   __ Ld4(v2.V8B(), v3.V8B(), v4.V8B(), v5.V8B(),
          MemOperand(x17, x22, PostIndex));
   __ Ld4(v6.V8B(), v7.V8B(), v8_.V8B(), v9.V8B(),
-         MemOperand(x18, 32, PostIndex));
+         MemOperand(x28, 32, PostIndex));
   __ Ld4(v10.V4H(), v11.V4H(), v12.V4H(), v13.V4H(),
          MemOperand(x19, 32, PostIndex));
   __ Ld4(v14.V2S(), v15.V2S(), v16.V2S(), v17.V2S(),
@@ -4068,7 +4064,7 @@ TEST(neon_ld4_d_postindex) {
   CHECK_EQUAL_128(0, 0x2322212013121110, q1);
 
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 32, x18);
+  CHECK_EQUAL_64(src_base + 1 + 32, x28);
   CHECK_EQUAL_64(src_base + 2 + 32, x19);
   CHECK_EQUAL_64(src_base + 3 + 32, x20);
   CHECK_EQUAL_64(src_base + 4 + 32, x21);
@@ -4133,7 +4129,7 @@ TEST(neon_ld4_q_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base + 1);
+  __ Mov(x28, src_base + 1);
   __ Mov(x19, src_base + 2);
   __ Mov(x20, src_base + 3);
   __ Mov(x21, src_base + 4);
@@ -4142,7 +4138,7 @@ TEST(neon_ld4_q_postindex) {
   __ Ld4(v2.V16B(), v3.V16B(), v4.V16B(), v5.V16B(),
          MemOperand(x17, x22, PostIndex));
   __ Ld4(v6.V16B(), v7.V16B(), v8_.V16B(), v9.V16B(),
-         MemOperand(x18, 64, PostIndex));
+         MemOperand(x28, 64, PostIndex));
   __ Ld4(v10.V8H(), v11.V8H(), v12.V8H(), v13.V8H(),
          MemOperand(x19, 64, PostIndex));
   __ Ld4(v14.V4S(), v15.V4S(), v16.V4S(), v17.V4S(),
@@ -4175,7 +4171,7 @@ TEST(neon_ld4_q_postindex) {
   CHECK_EQUAL_128(0x434241403F3E3D3C, 0x232221201F1E1D1C, q1);
 
   CHECK_EQUAL_64(src_base + 1, x17);
-  CHECK_EQUAL_64(src_base + 1 + 64, x18);
+  CHECK_EQUAL_64(src_base + 1 + 64, x28);
   CHECK_EQUAL_64(src_base + 2 + 64, x19);
   CHECK_EQUAL_64(src_base + 3 + 64, x20);
   CHECK_EQUAL_64(src_base + 4 + 64, x21);
@@ -4304,9 +4300,9 @@ TEST(neon_ld4_lane_postindex) {
     __ Ld4(v0.B(), v1.B(), v2.B(), v3.B(), i, MemOperand(x17, 4, PostIndex));
   }
 
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   for (int i = 7; i >= 0; i--) {
-    __ Ld4(v4.H(), v5.H(), v6.H(), v7.H(), i, MemOperand(x18, 8, PostIndex));
+    __ Ld4(v4.H(), v5.H(), v6.H(), v7.H(), i, MemOperand(x28, 8, PostIndex));
   }
 
   __ Mov(x19, src_base);
@@ -4401,7 +4397,7 @@ TEST(neon_ld4_lane_postindex) {
   CHECK_EQUAL_128(0x1F1E1D1C1B1A1918, 0x3736353433323130, q31);
 
   CHECK_EQUAL_64(src_base + 64, x17);
-  CHECK_EQUAL_64(src_base + 64, x18);
+  CHECK_EQUAL_64(src_base + 64, x28);
   CHECK_EQUAL_64(src_base + 64, x19);
   CHECK_EQUAL_64(src_base + 64, x20);
   CHECK_EQUAL_64(src_base + 1, x21);
@@ -4422,7 +4418,6 @@ TEST(neon_ld4_alllanes) {
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
   __ Ld4r(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), MemOperand(x17));
   __ Add(x17, x17, 4);
   __ Ld4r(v4.V16B(), v5.V16B(), v6.V16B(), v7.V16B(), MemOperand(x17));
@@ -4480,22 +4475,20 @@ TEST(neon_ld4_alllanes_postindex) {
     src[i] = i;
   }
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
-  __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
+  __ Mov(x19, 1);
   __ Ld4r(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(),
           MemOperand(x17, 4, PostIndex));
   __ Ld4r(v4.V16B(), v5.V16B(), v6.V16B(), v7.V16B(),
-          MemOperand(x17, x18, PostIndex));
+          MemOperand(x17, x19, PostIndex));
   __ Ld4r(v8_.V4H(), v9.V4H(), v10.V4H(), v11.V4H(),
-          MemOperand(x17, x18, PostIndex));
+          MemOperand(x17, x19, PostIndex));
   __ Ld4r(v12.V8H(), v13.V8H(), v14.V8H(), v15.V8H(),
           MemOperand(x17, 8, PostIndex));
   __ Ld4r(v16.V2S(), v17.V2S(), v18.V2S(), v19.V2S(),
-          MemOperand(x17, x18, PostIndex));
+          MemOperand(x17, x19, PostIndex));
   __ Ld4r(v20.V4S(), v21.V4S(), v22.V4S(), v23.V4S(),
           MemOperand(x17, 16, PostIndex));
   __ Ld4r(v24.V2D(), v25.V2D(), v26.V2D(), v27.V2D(),
@@ -4547,32 +4540,32 @@ TEST(neon_st1_lane) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, -16);
+  __ Mov(x19, -16);
   __ Ldr(q0, MemOperand(x17));
 
   for (int i = 15; i >= 0; i--) {
     __ St1(v0.B(), i, MemOperand(x17));
     __ Add(x17, x17, 1);
   }
-  __ Ldr(q1, MemOperand(x17, x18));
+  __ Ldr(q1, MemOperand(x17, x19));
 
   for (int i = 7; i >= 0; i--) {
     __ St1(v0.H(), i, MemOperand(x17));
     __ Add(x17, x17, 2);
   }
-  __ Ldr(q2, MemOperand(x17, x18));
+  __ Ldr(q2, MemOperand(x17, x19));
 
   for (int i = 3; i >= 0; i--) {
     __ St1(v0.S(), i, MemOperand(x17));
     __ Add(x17, x17, 4);
   }
-  __ Ldr(q3, MemOperand(x17, x18));
+  __ Ldr(q3, MemOperand(x17, x19));
 
   for (int i = 1; i >= 0; i--) {
     __ St1(v0.D(), i, MemOperand(x17));
     __ Add(x17, x17, 8);
   }
-  __ Ldr(q4, MemOperand(x17, x18));
+  __ Ldr(q4, MemOperand(x17, x19));
 
   END();
 
@@ -4595,17 +4588,17 @@ TEST(neon_st2_lane) {
 
   START();
   __ Mov(x17, dst_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x19, dst_base);
   __ Movi(v0.V2D(), 0x0001020304050607, 0x08090A0B0C0D0E0F);
   __ Movi(v1.V2D(), 0x1011121314151617, 0x18191A1B1C1D1E1F);
 
   // Test B stores with and without post index.
   for (int i = 15; i >= 0; i--) {
-    __ St2(v0.B(), v1.B(), i, MemOperand(x18));
-    __ Add(x18, x18, 2);
+    __ St2(v0.B(), v1.B(), i, MemOperand(x19));
+    __ Add(x19, x19, 2);
   }
   for (int i = 15; i >= 0; i--) {
-    __ St2(v0.B(), v1.B(), i, MemOperand(x18, 2, PostIndex));
+    __ St2(v0.B(), v1.B(), i, MemOperand(x19, 2, PostIndex));
   }
   __ Ldr(q2, MemOperand(x17, 0 * 16));
   __ Ldr(q3, MemOperand(x17, 1 * 16));
@@ -4615,11 +4608,11 @@ TEST(neon_st2_lane) {
   // Test H stores with and without post index.
   __ Mov(x0, 4);
   for (int i = 7; i >= 0; i--) {
-    __ St2(v0.H(), v1.H(), i, MemOperand(x18));
-    __ Add(x18, x18, 4);
+    __ St2(v0.H(), v1.H(), i, MemOperand(x19));
+    __ Add(x19, x19, 4);
   }
   for (int i = 7; i >= 0; i--) {
-    __ St2(v0.H(), v1.H(), i, MemOperand(x18, x0, PostIndex));
+    __ St2(v0.H(), v1.H(), i, MemOperand(x19, x0, PostIndex));
   }
   __ Ldr(q6, MemOperand(x17, 4 * 16));
   __ Ldr(q7, MemOperand(x17, 5 * 16));
@@ -4628,11 +4621,11 @@ TEST(neon_st2_lane) {
 
   // Test S stores with and without post index.
   for (int i = 3; i >= 0; i--) {
-    __ St2(v0.S(), v1.S(), i, MemOperand(x18));
-    __ Add(x18, x18, 8);
+    __ St2(v0.S(), v1.S(), i, MemOperand(x19));
+    __ Add(x19, x19, 8);
   }
   for (int i = 3; i >= 0; i--) {
-    __ St2(v0.S(), v1.S(), i, MemOperand(x18, 8, PostIndex));
+    __ St2(v0.S(), v1.S(), i, MemOperand(x19, 8, PostIndex));
   }
   __ Ldr(q18, MemOperand(x17, 8 * 16));
   __ Ldr(q19, MemOperand(x17, 9 * 16));
@@ -4641,11 +4634,11 @@ TEST(neon_st2_lane) {
 
   // Test D stores with and without post index.
   __ Mov(x0, 16);
-  __ St2(v0.D(), v1.D(), 1, MemOperand(x18));
-  __ Add(x18, x18, 16);
-  __ St2(v0.D(), v1.D(), 0, MemOperand(x18, 16, PostIndex));
-  __ St2(v0.D(), v1.D(), 1, MemOperand(x18, x0, PostIndex));
-  __ St2(v0.D(), v1.D(), 0, MemOperand(x18, x0, PostIndex));
+  __ St2(v0.D(), v1.D(), 1, MemOperand(x19));
+  __ Add(x19, x19, 16);
+  __ St2(v0.D(), v1.D(), 0, MemOperand(x19, 16, PostIndex));
+  __ St2(v0.D(), v1.D(), 1, MemOperand(x19, x0, PostIndex));
+  __ St2(v0.D(), v1.D(), 0, MemOperand(x19, x0, PostIndex));
   __ Ldr(q22, MemOperand(x17, 12 * 16));
   __ Ldr(q23, MemOperand(x17, 13 * 16));
   __ Ldr(q24, MemOperand(x17, 14 * 16));
@@ -4686,18 +4679,18 @@ TEST(neon_st3_lane) {
 
   START();
   __ Mov(x17, dst_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x19, dst_base);
   __ Movi(v0.V2D(), 0x0001020304050607, 0x08090A0B0C0D0E0F);
   __ Movi(v1.V2D(), 0x1011121314151617, 0x18191A1B1C1D1E1F);
   __ Movi(v2.V2D(), 0x2021222324252627, 0x28292A2B2C2D2E2F);
 
   // Test B stores with and without post index.
   for (int i = 15; i >= 0; i--) {
-    __ St3(v0.B(), v1.B(), v2.B(), i, MemOperand(x18));
-    __ Add(x18, x18, 3);
+    __ St3(v0.B(), v1.B(), v2.B(), i, MemOperand(x19));
+    __ Add(x19, x19, 3);
   }
   for (int i = 15; i >= 0; i--) {
-    __ St3(v0.B(), v1.B(), v2.B(), i, MemOperand(x18, 3, PostIndex));
+    __ St3(v0.B(), v1.B(), v2.B(), i, MemOperand(x19, 3, PostIndex));
   }
   __ Ldr(q3, MemOperand(x17, 0 * 16));
   __ Ldr(q4, MemOperand(x17, 1 * 16));
@@ -4709,11 +4702,11 @@ TEST(neon_st3_lane) {
   // Test H stores with and without post index.
   __ Mov(x0, 6);
   for (int i = 7; i >= 0; i--) {
-    __ St3(v0.H(), v1.H(), v2.H(), i, MemOperand(x18));
-    __ Add(x18, x18, 6);
+    __ St3(v0.H(), v1.H(), v2.H(), i, MemOperand(x19));
+    __ Add(x19, x19, 6);
   }
   for (int i = 7; i >= 0; i--) {
-    __ St3(v0.H(), v1.H(), v2.H(), i, MemOperand(x18, x0, PostIndex));
+    __ St3(v0.H(), v1.H(), v2.H(), i, MemOperand(x19, x0, PostIndex));
   }
   __ Ldr(q17, MemOperand(x17, 6 * 16));
   __ Ldr(q18, MemOperand(x17, 7 * 16));
@@ -4724,11 +4717,11 @@ TEST(neon_st3_lane) {
 
   // Test S stores with and without post index.
   for (int i = 3; i >= 0; i--) {
-    __ St3(v0.S(), v1.S(), v2.S(), i, MemOperand(x18));
-    __ Add(x18, x18, 12);
+    __ St3(v0.S(), v1.S(), v2.S(), i, MemOperand(x19));
+    __ Add(x19, x19, 12);
   }
   for (int i = 3; i >= 0; i--) {
-    __ St3(v0.S(), v1.S(), v2.S(), i, MemOperand(x18, 12, PostIndex));
+    __ St3(v0.S(), v1.S(), v2.S(), i, MemOperand(x19, 12, PostIndex));
   }
   __ Ldr(q23, MemOperand(x17, 12 * 16));
   __ Ldr(q24, MemOperand(x17, 13 * 16));
@@ -4739,10 +4732,10 @@ TEST(neon_st3_lane) {
 
   // Test D stores with and without post index.
   __ Mov(x0, 24);
-  __ St3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x18));
-  __ Add(x18, x18, 24);
-  __ St3(v0.D(), v1.D(), v2.D(), 0, MemOperand(x18, 24, PostIndex));
-  __ St3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x18, x0, PostIndex));
+  __ St3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x19));
+  __ Add(x19, x19, 24);
+  __ St3(v0.D(), v1.D(), v2.D(), 0, MemOperand(x19, 24, PostIndex));
+  __ St3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x19, x0, PostIndex));
   __ Ldr(q29, MemOperand(x17, 18 * 16));
   __ Ldr(q30, MemOperand(x17, 19 * 16));
   __ Ldr(q31, MemOperand(x17, 20 * 16));
@@ -4783,7 +4776,7 @@ TEST(neon_st4_lane) {
 
   START();
   __ Mov(x17, dst_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x19, dst_base);
   __ Movi(v0.V2D(), 0x0001020304050607, 0x08090A0B0C0D0E0F);
   __ Movi(v1.V2D(), 0x1011121314151617, 0x18191A1B1C1D1E1F);
   __ Movi(v2.V2D(), 0x2021222324252627, 0x28292A2B2C2D2E2F);
@@ -4791,8 +4784,8 @@ TEST(neon_st4_lane) {
 
   // Test B stores without post index.
   for (int i = 15; i >= 0; i--) {
-    __ St4(v0.B(), v1.B(), v2.B(), v3.B(), i, MemOperand(x18));
-    __ Add(x18, x18, 4);
+    __ St4(v0.B(), v1.B(), v2.B(), v3.B(), i, MemOperand(x19));
+    __ Add(x19, x19, 4);
   }
   __ Ldr(q4, MemOperand(x17, 0 * 16));
   __ Ldr(q5, MemOperand(x17, 1 * 16));
@@ -4802,7 +4795,7 @@ TEST(neon_st4_lane) {
   // Test H stores with post index.
   __ Mov(x0, 8);
   for (int i = 7; i >= 0; i--) {
-    __ St4(v0.H(), v1.H(), v2.H(), v3.H(), i, MemOperand(x18, x0, PostIndex));
+    __ St4(v0.H(), v1.H(), v2.H(), v3.H(), i, MemOperand(x19, x0, PostIndex));
   }
   __ Ldr(q16, MemOperand(x17, 4 * 16));
   __ Ldr(q17, MemOperand(x17, 5 * 16));
@@ -4811,8 +4804,8 @@ TEST(neon_st4_lane) {
 
   // Test S stores without post index.
   for (int i = 3; i >= 0; i--) {
-    __ St4(v0.S(), v1.S(), v2.S(), v3.S(), i, MemOperand(x18));
-    __ Add(x18, x18, 16);
+    __ St4(v0.S(), v1.S(), v2.S(), v3.S(), i, MemOperand(x19));
+    __ Add(x19, x19, 16);
   }
   __ Ldr(q20, MemOperand(x17, 8 * 16));
   __ Ldr(q21, MemOperand(x17, 9 * 16));
@@ -4821,8 +4814,8 @@ TEST(neon_st4_lane) {
 
   // Test D stores with post index.
   __ Mov(x0, 32);
-  __ St4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x18, 32, PostIndex));
-  __ St4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x18, x0, PostIndex));
+  __ St4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x19, 32, PostIndex));
+  __ St4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x19, x0, PostIndex));
 
   __ Ldr(q24, MemOperand(x17, 12 * 16));
   __ Ldr(q25, MemOperand(x17, 13 * 16));
@@ -4865,7 +4858,7 @@ TEST(neon_ld1_lane_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Mov(x19, src_base);
   __ Mov(x20, src_base);
   __ Mov(x21, src_base);
@@ -4879,7 +4872,7 @@ TEST(neon_ld1_lane_postindex) {
   }
 
   for (int i = 7; i >= 0; i--) {
-    __ Ld1(v1.H(), i, MemOperand(x18, 2, PostIndex));
+    __ Ld1(v1.H(), i, MemOperand(x28, 2, PostIndex));
   }
 
   for (int i = 3; i >= 0; i--) {
@@ -4920,7 +4913,7 @@ TEST(neon_ld1_lane_postindex) {
   CHECK_EQUAL_128(0x0F0E0D0C03020100, 0x0706050403020100, q6);
   CHECK_EQUAL_128(0x0706050403020100, 0x0706050403020100, q7);
   CHECK_EQUAL_64(src_base + 16, x17);
-  CHECK_EQUAL_64(src_base + 16, x18);
+  CHECK_EQUAL_64(src_base + 16, x28);
   CHECK_EQUAL_64(src_base + 16, x19);
   CHECK_EQUAL_64(src_base + 16, x20);
   CHECK_EQUAL_64(src_base + 1, x21);
@@ -4941,28 +4934,28 @@ TEST(neon_st1_lane_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, -16);
+  __ Mov(x19, -16);
   __ Ldr(q0, MemOperand(x17));
 
   for (int i = 15; i >= 0; i--) {
     __ St1(v0.B(), i, MemOperand(x17, 1, PostIndex));
   }
-  __ Ldr(q1, MemOperand(x17, x18));
+  __ Ldr(q1, MemOperand(x17, x19));
 
   for (int i = 7; i >= 0; i--) {
     __ St1(v0.H(), i, MemOperand(x17, 2, PostIndex));
   }
-  __ Ldr(q2, MemOperand(x17, x18));
+  __ Ldr(q2, MemOperand(x17, x19));
 
   for (int i = 3; i >= 0; i--) {
     __ St1(v0.S(), i, MemOperand(x17, 4, PostIndex));
   }
-  __ Ldr(q3, MemOperand(x17, x18));
+  __ Ldr(q3, MemOperand(x17, x19));
 
   for (int i = 1; i >= 0; i--) {
     __ St1(v0.D(), i, MemOperand(x17, 8, PostIndex));
   }
-  __ Ldr(q4, MemOperand(x17, x18));
+  __ Ldr(q4, MemOperand(x17, x19));
 
   END();
 
@@ -5027,12 +5020,12 @@ TEST(neon_ld1_alllanes_postindex) {
 
   START();
   __ Mov(x17, src_base + 1);
-  __ Mov(x18, 1);
+  __ Mov(x19, 1);
   __ Ld1r(v0.V8B(), MemOperand(x17, 1, PostIndex));
-  __ Ld1r(v1.V16B(), MemOperand(x17, x18, PostIndex));
-  __ Ld1r(v2.V4H(), MemOperand(x17, x18, PostIndex));
+  __ Ld1r(v1.V16B(), MemOperand(x17, x19, PostIndex));
+  __ Ld1r(v2.V4H(), MemOperand(x17, x19, PostIndex));
   __ Ld1r(v3.V8H(), MemOperand(x17, 2, PostIndex));
-  __ Ld1r(v4.V2S(), MemOperand(x17, x18, PostIndex));
+  __ Ld1r(v4.V2S(), MemOperand(x17, x19, PostIndex));
   __ Ld1r(v5.V4S(), MemOperand(x17, 4, PostIndex));
   __ Ld1r(v6.V2D(), MemOperand(x17, 8, PostIndex));
   END();
@@ -5116,7 +5109,7 @@ TEST(neon_st1_d_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, -8);
+  __ Mov(x28, -8);
   __ Mov(x19, -16);
   __ Mov(x20, -24);
   __ Mov(x21, -32);
@@ -5127,7 +5120,7 @@ TEST(neon_st1_d_postindex) {
   __ Mov(x17, src_base);
 
   __ St1(v0.V8B(), MemOperand(x17, 8, PostIndex));
-  __ Ldr(d16, MemOperand(x17, x18));
+  __ Ldr(d16, MemOperand(x17, x28));
 
   __ St1(v0.V8B(), v1.V8B(), MemOperand(x17, 16, PostIndex));
   __ Ldr(q17, MemOperand(x17, x19));
@@ -5135,7 +5128,7 @@ TEST(neon_st1_d_postindex) {
   __ St1(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x17, 24, PostIndex));
   __ Ldr(d18, MemOperand(x17, x20));
   __ Ldr(d19, MemOperand(x17, x19));
-  __ Ldr(d20, MemOperand(x17, x18));
+  __ Ldr(d20, MemOperand(x17, x28));
 
   __ St1(v0.V2S(), v1.V2S(), v2.V2S(), v3.V2S(),
          MemOperand(x17, 32, PostIndex));
@@ -5223,7 +5216,7 @@ TEST(neon_st1_q_postindex) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, -16);
+  __ Mov(x28, -16);
   __ Mov(x19, -32);
   __ Mov(x20, -48);
   __ Mov(x21, -64);
@@ -5233,23 +5226,23 @@ TEST(neon_st1_q_postindex) {
   __ Ldr(q3, MemOperand(x17, 16, PostIndex));
 
   __ St1(v0.V16B(), MemOperand(x17, 16, PostIndex));
-  __ Ldr(q16, MemOperand(x17, x18));
+  __ Ldr(q16, MemOperand(x17, x28));
 
   __ St1(v0.V8H(), v1.V8H(), MemOperand(x17, 32, PostIndex));
   __ Ldr(q17, MemOperand(x17, x19));
-  __ Ldr(q18, MemOperand(x17, x18));
+  __ Ldr(q18, MemOperand(x17, x28));
 
   __ St1(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x17, 48, PostIndex));
   __ Ldr(q19, MemOperand(x17, x20));
   __ Ldr(q20, MemOperand(x17, x19));
-  __ Ldr(q21, MemOperand(x17, x18));
+  __ Ldr(q21, MemOperand(x17, x28));
 
   __ St1(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(),
          MemOperand(x17, 64, PostIndex));
   __ Ldr(q22, MemOperand(x17, x21));
   __ Ldr(q23, MemOperand(x17, x20));
   __ Ldr(q24, MemOperand(x17, x19));
-  __ Ldr(q25, MemOperand(x17, x18));
+  __ Ldr(q25, MemOperand(x17, x28));
 
   END();
 
@@ -5279,15 +5272,15 @@ TEST(neon_st2_d) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
 
-  __ St2(v0.V8B(), v1.V8B(), MemOperand(x18));
-  __ Add(x18, x18, 22);
-  __ St2(v0.V4H(), v1.V4H(), MemOperand(x18));
-  __ Add(x18, x18, 11);
-  __ St2(v0.V2S(), v1.V2S(), MemOperand(x18));
+  __ St2(v0.V8B(), v1.V8B(), MemOperand(x19));
+  __ Add(x19, x19, 22);
+  __ St2(v0.V4H(), v1.V4H(), MemOperand(x19));
+  __ Add(x19, x19, 11);
+  __ St2(v0.V2S(), v1.V2S(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5318,13 +5311,13 @@ TEST(neon_st2_d_postindex) {
   START();
   __ Mov(x22, 5);
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
 
-  __ St2(v0.V8B(), v1.V8B(), MemOperand(x18, x22, PostIndex));
-  __ St2(v0.V4H(), v1.V4H(), MemOperand(x18, 16, PostIndex));
-  __ St2(v0.V2S(), v1.V2S(), MemOperand(x18));
+  __ St2(v0.V8B(), v1.V8B(), MemOperand(x19, x22, PostIndex));
+  __ St2(v0.V4H(), v1.V4H(), MemOperand(x19, 16, PostIndex));
+  __ St2(v0.V2S(), v1.V2S(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5352,17 +5345,17 @@ TEST(neon_st2_q) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
 
-  __ St2(v0.V16B(), v1.V16B(), MemOperand(x18));
-  __ Add(x18, x18, 8);
-  __ St2(v0.V8H(), v1.V8H(), MemOperand(x18));
-  __ Add(x18, x18, 22);
-  __ St2(v0.V4S(), v1.V4S(), MemOperand(x18));
-  __ Add(x18, x18, 2);
-  __ St2(v0.V2D(), v1.V2D(), MemOperand(x18));
+  __ St2(v0.V16B(), v1.V16B(), MemOperand(x19));
+  __ Add(x19, x19, 8);
+  __ St2(v0.V8H(), v1.V8H(), MemOperand(x19));
+  __ Add(x19, x19, 22);
+  __ St2(v0.V4S(), v1.V4S(), MemOperand(x19));
+  __ Add(x19, x19, 2);
+  __ St2(v0.V2D(), v1.V2D(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5393,14 +5386,14 @@ TEST(neon_st2_q_postindex) {
   START();
   __ Mov(x22, 5);
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
 
-  __ St2(v0.V16B(), v1.V16B(), MemOperand(x18, x22, PostIndex));
-  __ St2(v0.V8H(), v1.V8H(), MemOperand(x18, 32, PostIndex));
-  __ St2(v0.V4S(), v1.V4S(), MemOperand(x18, x22, PostIndex));
-  __ St2(v0.V2D(), v1.V2D(), MemOperand(x18));
+  __ St2(v0.V16B(), v1.V16B(), MemOperand(x19, x22, PostIndex));
+  __ St2(v0.V8H(), v1.V8H(), MemOperand(x19, 32, PostIndex));
+  __ St2(v0.V4S(), v1.V4S(), MemOperand(x19, x22, PostIndex));
+  __ St2(v0.V2D(), v1.V2D(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5432,16 +5425,16 @@ TEST(neon_st3_d) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
 
-  __ St3(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x18));
-  __ Add(x18, x18, 3);
-  __ St3(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x18));
-  __ Add(x18, x18, 2);
-  __ St3(v0.V2S(), v1.V2S(), v2.V2S(), MemOperand(x18));
+  __ St3(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x19));
+  __ Add(x19, x19, 3);
+  __ St3(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x19));
+  __ Add(x19, x19, 2);
+  __ St3(v0.V2S(), v1.V2S(), v2.V2S(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5468,14 +5461,14 @@ TEST(neon_st3_d_postindex) {
   START();
   __ Mov(x22, 5);
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
 
-  __ St3(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x18, x22, PostIndex));
-  __ St3(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x18, 24, PostIndex));
-  __ St3(v0.V2S(), v1.V2S(), v2.V2S(), MemOperand(x18));
+  __ St3(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x19, x22, PostIndex));
+  __ St3(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x19, 24, PostIndex));
+  __ St3(v0.V2S(), v1.V2S(), v2.V2S(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5505,18 +5498,18 @@ TEST(neon_st3_q) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
 
-  __ St3(v0.V16B(), v1.V16B(), v2.V16B(), MemOperand(x18));
-  __ Add(x18, x18, 5);
-  __ St3(v0.V8H(), v1.V8H(), v2.V8H(), MemOperand(x18));
-  __ Add(x18, x18, 12);
-  __ St3(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x18));
-  __ Add(x18, x18, 22);
-  __ St3(v0.V2D(), v1.V2D(), v2.V2D(), MemOperand(x18));
+  __ St3(v0.V16B(), v1.V16B(), v2.V16B(), MemOperand(x19));
+  __ Add(x19, x19, 5);
+  __ St3(v0.V8H(), v1.V8H(), v2.V8H(), MemOperand(x19));
+  __ Add(x19, x19, 12);
+  __ St3(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x19));
+  __ Add(x19, x19, 22);
+  __ St3(v0.V2D(), v1.V2D(), v2.V2D(), MemOperand(x19));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5551,15 +5544,15 @@ TEST(neon_st3_q_postindex) {
   START();
   __ Mov(x22, 5);
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
 
-  __ St3(v0.V16B(), v1.V16B(), v2.V16B(), MemOperand(x18, x22, PostIndex));
-  __ St3(v0.V8H(), v1.V8H(), v2.V8H(), MemOperand(x18, 48, PostIndex));
-  __ St3(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x18, x22, PostIndex));
-  __ St3(v0.V2D(), v1.V2D(), v2.V2D(), MemOperand(x18));
+  __ St3(v0.V16B(), v1.V16B(), v2.V16B(), MemOperand(x28, x22, PostIndex));
+  __ St3(v0.V8H(), v1.V8H(), v2.V8H(), MemOperand(x28, 48, PostIndex));
+  __ St3(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x28, x22, PostIndex));
+  __ St3(v0.V2D(), v1.V2D(), v2.V2D(), MemOperand(x28));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5595,17 +5588,17 @@ TEST(neon_st4_d) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
   __ Ldr(q3, MemOperand(x17, 16, PostIndex));
 
-  __ St4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), MemOperand(x18));
-  __ Add(x18, x18, 12);
-  __ St4(v0.V4H(), v1.V4H(), v2.V4H(), v3.V4H(), MemOperand(x18));
-  __ Add(x18, x18, 15);
-  __ St4(v0.V2S(), v1.V2S(), v2.V2S(), v3.V2S(), MemOperand(x18));
+  __ St4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), MemOperand(x28));
+  __ Add(x28, x28, 12);
+  __ St4(v0.V4H(), v1.V4H(), v2.V4H(), v3.V4H(), MemOperand(x28));
+  __ Add(x28, x28, 15);
+  __ St4(v0.V2S(), v1.V2S(), v2.V2S(), v3.V2S(), MemOperand(x28));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5636,17 +5629,17 @@ TEST(neon_st4_d_postindex) {
   START();
   __ Mov(x22, 5);
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
   __ Ldr(q3, MemOperand(x17, 16, PostIndex));
 
   __ St4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(),
-         MemOperand(x18, x22, PostIndex));
+         MemOperand(x28, x22, PostIndex));
   __ St4(v0.V4H(), v1.V4H(), v2.V4H(), v3.V4H(),
-         MemOperand(x18, 32, PostIndex));
-  __ St4(v0.V2S(), v1.V2S(), v2.V2S(), v3.V2S(), MemOperand(x18));
+         MemOperand(x28, 32, PostIndex));
+  __ St4(v0.V2S(), v1.V2S(), v2.V2S(), v3.V2S(), MemOperand(x28));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5678,20 +5671,20 @@ TEST(neon_st4_q) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
   __ Ldr(q3, MemOperand(x17, 16, PostIndex));
 
-  __ St4(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), MemOperand(x18));
-  __ Add(x18, x18, 5);
-  __ St4(v0.V8H(), v1.V8H(), v2.V8H(), v3.V8H(), MemOperand(x18));
-  __ Add(x18, x18, 12);
-  __ St4(v0.V4S(), v1.V4S(), v2.V4S(), v3.V4S(), MemOperand(x18));
-  __ Add(x18, x18, 22);
-  __ St4(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x18));
-  __ Add(x18, x18, 10);
+  __ St4(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), MemOperand(x28));
+  __ Add(x28, x28, 5);
+  __ St4(v0.V8H(), v1.V8H(), v2.V8H(), v3.V8H(), MemOperand(x28));
+  __ Add(x28, x28, 12);
+  __ St4(v0.V4S(), v1.V4S(), v2.V4S(), v3.V4S(), MemOperand(x28));
+  __ Add(x28, x28, 22);
+  __ St4(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x28));
+  __ Add(x28, x28, 10);
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -5728,19 +5721,19 @@ TEST(neon_st4_q_postindex) {
   START();
   __ Mov(x22, 5);
   __ Mov(x17, src_base);
-  __ Mov(x18, src_base);
+  __ Mov(x28, src_base);
   __ Ldr(q0, MemOperand(x17, 16, PostIndex));
   __ Ldr(q1, MemOperand(x17, 16, PostIndex));
   __ Ldr(q2, MemOperand(x17, 16, PostIndex));
   __ Ldr(q3, MemOperand(x17, 16, PostIndex));
 
   __ St4(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(),
-         MemOperand(x18, x22, PostIndex));
+         MemOperand(x28, x22, PostIndex));
   __ St4(v0.V8H(), v1.V8H(), v2.V8H(), v3.V8H(),
-         MemOperand(x18, 64, PostIndex));
+         MemOperand(x28, 64, PostIndex));
   __ St4(v0.V4S(), v1.V4S(), v2.V4S(), v3.V4S(),
-         MemOperand(x18, x22, PostIndex));
-  __ St4(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x18));
+         MemOperand(x28, x22, PostIndex));
+  __ St4(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x28));
 
   __ Mov(x19, src_base);
   __ Ldr(q0, MemOperand(x19, 16, PostIndex));
@@ -6065,13 +6058,13 @@ TEST(ldp_stp_offset) {
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
-  __ Mov(x18, src_base + 24);
+  __ Mov(x28, src_base + 24);
   __ Mov(x19, dst_base + 56);
   __ Ldp(w0, w1, MemOperand(x16));
   __ Ldp(w2, w3, MemOperand(x16, 4));
   __ Ldp(x4, x5, MemOperand(x16, 8));
-  __ Ldp(w6, w7, MemOperand(x18, -12));
-  __ Ldp(x8, x9, MemOperand(x18, -16));
+  __ Ldp(w6, w7, MemOperand(x28, -12));
+  __ Ldp(x8, x9, MemOperand(x28, -16));
   __ Stp(w0, w1, MemOperand(x17));
   __ Stp(w2, w3, MemOperand(x17, 8));
   __ Stp(x4, x5, MemOperand(x17, 16));
@@ -6100,7 +6093,7 @@ TEST(ldp_stp_offset) {
   CHECK_EQUAL_64(0xFFEEDDCCBBAA9988UL, dst[6]);
   CHECK_EQUAL_64(src_base, x16);
   CHECK_EQUAL_64(dst_base, x17);
-  CHECK_EQUAL_64(src_base + 24, x18);
+  CHECK_EQUAL_64(src_base + 24, x28);
   CHECK_EQUAL_64(dst_base + 56, x19);
 }
 
@@ -6120,13 +6113,13 @@ TEST(ldp_stp_offset_wide) {
   START();
   __ Mov(x20, src_base - base_offset);
   __ Mov(x21, dst_base - base_offset);
-  __ Mov(x18, src_base + base_offset + 24);
+  __ Mov(x28, src_base + base_offset + 24);
   __ Mov(x19, dst_base + base_offset + 56);
   __ Ldp(w0, w1, MemOperand(x20, base_offset));
   __ Ldp(w2, w3, MemOperand(x20, base_offset + 4));
   __ Ldp(x4, x5, MemOperand(x20, base_offset + 8));
-  __ Ldp(w6, w7, MemOperand(x18, -12 - base_offset));
-  __ Ldp(x8, x9, MemOperand(x18, -16 - base_offset));
+  __ Ldp(w6, w7, MemOperand(x28, -12 - base_offset));
+  __ Ldp(x8, x9, MemOperand(x28, -16 - base_offset));
   __ Stp(w0, w1, MemOperand(x21, base_offset));
   __ Stp(w2, w3, MemOperand(x21, base_offset + 8));
   __ Stp(x4, x5, MemOperand(x21, base_offset + 16));
@@ -6155,7 +6148,7 @@ TEST(ldp_stp_offset_wide) {
   CHECK_EQUAL_64(0xFFEEDDCCBBAA9988UL, dst[6]);
   CHECK_EQUAL_64(src_base - base_offset, x20);
   CHECK_EQUAL_64(dst_base - base_offset, x21);
-  CHECK_EQUAL_64(src_base + base_offset + 24, x18);
+  CHECK_EQUAL_64(src_base + base_offset + 24, x28);
   CHECK_EQUAL_64(dst_base + base_offset + 56, x19);
 }
 
@@ -6172,7 +6165,7 @@ TEST(ldp_stp_preindex) {
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
-  __ Mov(x18, dst_base + 16);
+  __ Mov(x28, dst_base + 16);
   __ Ldp(w0, w1, MemOperand(x16, 4, PreIndex));
   __ Mov(x19, x16);
   __ Ldp(w2, w3, MemOperand(x16, -4, PreIndex));
@@ -6182,9 +6175,9 @@ TEST(ldp_stp_preindex) {
   __ Ldp(x4, x5, MemOperand(x16, 8, PreIndex));
   __ Mov(x21, x16);
   __ Ldp(x6, x7, MemOperand(x16, -8, PreIndex));
-  __ Stp(x7, x6, MemOperand(x18, 8, PreIndex));
-  __ Mov(x22, x18);
-  __ Stp(x5, x4, MemOperand(x18, -8, PreIndex));
+  __ Stp(x7, x6, MemOperand(x28, 8, PreIndex));
+  __ Mov(x22, x28);
+  __ Stp(x5, x4, MemOperand(x28, -8, PreIndex));
   END();
 
   RUN();
@@ -6204,7 +6197,7 @@ TEST(ldp_stp_preindex) {
   CHECK_EQUAL_64(0x0011223344556677UL, dst[4]);
   CHECK_EQUAL_64(src_base, x16);
   CHECK_EQUAL_64(dst_base, x17);
-  CHECK_EQUAL_64(dst_base + 16, x18);
+  CHECK_EQUAL_64(dst_base + 16, x28);
   CHECK_EQUAL_64(src_base + 4, x19);
   CHECK_EQUAL_64(dst_base + 4, x20);
   CHECK_EQUAL_64(src_base + 8, x21);
@@ -6227,7 +6220,7 @@ TEST(ldp_stp_preindex_wide) {
   START();
   __ Mov(x24, src_base - base_offset);
   __ Mov(x25, dst_base + base_offset);
-  __ Mov(x18, dst_base + base_offset + 16);
+  __ Mov(x28, dst_base + base_offset + 16);
   __ Ldp(w0, w1, MemOperand(x24, base_offset + 4, PreIndex));
   __ Mov(x19, x24);
   __ Mov(x24, src_base - base_offset + 4);
@@ -6241,10 +6234,10 @@ TEST(ldp_stp_preindex_wide) {
   __ Mov(x21, x24);
   __ Mov(x24, src_base - base_offset + 8);
   __ Ldp(x6, x7, MemOperand(x24, base_offset - 8, PreIndex));
-  __ Stp(x7, x6, MemOperand(x18, 8 - base_offset, PreIndex));
-  __ Mov(x22, x18);
-  __ Mov(x18, dst_base + base_offset + 16 + 8);
-  __ Stp(x5, x4, MemOperand(x18, -8 - base_offset, PreIndex));
+  __ Stp(x7, x6, MemOperand(x28, 8 - base_offset, PreIndex));
+  __ Mov(x22, x28);
+  __ Mov(x28, dst_base + base_offset + 16 + 8);
+  __ Stp(x5, x4, MemOperand(x28, -8 - base_offset, PreIndex));
   END();
 
   RUN();
@@ -6264,7 +6257,7 @@ TEST(ldp_stp_preindex_wide) {
   CHECK_EQUAL_64(0x0011223344556677UL, dst[4]);
   CHECK_EQUAL_64(src_base, x24);
   CHECK_EQUAL_64(dst_base, x25);
-  CHECK_EQUAL_64(dst_base + 16, x18);
+  CHECK_EQUAL_64(dst_base + 16, x28);
   CHECK_EQUAL_64(src_base + 4, x19);
   CHECK_EQUAL_64(dst_base + 4, x20);
   CHECK_EQUAL_64(src_base + 8, x21);
@@ -6284,7 +6277,7 @@ TEST(ldp_stp_postindex) {
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
-  __ Mov(x18, dst_base + 16);
+  __ Mov(x28, dst_base + 16);
   __ Ldp(w0, w1, MemOperand(x16, 4, PostIndex));
   __ Mov(x19, x16);
   __ Ldp(w2, w3, MemOperand(x16, -4, PostIndex));
@@ -6294,9 +6287,9 @@ TEST(ldp_stp_postindex) {
   __ Ldp(x4, x5, MemOperand(x16, 8, PostIndex));
   __ Mov(x21, x16);
   __ Ldp(x6, x7, MemOperand(x16, -8, PostIndex));
-  __ Stp(x7, x6, MemOperand(x18, 8, PostIndex));
-  __ Mov(x22, x18);
-  __ Stp(x5, x4, MemOperand(x18, -8, PostIndex));
+  __ Stp(x7, x6, MemOperand(x28, 8, PostIndex));
+  __ Mov(x22, x28);
+  __ Stp(x5, x4, MemOperand(x28, -8, PostIndex));
   END();
 
   RUN();
@@ -6316,7 +6309,7 @@ TEST(ldp_stp_postindex) {
   CHECK_EQUAL_64(0x0011223344556677UL, dst[4]);
   CHECK_EQUAL_64(src_base, x16);
   CHECK_EQUAL_64(dst_base, x17);
-  CHECK_EQUAL_64(dst_base + 16, x18);
+  CHECK_EQUAL_64(dst_base + 16, x28);
   CHECK_EQUAL_64(src_base + 4, x19);
   CHECK_EQUAL_64(dst_base + 4, x20);
   CHECK_EQUAL_64(src_base + 8, x21);
@@ -6339,7 +6332,7 @@ TEST(ldp_stp_postindex_wide) {
   START();
   __ Mov(x24, src_base);
   __ Mov(x25, dst_base);
-  __ Mov(x18, dst_base + 16);
+  __ Mov(x28, dst_base + 16);
   __ Ldp(w0, w1, MemOperand(x24, base_offset + 4, PostIndex));
   __ Mov(x19, x24);
   __ Sub(x24, x24, base_offset);
@@ -6353,10 +6346,10 @@ TEST(ldp_stp_postindex_wide) {
   __ Mov(x21, x24);
   __ Sub(x24, x24, base_offset);
   __ Ldp(x6, x7, MemOperand(x24, base_offset - 8, PostIndex));
-  __ Stp(x7, x6, MemOperand(x18, 8 - base_offset, PostIndex));
-  __ Mov(x22, x18);
-  __ Add(x18, x18, base_offset);
-  __ Stp(x5, x4, MemOperand(x18, -8 - base_offset, PostIndex));
+  __ Stp(x7, x6, MemOperand(x28, 8 - base_offset, PostIndex));
+  __ Mov(x22, x28);
+  __ Add(x28, x28, base_offset);
+  __ Stp(x5, x4, MemOperand(x28, -8 - base_offset, PostIndex));
   END();
 
   RUN();
@@ -6376,7 +6369,7 @@ TEST(ldp_stp_postindex_wide) {
   CHECK_EQUAL_64(0x0011223344556677UL, dst[4]);
   CHECK_EQUAL_64(src_base + base_offset, x24);
   CHECK_EQUAL_64(dst_base - base_offset, x25);
-  CHECK_EQUAL_64(dst_base - base_offset + 16, x18);
+  CHECK_EQUAL_64(dst_base - base_offset + 16, x28);
   CHECK_EQUAL_64(src_base + base_offset + 4, x19);
   CHECK_EQUAL_64(dst_base - base_offset + 4, x20);
   CHECK_EQUAL_64(src_base + base_offset + 8, x21);
@@ -6412,14 +6405,14 @@ TEST(ldur_stur) {
 
   START();
   __ Mov(x17, src_base);
-  __ Mov(x18, dst_base);
+  __ Mov(x28, dst_base);
   __ Mov(x19, src_base + 16);
   __ Mov(x20, dst_base + 32);
   __ Mov(x21, dst_base + 40);
   __ Ldr(w0, MemOperand(x17, 1));
-  __ Str(w0, MemOperand(x18, 2));
+  __ Str(w0, MemOperand(x28, 2));
   __ Ldr(x1, MemOperand(x17, 3));
-  __ Str(x1, MemOperand(x18, 9));
+  __ Str(x1, MemOperand(x28, 9));
   __ Ldr(w2, MemOperand(x19, -9));
   __ Str(w2, MemOperand(x20, -5));
   __ Ldrb(w3, MemOperand(x19, -1));
@@ -6438,7 +6431,7 @@ TEST(ldur_stur) {
   CHECK_EQUAL_64(0x00000001, x3);
   CHECK_EQUAL_64(0x0100000000000000L, dst[4]);
   CHECK_EQUAL_64(src_base, x17);
-  CHECK_EQUAL_64(dst_base, x18);
+  CHECK_EQUAL_64(dst_base, x28);
   CHECK_EQUAL_64(src_base + 16, x19);
   CHECK_EQUAL_64(dst_base + 32, x20);
 }
@@ -6682,7 +6675,7 @@ TEST(add_sub_wide_imm) {
   __ Add(w12, w0, Operand(0x12345678));
   __ Add(w13, w1, Operand(0xFFFFFFFF));
 
-  __ Add(w18, w0, Operand(kWMinInt));
+  __ Add(w28, w0, Operand(kWMinInt));
   __ Sub(w19, w0, Operand(kWMinInt));
 
   __ Sub(x20, x0, Operand(0x1234567890ABCDEFUL));
@@ -6697,7 +6690,7 @@ TEST(add_sub_wide_imm) {
   CHECK_EQUAL_32(0x12345678, w12);
   CHECK_EQUAL_64(0x0, x13);
 
-  CHECK_EQUAL_32(kWMinInt, w18);
+  CHECK_EQUAL_32(kWMinInt, w28);
   CHECK_EQUAL_32(kWMinInt, w19);
 
   CHECK_EQUAL_64(-0x1234567890ABCDEFLL, x20);
@@ -6720,7 +6713,7 @@ TEST(add_sub_shifted) {
   __ Add(x13, x0, Operand(x1, ASR, 8));
   __ Add(x14, x0, Operand(x2, ASR, 8));
   __ Add(w15, w0, Operand(w1, ASR, 8));
-  __ Add(w18, w3, Operand(w1, ROR, 8));
+  __ Add(w28, w3, Operand(w1, ROR, 8));
   __ Add(x19, x3, Operand(x1, ROR, 8));
 
   __ Sub(x20, x3, Operand(x2));
@@ -6741,7 +6734,7 @@ TEST(add_sub_shifted) {
   CHECK_EQUAL_64(0x000123456789ABCDL, x13);
   CHECK_EQUAL_64(0xFFFEDCBA98765432L, x14);
   CHECK_EQUAL_64(0xFF89ABCD, x15);
-  CHECK_EQUAL_64(0xEF89ABCC, x18);
+  CHECK_EQUAL_64(0xEF89ABCC, x28);
   CHECK_EQUAL_64(0xEF0123456789ABCCL, x19);
 
   CHECK_EQUAL_64(0x0123456789ABCDEFL, x20);
@@ -6773,7 +6766,7 @@ TEST(add_sub_extended) {
   __ Add(x15, x0, Operand(x1, SXTB, 1));
   __ Add(x16, x0, Operand(x1, SXTH, 2));
   __ Add(x17, x0, Operand(x1, SXTW, 3));
-  __ Add(x18, x0, Operand(x2, SXTB, 0));
+  __ Add(x4, x0, Operand(x2, SXTB, 0));
   __ Add(x19, x0, Operand(x2, SXTB, 1));
   __ Add(x20, x0, Operand(x2, SXTH, 2));
   __ Add(x21, x0, Operand(x2, SXTW, 3));
@@ -6803,7 +6796,7 @@ TEST(add_sub_extended) {
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFDEL, x15);
   CHECK_EQUAL_64(0xFFFFFFFFFFFF37BCL, x16);
   CHECK_EQUAL_64(0xFFFFFFFC4D5E6F78L, x17);
-  CHECK_EQUAL_64(0x10L, x18);
+  CHECK_EQUAL_64(0x10L, x4);
   CHECK_EQUAL_64(0x20L, x19);
   CHECK_EQUAL_64(0xC840L, x20);
   CHECK_EQUAL_64(0x3B2A19080L, x21);
@@ -7430,7 +7423,7 @@ TEST(adc_sbc_shift) {
   // Set the C flag.
   __ Cmp(w0, Operand(w0));
 
-  __ Adc(x18, x2, Operand(x3));
+  __ Adc(x28, x2, Operand(x3));
   __ Adc(x19, x0, Operand(x1, LSL, 60));
   __ Sbc(x20, x4, Operand(x3, LSR, 4));
   __ Adc(x21, x2, Operand(x3, ASR, 4));
@@ -7457,7 +7450,7 @@ TEST(adc_sbc_shift) {
   CHECK_EQUAL_32(0x91111110, w13);
   CHECK_EQUAL_32(0x9A222221, w14);
 
-  CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFLL + 1, x18);
+  CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFLL + 1, x28);
   CHECK_EQUAL_64((1LL << 60) + 1, x19);
   CHECK_EQUAL_64(0xF0123456789ABCDDL + 1, x20);
   CHECK_EQUAL_64(0x0111111111111110L + 1, x21);
@@ -7581,7 +7574,7 @@ TEST(adc_sbc_wide_imm) {
   // Set the C flag.
   __ Cmp(w0, Operand(w0));
 
-  __ Adc(x18, x0, Operand(0x1234567890ABCDEFUL));
+  __ Adc(x28, x0, Operand(0x1234567890ABCDEFUL));
   __ Adc(w19, w0, Operand(0xFFFFFFFF));
   __ Sbc(x20, x0, Operand(0x1234567890ABCDEFUL));
   __ Sbc(w21, w0, Operand(0xFFFFFFFF));
@@ -7598,7 +7591,7 @@ TEST(adc_sbc_wide_imm) {
   CHECK_EQUAL_64(0xFFFFFFFF, x11);
   CHECK_EQUAL_64(0xFFFF, x12);
 
-  CHECK_EQUAL_64(0x1234567890ABCDEFUL + 1, x18);
+  CHECK_EQUAL_64(0x1234567890ABCDEFUL + 1, x28);
   CHECK_EQUAL_64(0, x19);
   CHECK_EQUAL_64(0xEDCBA9876F543211UL, x20);
   CHECK_EQUAL_64(1, x21);
@@ -7758,7 +7751,7 @@ TEST(cmp_shift) {
   SETUP();
 
   START();
-  __ Mov(x18, 0xF0000000);
+  __ Mov(x28, 0xF0000000);
   __ Mov(x19, 0xF000000010000000UL);
   __ Mov(x20, 0xF0000000F0000000UL);
   __ Mov(x21, 0x7800000078000000UL);
@@ -7778,7 +7771,7 @@ TEST(cmp_shift) {
   __ Cmp(w19, Operand(w23, LSR, 3));
   __ Mrs(x2, NZCV);
 
-  __ Cmp(x18, Operand(x24, LSR, 4));
+  __ Cmp(x28, Operand(x24, LSR, 4));
   __ Mrs(x3, NZCV);
 
   __ Cmp(w20, Operand(w25, ASR, 2));
@@ -7993,7 +7986,7 @@ TEST(csel) {
   __ Cneg(x12, x24, ne);
 
   __ csel(w15, w24, w25, al);
-  __ csel(x18, x24, x25, nv);
+  __ csel(x28, x24, x25, nv);
 
   __ CzeroX(x24, ne);
   __ CzeroX(x25, eq);
@@ -8020,7 +8013,7 @@ TEST(csel) {
   CHECK_EQUAL_64(0x0000000F, x13);
   CHECK_EQUAL_64(0x0000000F0000000FUL, x14);
   CHECK_EQUAL_64(0x0000000F, x15);
-  CHECK_EQUAL_64(0x0000000F0000000FUL, x18);
+  CHECK_EQUAL_64(0x0000000F0000000FUL, x28);
   CHECK_EQUAL_64(0, x24);
   CHECK_EQUAL_64(0x0000001F0000001FUL, x25);
   CHECK_EQUAL_64(0x0000001F0000001FUL, x26);
@@ -8032,11 +8025,11 @@ TEST(csel_imm) {
   SETUP();
 
   START();
-  __ Mov(x18, 0);
+  __ Mov(x28, 0);
   __ Mov(x19, 0x80000000);
   __ Mov(x20, 0x8000000000000000UL);
 
-  __ Cmp(x18, Operand(0));
+  __ Cmp(x28, Operand(0));
   __ Csel(w0, w19, -2, ne);
   __ Csel(w1, w19, -1, ne);
   __ Csel(w2, w19, 0, ne);
@@ -8098,7 +8091,7 @@ TEST(lslv) {
 
   __ Lsl(x16, x0, x1);
   __ Lsl(x17, x0, x2);
-  __ Lsl(x18, x0, x3);
+  __ Lsl(x28, x0, x3);
   __ Lsl(x19, x0, x4);
   __ Lsl(x20, x0, x5);
   __ Lsl(x21, x0, x6);
@@ -8116,7 +8109,7 @@ TEST(lslv) {
   CHECK_EQUAL_64(value, x0);
   CHECK_EQUAL_64(value << (shift[0] & 63), x16);
   CHECK_EQUAL_64(value << (shift[1] & 63), x17);
-  CHECK_EQUAL_64(value << (shift[2] & 63), x18);
+  CHECK_EQUAL_64(value << (shift[2] & 63), x28);
   CHECK_EQUAL_64(value << (shift[3] & 63), x19);
   CHECK_EQUAL_64(value << (shift[4] & 63), x20);
   CHECK_EQUAL_64(value << (shift[5] & 63), x21);
@@ -8148,7 +8141,7 @@ TEST(lsrv) {
 
   __ Lsr(x16, x0, x1);
   __ Lsr(x17, x0, x2);
-  __ Lsr(x18, x0, x3);
+  __ Lsr(x28, x0, x3);
   __ Lsr(x19, x0, x4);
   __ Lsr(x20, x0, x5);
   __ Lsr(x21, x0, x6);
@@ -8166,7 +8159,7 @@ TEST(lsrv) {
   CHECK_EQUAL_64(value, x0);
   CHECK_EQUAL_64(value >> (shift[0] & 63), x16);
   CHECK_EQUAL_64(value >> (shift[1] & 63), x17);
-  CHECK_EQUAL_64(value >> (shift[2] & 63), x18);
+  CHECK_EQUAL_64(value >> (shift[2] & 63), x28);
   CHECK_EQUAL_64(value >> (shift[3] & 63), x19);
   CHECK_EQUAL_64(value >> (shift[4] & 63), x20);
   CHECK_EQUAL_64(value >> (shift[5] & 63), x21);
@@ -8200,7 +8193,7 @@ TEST(asrv) {
 
   __ Asr(x16, x0, x1);
   __ Asr(x17, x0, x2);
-  __ Asr(x18, x0, x3);
+  __ Asr(x28, x0, x3);
   __ Asr(x19, x0, x4);
   __ Asr(x20, x0, x5);
   __ Asr(x21, x0, x6);
@@ -8218,7 +8211,7 @@ TEST(asrv) {
   CHECK_EQUAL_64(value, x0);
   CHECK_EQUAL_64(value >> (shift[0] & 63), x16);
   CHECK_EQUAL_64(value >> (shift[1] & 63), x17);
-  CHECK_EQUAL_64(value >> (shift[2] & 63), x18);
+  CHECK_EQUAL_64(value >> (shift[2] & 63), x28);
   CHECK_EQUAL_64(value >> (shift[3] & 63), x19);
   CHECK_EQUAL_64(value >> (shift[4] & 63), x20);
   CHECK_EQUAL_64(value >> (shift[5] & 63), x21);
@@ -8252,7 +8245,7 @@ TEST(rorv) {
 
   __ Ror(x16, x0, x1);
   __ Ror(x17, x0, x2);
-  __ Ror(x18, x0, x3);
+  __ Ror(x28, x0, x3);
   __ Ror(x19, x0, x4);
   __ Ror(x20, x0, x5);
   __ Ror(x21, x0, x6);
@@ -8270,7 +8263,7 @@ TEST(rorv) {
   CHECK_EQUAL_64(value, x0);
   CHECK_EQUAL_64(0xF0123456789ABCDEUL, x16);
   CHECK_EQUAL_64(0xEF0123456789ABCDUL, x17);
-  CHECK_EQUAL_64(0xDEF0123456789ABCUL, x18);
+  CHECK_EQUAL_64(0xDEF0123456789ABCUL, x28);
   CHECK_EQUAL_64(0xCDEF0123456789ABUL, x19);
   CHECK_EQUAL_64(0xABCDEF0123456789UL, x20);
   CHECK_EQUAL_64(0x789ABCDEF0123456UL, x21);
@@ -8338,7 +8331,7 @@ TEST(sbfm) {
   __ sbfm(w17, w2, 24, 15);
 
   // Aliases.
-  __ Asr(x18, x1, 32);
+  __ Asr(x3, x1, 32);
   __ Asr(x19, x2, 32);
   __ Sbfiz(x20, x1, 8, 16);
   __ Sbfiz(x21, x2, 8, 16);
@@ -8364,7 +8357,7 @@ TEST(sbfm) {
   CHECK_EQUAL_32(0x54, w16);
   CHECK_EQUAL_32(0x00321000, w17);
 
-  CHECK_EQUAL_64(0x01234567L, x18);
+  CHECK_EQUAL_64(0x01234567L, x3);
   CHECK_EQUAL_64(0xFFFFFFFFFEDCBA98L, x19);
   CHECK_EQUAL_64(0xFFFFFFFFFFCDEF00L, x20);
   CHECK_EQUAL_64(0x321000L, x21);
@@ -8403,7 +8396,7 @@ TEST(ubfm) {
   __ Lsl(x15, x1, 63);
   __ Lsl(x16, x1, 0);
   __ Lsr(x17, x1, 32);
-  __ Ubfiz(x18, x1, 8, 16);
+  __ Ubfiz(x3, x1, 8, 16);
   __ Ubfx(x19, x1, 8, 16);
   __ Uxtb(x20, x1);
   __ Uxth(x21, x1);
@@ -8425,7 +8418,7 @@ TEST(ubfm) {
   CHECK_EQUAL_64(0x8000000000000000L, x15);
   CHECK_EQUAL_64(0x0123456789ABCDEFL, x16);
   CHECK_EQUAL_64(0x01234567L, x17);
-  CHECK_EQUAL_64(0xCDEF00L, x18);
+  CHECK_EQUAL_64(0xCDEF00L, x3);
   CHECK_EQUAL_64(0xABCDL, x19);
   CHECK_EQUAL_64(0xEFL, x20);
   CHECK_EQUAL_64(0xCDEFL, x21);
@@ -9359,8 +9352,8 @@ TEST(fcmp) {
 
     __ Fmov(s8, 0.0);
     __ Fmov(s9, 0.5);
-    __ Mov(w18, 0x7F800001);  // Single precision NaN.
-    __ Fmov(s18, w18);
+    __ Mov(w19, 0x7F800001);  // Single precision NaN.
+    __ Fmov(s18, w19);
 
     __ Fcmp(s8, s8);
     __ Mrs(x0, NZCV);
@@ -10190,6 +10183,9 @@ TEST(fcvtas) {
   INIT_V8();
   SETUP();
 
+  int64_t scratch = 0;
+  uintptr_t scratch_base = reinterpret_cast<uintptr_t>(&scratch);
+
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
@@ -10207,8 +10203,8 @@ TEST(fcvtas) {
   __ Fmov(d13, kFP64NegativeInfinity);
   __ Fmov(d14, kWMaxInt - 1);
   __ Fmov(d15, kWMinInt + 1);
+  __ Fmov(s16, 2.5);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 2.5);
   __ Fmov(s19, -2.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10239,7 +10235,6 @@ TEST(fcvtas) {
   __ Fcvtas(w14, d14);
   __ Fcvtas(w15, d15);
   __ Fcvtas(x17, s17);
-  __ Fcvtas(x18, s18);
   __ Fcvtas(x19, s19);
   __ Fcvtas(x20, s20);
   __ Fcvtas(x21, s21);
@@ -10250,6 +10245,12 @@ TEST(fcvtas) {
   __ Fcvtas(x26, d26);
   __ Fcvtas(x27, d27);
   __ Fcvtas(x28, d28);
+
+  // Save results to the scratch memory, for those that don't fit in registers.
+  __ Mov(x30, scratch_base);
+  __ Fcvtas(x29, s16);
+  __ Str(x29, MemOperand(x30));
+
   __ Fcvtas(x29, d29);
   __ Fcvtas(x30, d30);
   END();
@@ -10272,8 +10273,8 @@ TEST(fcvtas) {
   CHECK_EQUAL_64(0x80000000, x13);
   CHECK_EQUAL_64(0x7FFFFFFE, x14);
   CHECK_EQUAL_64(0x80000001, x15);
+  CHECK_EQUAL_64(3, scratch);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(3, x18);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFDUL, x19);
   CHECK_EQUAL_64(0x7FFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0x8000000000000000UL, x21);
@@ -10339,7 +10340,7 @@ TEST(fcvtau) {
   __ Fcvtau(w15, d15);
   __ Fcvtau(x16, s16);
   __ Fcvtau(x17, s17);
-  __ Fcvtau(x18, s18);
+  __ Fcvtau(x7, s18);
   __ Fcvtau(x19, s19);
   __ Fcvtau(x20, s20);
   __ Fcvtau(x21, s21);
@@ -10371,7 +10372,7 @@ TEST(fcvtau) {
   CHECK_EQUAL_64(0xFFFFFFFE, x14);
   CHECK_EQUAL_64(1, x16);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(3, x18);
+  CHECK_EQUAL_64(3, x7);
   CHECK_EQUAL_64(0, x19);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0, x21);
@@ -10389,6 +10390,9 @@ TEST(fcvtms) {
   INIT_V8();
   SETUP();
 
+  int64_t scratch = 0;
+  uintptr_t scratch_base = reinterpret_cast<uintptr_t>(&scratch);
+
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
@@ -10406,8 +10410,8 @@ TEST(fcvtms) {
   __ Fmov(d13, kFP64NegativeInfinity);
   __ Fmov(d14, kWMaxInt - 1);
   __ Fmov(d15, kWMinInt + 1);
+  __ Fmov(s16, 1.5);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 1.5);
   __ Fmov(s19, -1.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10438,7 +10442,6 @@ TEST(fcvtms) {
   __ Fcvtms(w14, d14);
   __ Fcvtms(w15, d15);
   __ Fcvtms(x17, s17);
-  __ Fcvtms(x18, s18);
   __ Fcvtms(x19, s19);
   __ Fcvtms(x20, s20);
   __ Fcvtms(x21, s21);
@@ -10449,6 +10452,12 @@ TEST(fcvtms) {
   __ Fcvtms(x26, d26);
   __ Fcvtms(x27, d27);
   __ Fcvtms(x28, d28);
+
+  // Save results to the scratch memory, for those that don't fit in registers.
+  __ Mov(x30, scratch_base);
+  __ Fcvtms(x29, s16);
+  __ Str(x29, MemOperand(x30));
+
   __ Fcvtms(x29, d29);
   __ Fcvtms(x30, d30);
   END();
@@ -10471,8 +10480,8 @@ TEST(fcvtms) {
   CHECK_EQUAL_64(0x80000000, x13);
   CHECK_EQUAL_64(0x7FFFFFFE, x14);
   CHECK_EQUAL_64(0x80000001, x15);
+  CHECK_EQUAL_64(1, scratch);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(1, x18);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFEUL, x19);
   CHECK_EQUAL_64(0x7FFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0x8000000000000000UL, x21);
@@ -10491,6 +10500,9 @@ TEST(fcvtmu) {
   INIT_V8();
   SETUP();
 
+  int64_t scratch = 0;
+  uintptr_t scratch_base = reinterpret_cast<uintptr_t>(&scratch);
+
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
@@ -10508,8 +10520,8 @@ TEST(fcvtmu) {
   __ Fmov(d13, kFP64NegativeInfinity);
   __ Fmov(d14, kWMaxInt - 1);
   __ Fmov(d15, kWMinInt + 1);
+  __ Fmov(s16, 1.5);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 1.5);
   __ Fmov(s19, -1.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10538,8 +10550,8 @@ TEST(fcvtmu) {
   __ Fcvtmu(w12, d12);
   __ Fcvtmu(w13, d13);
   __ Fcvtmu(w14, d14);
+  __ Fcvtmu(w15, d15);
   __ Fcvtmu(x17, s17);
-  __ Fcvtmu(x18, s18);
   __ Fcvtmu(x19, s19);
   __ Fcvtmu(x20, s20);
   __ Fcvtmu(x21, s21);
@@ -10550,6 +10562,12 @@ TEST(fcvtmu) {
   __ Fcvtmu(x26, d26);
   __ Fcvtmu(x27, d27);
   __ Fcvtmu(x28, d28);
+
+  // Save results to the scratch memory, for those that don't fit in registers.
+  __ Mov(x30, scratch_base);
+  __ Fcvtmu(x29, s16);
+  __ Str(x29, MemOperand(x30));
+
   __ Fcvtmu(x29, d29);
   __ Fcvtmu(x30, d30);
   END();
@@ -10571,8 +10589,9 @@ TEST(fcvtmu) {
   CHECK_EQUAL_64(0xFFFFFFFF, x12);
   CHECK_EQUAL_64(0, x13);
   CHECK_EQUAL_64(0x7FFFFFFE, x14);
+  CHECK_EQUAL_64(0x0, x15);
+  CHECK_EQUAL_64(1, scratch);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(1, x18);
   CHECK_EQUAL_64(0x0UL, x19);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0x0UL, x21);
@@ -10591,6 +10610,9 @@ TEST(fcvtns) {
   INIT_V8();
   SETUP();
 
+  int64_t scratch = 0;
+  uintptr_t scratch_base = reinterpret_cast<uintptr_t>(&scratch);
+
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
@@ -10608,8 +10630,8 @@ TEST(fcvtns) {
   __ Fmov(d13, kFP64NegativeInfinity);
   __ Fmov(d14, kWMaxInt - 1);
   __ Fmov(d15, kWMinInt + 1);
+  __ Fmov(s16, 1.5);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 1.5);
   __ Fmov(s19, -1.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10640,7 +10662,6 @@ TEST(fcvtns) {
   __ Fcvtns(w14, d14);
   __ Fcvtns(w15, d15);
   __ Fcvtns(x17, s17);
-  __ Fcvtns(x18, s18);
   __ Fcvtns(x19, s19);
   __ Fcvtns(x20, s20);
   __ Fcvtns(x21, s21);
@@ -10651,6 +10672,12 @@ TEST(fcvtns) {
   __ Fcvtns(x26, d26);
   __ Fcvtns(x27, d27);
 //  __ Fcvtns(x28, d28);
+
+  // Save results to the scratch memory, for those that don't fit in registers.
+  __ Mov(x30, scratch_base);
+  __ Fcvtns(x29, s16);
+  __ Str(x29, MemOperand(x30));
+
   __ Fcvtns(x29, d29);
   __ Fcvtns(x30, d30);
   END();
@@ -10673,8 +10700,8 @@ TEST(fcvtns) {
   CHECK_EQUAL_64(0x80000000, x13);
   CHECK_EQUAL_64(0x7FFFFFFE, x14);
   CHECK_EQUAL_64(0x80000001, x15);
+  CHECK_EQUAL_64(2, scratch);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(2, x18);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFEUL, x19);
   CHECK_EQUAL_64(0x7FFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0x8000000000000000UL, x21);
@@ -10701,6 +10728,7 @@ TEST(fcvtnu) {
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0xFFFFFF00);  // Largest float < UINT32_MAX.
+  __ Fmov(s7, 1.5);
   __ Fmov(d8, 1.0);
   __ Fmov(d9, 1.1);
   __ Fmov(d10, 1.5);
@@ -10710,7 +10738,6 @@ TEST(fcvtnu) {
   __ Fmov(d14, 0xFFFFFFFE);
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 1.5);
   __ Fmov(s19, -1.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10730,6 +10757,7 @@ TEST(fcvtnu) {
   __ Fcvtnu(w4, s4);
   __ Fcvtnu(w5, s5);
   __ Fcvtnu(w6, s6);
+  __ Fcvtnu(x7, s7);
   __ Fcvtnu(w8, d8);
   __ Fcvtnu(w9, d9);
   __ Fcvtnu(w10, d10);
@@ -10740,7 +10768,6 @@ TEST(fcvtnu) {
   __ Fcvtnu(w15, d15);
   __ Fcvtnu(x16, s16);
   __ Fcvtnu(x17, s17);
-  __ Fcvtnu(x18, s18);
   __ Fcvtnu(x19, s19);
   __ Fcvtnu(x20, s20);
   __ Fcvtnu(x21, s21);
@@ -10763,6 +10790,7 @@ TEST(fcvtnu) {
   CHECK_EQUAL_64(0xFFFFFFFF, x4);
   CHECK_EQUAL_64(0, x5);
   CHECK_EQUAL_64(0xFFFFFF00, x6);
+  CHECK_EQUAL_64(2, x7);
   CHECK_EQUAL_64(1, x8);
   CHECK_EQUAL_64(1, x9);
   CHECK_EQUAL_64(2, x10);
@@ -10772,7 +10800,6 @@ TEST(fcvtnu) {
   CHECK_EQUAL_64(0xFFFFFFFE, x14);
   CHECK_EQUAL_64(1, x16);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(2, x18);
   CHECK_EQUAL_64(0, x19);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0, x21);
@@ -10790,6 +10817,9 @@ TEST(fcvtzs) {
   INIT_V8();
   SETUP();
 
+  int64_t scratch = 0;
+  uintptr_t scratch_base = reinterpret_cast<uintptr_t>(&scratch);
+
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
@@ -10807,8 +10837,8 @@ TEST(fcvtzs) {
   __ Fmov(d13, kFP64NegativeInfinity);
   __ Fmov(d14, kWMaxInt - 1);
   __ Fmov(d15, kWMinInt + 1);
+  __ Fmov(s16, 1.5);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 1.5);
   __ Fmov(s19, -1.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10839,7 +10869,6 @@ TEST(fcvtzs) {
   __ Fcvtzs(w14, d14);
   __ Fcvtzs(w15, d15);
   __ Fcvtzs(x17, s17);
-  __ Fcvtzs(x18, s18);
   __ Fcvtzs(x19, s19);
   __ Fcvtzs(x20, s20);
   __ Fcvtzs(x21, s21);
@@ -10850,6 +10879,12 @@ TEST(fcvtzs) {
   __ Fcvtzs(x26, d26);
   __ Fcvtzs(x27, d27);
   __ Fcvtzs(x28, d28);
+
+  // Save results to the scratch memory, for those that don't fit in registers.
+  __ Mov(x30, scratch_base);
+  __ Fcvtmu(x29, s16);
+  __ Str(x29, MemOperand(x30));
+
   __ Fcvtzs(x29, d29);
   __ Fcvtzs(x30, d30);
   END();
@@ -10872,8 +10907,8 @@ TEST(fcvtzs) {
   CHECK_EQUAL_64(0x80000000, x13);
   CHECK_EQUAL_64(0x7FFFFFFE, x14);
   CHECK_EQUAL_64(0x80000001, x15);
+  CHECK_EQUAL_64(1, scratch);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(1, x18);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFUL, x19);
   CHECK_EQUAL_64(0x7FFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0x8000000000000000UL, x21);
@@ -10892,6 +10927,9 @@ TEST(fcvtzu) {
   INIT_V8();
   SETUP();
 
+  int64_t scratch = 0;
+  uintptr_t scratch_base = reinterpret_cast<uintptr_t>(&scratch);
+
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
@@ -10909,8 +10947,8 @@ TEST(fcvtzu) {
   __ Fmov(d13, kFP64NegativeInfinity);
   __ Fmov(d14, kWMaxInt - 1);
   __ Fmov(d15, kWMinInt + 1);
+  __ Fmov(s16, 1.5);
   __ Fmov(s17, 1.1);
-  __ Fmov(s18, 1.5);
   __ Fmov(s19, -1.5);
   __ Fmov(s20, kFP32PositiveInfinity);
   __ Fmov(s21, kFP32NegativeInfinity);
@@ -10939,8 +10977,8 @@ TEST(fcvtzu) {
   __ Fcvtzu(w12, d12);
   __ Fcvtzu(w13, d13);
   __ Fcvtzu(w14, d14);
+  __ Fcvtzu(w15, d15);
   __ Fcvtzu(x17, s17);
-  __ Fcvtzu(x18, s18);
   __ Fcvtzu(x19, s19);
   __ Fcvtzu(x20, s20);
   __ Fcvtzu(x21, s21);
@@ -10951,6 +10989,12 @@ TEST(fcvtzu) {
   __ Fcvtzu(x26, d26);
   __ Fcvtzu(x27, d27);
   __ Fcvtzu(x28, d28);
+
+  // Save results to the scratch memory, for those that don't fit in registers.
+  __ Mov(x30, scratch_base);
+  __ Fcvtzu(x29, s16);
+  __ Str(x29, MemOperand(x30));
+
   __ Fcvtzu(x29, d29);
   __ Fcvtzu(x30, d30);
   END();
@@ -10972,8 +11016,9 @@ TEST(fcvtzu) {
   CHECK_EQUAL_64(0xFFFFFFFF, x12);
   CHECK_EQUAL_64(0, x13);
   CHECK_EQUAL_64(0x7FFFFFFE, x14);
+  CHECK_EQUAL_64(0x0, x15);
+  CHECK_EQUAL_64(1, scratch);
   CHECK_EQUAL_64(1, x17);
-  CHECK_EQUAL_64(1, x18);
   CHECK_EQUAL_64(0x0UL, x19);
   CHECK_EQUAL_64(0xFFFFFFFFFFFFFFFFUL, x20);
   CHECK_EQUAL_64(0x0UL, x21);
@@ -11439,6 +11484,8 @@ TEST(zero_dest) {
   __ Mov(x0, 0);
   __ Mov(x1, literal_base);
   for (int i = 2; i < x30.code(); i++) {
+    // Skip x18, the platform register.
+    if (i == 18) continue;
     __ Add(Register::XRegFromCode(i), Register::XRegFromCode(i-1), x1);
   }
   before.Dump(&masm);
@@ -11503,6 +11550,8 @@ TEST(zero_dest_setflags) {
   __ Mov(x0, 0);
   __ Mov(x1, literal_base);
   for (int i = 2; i < 30; i++) {
+    // Skip x18, the platform register.
+    if (i == 18) continue;
     __ Add(Register::XRegFromCode(i), Register::XRegFromCode(i-1), x1);
   }
   before.Dump(&masm);
@@ -11858,10 +11907,14 @@ static void PushPopSimpleHelper(int reg_count, int reg_size,
 
   // Registers in the TmpList can be used by the macro assembler for debug code
   // (for example in 'Pop'), so we can't use them here.
-  static RegList const allowed = ~(masm.TmpList()->list());
+  // x18 is reserved for the platform register.
+  // Disallow x31 / xzr, to ensure this list has an even number of elements, to
+  // ensure alignment.
+  RegList allowed = ~(masm.TmpList()->list() | x18.bit() | x31.bit());
   if (reg_count == kPushPopMaxRegCount) {
     reg_count = CountSetBits(allowed, kNumberOfRegisters);
   }
+  DCHECK_EQ(reg_count % 2, 0);
   // Work out which registers to use, based on reg_size.
   auto r = CreateRegisterArray<Register, kNumberOfRegisters>();
   auto x = CreateRegisterArray<Register, kNumberOfRegisters>();
@@ -12245,7 +12298,7 @@ TEST(push_pop) {
   __ Claim(2);
   __ Push(w2, w2, w1, w1);
   __ Push(x3, x3);
-  __ Pop(w18, w19, w20, w21);
+  __ Pop(w30, w19, w20, w21);
   __ Pop(x22, x23);
 
   __ Claim(2);
@@ -12259,8 +12312,10 @@ TEST(push_pop) {
   __ Claim(2);
   __ PushXRegList(0);
   __ PopXRegList(0);
-  __ PushXRegList(0xFFFFFFFF);
-  __ PopXRegList(0xFFFFFFFF);
+  // Don't push/pop x18 (platform register) or xzr (for alignment)
+  RegList all_regs = 0xFFFFFFFF & ~(x18.bit() | x31.bit());
+  __ PushXRegList(all_regs);
+  __ PopXRegList(all_regs);
   __ Drop(12);
 
   END();
@@ -12287,7 +12342,7 @@ TEST(push_pop) {
   CHECK_EQUAL_32(0x33333333U, w15);
   CHECK_EQUAL_32(0x22222222U, w14);
 
-  CHECK_EQUAL_32(0x11111111U, w18);
+  CHECK_EQUAL_32(0x11111111U, w30);
   CHECK_EQUAL_32(0x11111111U, w19);
   CHECK_EQUAL_32(0x11111111U, w20);
   CHECK_EQUAL_32(0x11111111U, w21);