MIPS64: Move load/store instructions to macro-assembler.

test/cctest/test-assembler-mips64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 270 matching lines @@
     float fg;
   } T;
   T t;
 
   // Create a function that accepts &t, and loads, manipulates, and stores
   // the doubles t.a ... t.f.
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   // Double precision floating point instructions.
-  __ ldc1(f4, MemOperand(a0, offsetof(T, a)) );
-  __ ldc1(f6, MemOperand(a0, offsetof(T, b)) );
+  __ Ldc1(f4, MemOperand(a0, offsetof(T, a)));
+  __ Ldc1(f6, MemOperand(a0, offsetof(T, b)));
   __ add_d(f8, f4, f6);
-  __ sdc1(f8, MemOperand(a0, offsetof(T, c)) );  // c = a + b.
+  __ Sdc1(f8, MemOperand(a0, offsetof(T, c)));  // c = a + b.
 
   __ mov_d(f10, f8);  // c
   __ neg_d(f12, f6);  // -b
   __ sub_d(f10, f10, f12);
-  __ sdc1(f10, MemOperand(a0, offsetof(T, d)) );  // d = c - (-b).
+  __ Sdc1(f10, MemOperand(a0, offsetof(T, d)));  // d = c - (-b).
 
-  __ sdc1(f4, MemOperand(a0, offsetof(T, b)) );   // b = a.
+  __ Sdc1(f4, MemOperand(a0, offsetof(T, b)));  // b = a.
 
   __ li(a4, 120);
   __ mtc1(a4, f14);
   __ cvt_d_w(f14, f14);   // f14 = 120.0.
   __ mul_d(f10, f10, f14);
-  __ sdc1(f10, MemOperand(a0, offsetof(T, e)) );  // e = d * 120 = 1.8066e16.
+  __ Sdc1(f10, MemOperand(a0, offsetof(T, e)));  // e = d * 120 = 1.8066e16.
 
   __ div_d(f12, f10, f4);
-  __ sdc1(f12, MemOperand(a0, offsetof(T, f)) );  // f = e / a = 120.44.
+  __ Sdc1(f12, MemOperand(a0, offsetof(T, f)));  // f = e / a = 120.44.
 
   __ sqrt_d(f14, f12);
-  __ sdc1(f14, MemOperand(a0, offsetof(T, g)) );
+  __ Sdc1(f14, MemOperand(a0, offsetof(T, g)));
   // g = sqrt(f) = 10.97451593465515908537
 
   if (kArchVariant == kMips64r2) {
-    __ ldc1(f4, MemOperand(a0, offsetof(T, h)) );
-    __ ldc1(f6, MemOperand(a0, offsetof(T, i)) );
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, h)));
+    __ Ldc1(f6, MemOperand(a0, offsetof(T, i)));
     __ madd_d(f14, f6, f4, f6);
-    __ sdc1(f14, MemOperand(a0, offsetof(T, h)) );
+    __ Sdc1(f14, MemOperand(a0, offsetof(T, h)));
   }
 
   // Single precision floating point instructions.
-  __ lwc1(f4, MemOperand(a0, offsetof(T, fa)) );
-  __ lwc1(f6, MemOperand(a0, offsetof(T, fb)) );
+  __ Lwc1(f4, MemOperand(a0, offsetof(T, fa)));
+  __ Lwc1(f6, MemOperand(a0, offsetof(T, fb)));
   __ add_s(f8, f4, f6);
-  __ swc1(f8, MemOperand(a0, offsetof(T, fc)) );  // fc = fa + fb.
+  __ Swc1(f8, MemOperand(a0, offsetof(T, fc)));  // fc = fa + fb.
 
   __ neg_s(f10, f6);  // -fb
   __ sub_s(f10, f8, f10);
-  __ swc1(f10, MemOperand(a0, offsetof(T, fd)) );  // fd = fc - (-fb).
+  __ Swc1(f10, MemOperand(a0, offsetof(T, fd)));  // fd = fc - (-fb).
 
-  __ swc1(f4, MemOperand(a0, offsetof(T, fb)) );   // fb = fa.
+  __ Swc1(f4, MemOperand(a0, offsetof(T, fb)));  // fb = fa.
 
   __ li(t0, 120);
   __ mtc1(t0, f14);
   __ cvt_s_w(f14, f14);   // f14 = 120.0.
   __ mul_s(f10, f10, f14);
-  __ swc1(f10, MemOperand(a0, offsetof(T, fe)) );  // fe = fd * 120
+  __ Swc1(f10, MemOperand(a0, offsetof(T, fe)));  // fe = fd * 120
 
   __ div_s(f12, f10, f4);
-  __ swc1(f12, MemOperand(a0, offsetof(T, ff)) );  // ff = fe / fa
+  __ Swc1(f12, MemOperand(a0, offsetof(T, ff)));  // ff = fe / fa
 
   __ sqrt_s(f14, f12);
-  __ swc1(f14, MemOperand(a0, offsetof(T, fg)) );
+  __ Swc1(f14, MemOperand(a0, offsetof(T, fg)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   // Double test values.
@@ skipping 45 matching lines @@
   typedef struct {
     double a;
     double b;
     double c;
     double d;
     int64_t high;
     int64_t low;
   } T;
   T t;
 
-  Assembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
-  __ ldc1(f4, MemOperand(a0, offsetof(T, a)));
-  __ ldc1(f5, MemOperand(a0, offsetof(T, b)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(T, a)));
+  __ Ldc1(f5, MemOperand(a0, offsetof(T, b)));
 
   // Swap f4 and f5, by using 3 integer registers, a4-a6,
   // both two 32-bit chunks, and one 64-bit chunk.
   // mXhc1 is mips32/64-r2 only, not r1,
   // but we will not support r1 in practice.
   __ mfc1(a4, f4);
   __ mfhc1(a5, f4);
   __ dmfc1(a6, f5);
 
   __ mtc1(a4, f5);
   __ mthc1(a5, f5);
   __ dmtc1(a6, f4);
 
   // Store the swapped f4 and f5 back to memory.
-  __ sdc1(f4, MemOperand(a0, offsetof(T, a)));
-  __ sdc1(f5, MemOperand(a0, offsetof(T, c)));
+  __ Sdc1(f4, MemOperand(a0, offsetof(T, a)));
+  __ Sdc1(f5, MemOperand(a0, offsetof(T, c)));
 
   // Test sign extension of move operations from coprocessor.
-  __ ldc1(f4, MemOperand(a0, offsetof(T, d)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(T, d)));
   __ mfhc1(a4, f4);
   __ mfc1(a5, f4);
 
-  __ sd(a4, MemOperand(a0, offsetof(T, high)));
-  __ sd(a5, MemOperand(a0, offsetof(T, low)));
+  __ Sd(a4, MemOperand(a0, offsetof(T, high)));
+  __ Sd(a5, MemOperand(a0, offsetof(T, low)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.a = 1.5e22;
@@ skipping 18 matching lines @@
   HandleScope scope(isolate);
 
   typedef struct {
     double a;
     double b;
     int i;
     int j;
   } T;
   T t;
 
-  Assembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   // Load all structure elements to registers.
-  __ ldc1(f4, MemOperand(a0, offsetof(T, a)) );
-  __ ldc1(f6, MemOperand(a0, offsetof(T, b)) );
-  __ lw(a4, MemOperand(a0, offsetof(T, i)) );
-  __ lw(a5, MemOperand(a0, offsetof(T, j)) );
+  __ Ldc1(f4, MemOperand(a0, offsetof(T, a)));
+  __ Ldc1(f6, MemOperand(a0, offsetof(T, b)));
+  __ Lw(a4, MemOperand(a0, offsetof(T, i)));
+  __ Lw(a5, MemOperand(a0, offsetof(T, j)));
 
   // Convert double in f4 to int in element i.
   __ cvt_w_d(f8, f4);
   __ mfc1(a6, f8);
-  __ sw(a6, MemOperand(a0, offsetof(T, i)) );
+  __ Sw(a6, MemOperand(a0, offsetof(T, i)));
 
   // Convert double in f6 to int in element j.
   __ cvt_w_d(f10, f6);
   __ mfc1(a7, f10);
-  __ sw(a7, MemOperand(a0, offsetof(T, j)) );
+  __ Sw(a7, MemOperand(a0, offsetof(T, j)));
 
   // Convert int in original i (a4) to double in a.
   __ mtc1(a4, f12);
   __ cvt_d_w(f0, f12);
-  __ sdc1(f0, MemOperand(a0, offsetof(T, a)) );
+  __ Sdc1(f0, MemOperand(a0, offsetof(T, a)));
 
   // Convert int in original j (a5) to double in b.
   __ mtc1(a5, f14);
   __ cvt_d_w(f2, f14);
-  __ sdc1(f2, MemOperand(a0, offsetof(T, b)) );
+  __ Sdc1(f2, MemOperand(a0, offsetof(T, b)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.a = 1.5e4;
@@ skipping 21 matching lines @@
     int32_t si;
     int32_t r1;
     int32_t r2;
     int32_t r3;
     int32_t r4;
     int32_t r5;
     int32_t r6;
   } T;
   T t;
 
-  Assembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   // Basic word load/store.
-  __ lw(a4, MemOperand(a0, offsetof(T, ui)) );
-  __ sw(a4, MemOperand(a0, offsetof(T, r1)) );
+  __ Lw(a4, MemOperand(a0, offsetof(T, ui)));
+  __ Sw(a4, MemOperand(a0, offsetof(T, r1)));
 
   // lh with positive data.
-  __ lh(a5, MemOperand(a0, offsetof(T, ui)) );
-  __ sw(a5, MemOperand(a0, offsetof(T, r2)) );
+  __ Lh(a5, MemOperand(a0, offsetof(T, ui)));
+  __ Sw(a5, MemOperand(a0, offsetof(T, r2)));
 
   // lh with negative data.
-  __ lh(a6, MemOperand(a0, offsetof(T, si)) );
-  __ sw(a6, MemOperand(a0, offsetof(T, r3)) );
+  __ Lh(a6, MemOperand(a0, offsetof(T, si)));
+  __ Sw(a6, MemOperand(a0, offsetof(T, r3)));
 
   // lhu with negative data.
-  __ lhu(a7, MemOperand(a0, offsetof(T, si)) );
-  __ sw(a7, MemOperand(a0, offsetof(T, r4)) );
+  __ Lhu(a7, MemOperand(a0, offsetof(T, si)));
+  __ Sw(a7, MemOperand(a0, offsetof(T, r4)));
 
-  // lb with negative data.
-  __ lb(t0, MemOperand(a0, offsetof(T, si)) );
-  __ sw(t0, MemOperand(a0, offsetof(T, r5)) );
+  // Lb with negative data.
+  __ Lb(t0, MemOperand(a0, offsetof(T, si)));
+  __ Sw(t0, MemOperand(a0, offsetof(T, r5)));
 
   // sh writes only 1/2 of word.
   __ lui(t1, 0x3333);
   __ ori(t1, t1, 0x3333);
-  __ sw(t1, MemOperand(a0, offsetof(T, r6)) );
-  __ lhu(t1, MemOperand(a0, offsetof(T, si)) );
-  __ sh(t1, MemOperand(a0, offsetof(T, r6)) );
+  __ Sw(t1, MemOperand(a0, offsetof(T, r6)));
+  __ Lhu(t1, MemOperand(a0, offsetof(T, si)));
+  __ Sh(t1, MemOperand(a0, offsetof(T, r6)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.ui = 0x11223344;
@@ skipping 33 matching lines @@
     double f;
     int32_t result;
   } T;
   T t;
 
   // Create a function that accepts &t, and loads, manipulates, and stores
   // the doubles t.a ... t.f.
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label neither_is_nan, less_than, outa_here;
 
-  __ ldc1(f4, MemOperand(a0, offsetof(T, a)) );
-  __ ldc1(f6, MemOperand(a0, offsetof(T, b)) );
+  __ Ldc1(f4, MemOperand(a0, offsetof(T, a)));
+  __ Ldc1(f6, MemOperand(a0, offsetof(T, b)));
   if (kArchVariant != kMips64r6) {
     __ c(UN, D, f4, f6);
     __ bc1f(&neither_is_nan);
   } else {
     __ cmp(UN, L, f2, f4, f6);
     __ bc1eqz(&neither_is_nan, f2);
   }
   __ nop();
-  __ sw(zero_reg, MemOperand(a0, offsetof(T, result)) );
+  __ Sw(zero_reg, MemOperand(a0, offsetof(T, result)));
   __ Branch(&outa_here);
 
   __ bind(&neither_is_nan);
 
   if (kArchVariant == kMips64r6) {
     __ cmp(OLT, L, f2, f6, f4);
     __ bc1nez(&less_than, f2);
   } else {
     __ c(OLT, D, f6, f4, 2);
     __ bc1t(&less_than, 2);
   }
 
   __ nop();
-  __ sw(zero_reg, MemOperand(a0, offsetof(T, result)) );
+  __ Sw(zero_reg, MemOperand(a0, offsetof(T, result)));
   __ Branch(&outa_here);
 
   __ bind(&less_than);
   __ Addu(a4, zero_reg, Operand(1));
-  __ sw(a4, MemOperand(a0, offsetof(T, result)) );  // Set true.
-
+  __ Sw(a4, MemOperand(a0, offsetof(T, result)));  // Set true.
 
   // This test-case should have additional tests.
 
   __ bind(&outa_here);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
@@ skipping 38 matching lines @@
       int32_t result_rotrv_20;
       int32_t result_rotrv_24;
       int32_t result_rotrv_28;
     } T;
     T t;
 
     MacroAssembler assm(isolate, NULL, 0,
                         v8::internal::CodeObjectRequired::kYes);
 
     // Basic word load.
-    __ lw(a4, MemOperand(a0, offsetof(T, input)) );
+    __ Lw(a4, MemOperand(a0, offsetof(T, input)));
 
     // ROTR instruction (called through the Ror macro).
     __ Ror(a5, a4, 0x0004);
     __ Ror(a6, a4, 0x0008);
     __ Ror(a7, a4, 0x000c);
     __ Ror(t0, a4, 0x0010);
     __ Ror(t1, a4, 0x0014);
     __ Ror(t2, a4, 0x0018);
     __ Ror(t3, a4, 0x001c);
 
     // Basic word store.
-    __ sw(a5, MemOperand(a0, offsetof(T, result_rotr_4)) );
-    __ sw(a6, MemOperand(a0, offsetof(T, result_rotr_8)) );
-    __ sw(a7, MemOperand(a0, offsetof(T, result_rotr_12)) );
-    __ sw(t0, MemOperand(a0, offsetof(T, result_rotr_16)) );
-    __ sw(t1, MemOperand(a0, offsetof(T, result_rotr_20)) );
-    __ sw(t2, MemOperand(a0, offsetof(T, result_rotr_24)) );
-    __ sw(t3, MemOperand(a0, offsetof(T, result_rotr_28)) );
+    __ Sw(a5, MemOperand(a0, offsetof(T, result_rotr_4)));
+    __ Sw(a6, MemOperand(a0, offsetof(T, result_rotr_8)));
+    __ Sw(a7, MemOperand(a0, offsetof(T, result_rotr_12)));
+    __ Sw(t0, MemOperand(a0, offsetof(T, result_rotr_16)));
+    __ Sw(t1, MemOperand(a0, offsetof(T, result_rotr_20)));
+    __ Sw(t2, MemOperand(a0, offsetof(T, result_rotr_24)));
+    __ Sw(t3, MemOperand(a0, offsetof(T, result_rotr_28)));
 
     // ROTRV instruction (called through the Ror macro).
     __ li(t3, 0x0004);
     __ Ror(a5, a4, t3);
     __ li(t3, 0x0008);
     __ Ror(a6, a4, t3);
     __ li(t3, 0x000C);
     __ Ror(a7, a4, t3);
     __ li(t3, 0x0010);
     __ Ror(t0, a4, t3);
     __ li(t3, 0x0014);
     __ Ror(t1, a4, t3);
     __ li(t3, 0x0018);
     __ Ror(t2, a4, t3);
     __ li(t3, 0x001C);
     __ Ror(t3, a4, t3);
 
     // Basic word store.
-    __ sw(a5, MemOperand(a0, offsetof(T, result_rotrv_4)) );
-    __ sw(a6, MemOperand(a0, offsetof(T, result_rotrv_8)) );
-    __ sw(a7, MemOperand(a0, offsetof(T, result_rotrv_12)) );
-    __ sw(t0, MemOperand(a0, offsetof(T, result_rotrv_16)) );
-    __ sw(t1, MemOperand(a0, offsetof(T, result_rotrv_20)) );
-    __ sw(t2, MemOperand(a0, offsetof(T, result_rotrv_24)) );
-    __ sw(t3, MemOperand(a0, offsetof(T, result_rotrv_28)) );
+    __ Sw(a5, MemOperand(a0, offsetof(T, result_rotrv_4)));
+    __ Sw(a6, MemOperand(a0, offsetof(T, result_rotrv_8)));
+    __ Sw(a7, MemOperand(a0, offsetof(T, result_rotrv_12)));
+    __ Sw(t0, MemOperand(a0, offsetof(T, result_rotrv_16)));
+    __ Sw(t1, MemOperand(a0, offsetof(T, result_rotrv_20)));
+    __ Sw(t2, MemOperand(a0, offsetof(T, result_rotrv_24)));
+    __ Sw(t3, MemOperand(a0, offsetof(T, result_rotrv_28)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.input = 0x12345678;
@@ skipping 59 matching lines @@
     int32_t dbl_exp;
     int32_t long_hi;
     int32_t long_lo;
     int64_t long_as_int64;
     int32_t b_long_hi;
     int32_t b_long_lo;
     int64_t b_long_as_int64;
   } T;
   T t;
 
-  Assembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   if (kArchVariant == kMips64r2) {
     // Rewritten for FR=1 FPU mode:
     //  -  32 FP regs of 64-bits each, no odd/even pairs.
     //  -  Note that cvt_l_d/cvt_d_l ARE legal in FR=1 mode.
     // Load all structure elements to registers.
-    __ ldc1(f0, MemOperand(a0, offsetof(T, a)));
+    __ Ldc1(f0, MemOperand(a0, offsetof(T, a)));
 
     // Save the raw bits of the double.
     __ mfc1(a4, f0);
     __ mfhc1(a5, f0);
-    __ sw(a4, MemOperand(a0, offsetof(T, dbl_mant)));
-    __ sw(a5, MemOperand(a0, offsetof(T, dbl_exp)));
+    __ Sw(a4, MemOperand(a0, offsetof(T, dbl_mant)));
+    __ Sw(a5, MemOperand(a0, offsetof(T, dbl_exp)));
 
     // Convert double in f0 to long, save hi/lo parts.
     __ cvt_l_d(f0, f0);
     __ mfc1(a4, f0);  // f0 LS 32 bits of long.
     __ mfhc1(a5, f0);  // f0 MS 32 bits of long.
-    __ sw(a4, MemOperand(a0, offsetof(T, long_lo)));
-    __ sw(a5, MemOperand(a0, offsetof(T, long_hi)));
+    __ Sw(a4, MemOperand(a0, offsetof(T, long_lo)));
+    __ Sw(a5, MemOperand(a0, offsetof(T, long_hi)));
 
     // Combine the high/low ints, convert back to double.
     __ dsll32(a6, a5, 0);  // Move a5 to high bits of a6.
     __ or_(a6, a6, a4);
     __ dmtc1(a6, f1);
     __ cvt_d_l(f1, f1);
-    __ sdc1(f1, MemOperand(a0, offsetof(T, a_converted)));
-
+    __ Sdc1(f1, MemOperand(a0, offsetof(T, a_converted)));
 
     // Convert the b long integers to double b.
-    __ lw(a4, MemOperand(a0, offsetof(T, b_long_lo)));
-    __ lw(a5, MemOperand(a0, offsetof(T, b_long_hi)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, b_long_lo)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, b_long_hi)));
     __ mtc1(a4, f8);  // f8 LS 32-bits.
     __ mthc1(a5, f8);  // f8 MS 32-bits.
     __ cvt_d_l(f10, f8);
-    __ sdc1(f10, MemOperand(a0, offsetof(T, b)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(T, b)));
 
     // Convert double b back to long-int.
-    __ ldc1(f31, MemOperand(a0, offsetof(T, b)));
+    __ Ldc1(f31, MemOperand(a0, offsetof(T, b)));
     __ cvt_l_d(f31, f31);
     __ dmfc1(a7, f31);
-    __ sd(a7, MemOperand(a0, offsetof(T, b_long_as_int64)));
-
+    __ Sd(a7, MemOperand(a0, offsetof(T, b_long_as_int64)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.a = 2.147483647e9;       // 0x7fffffff -> 0x41DFFFFFFFC00000 as double.
@@ skipping 38 matching lines @@
       int32_t swl_1;
       int32_t swl_2;
       int32_t swl_3;
       int32_t swr_0;
       int32_t swr_1;
       int32_t swr_2;
       int32_t swr_3;
     } T;
     T t;
 
-    Assembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     // Test all combinations of LWL and vAddr.
-    __ lw(a4, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, reg_init)));
     __ lwl(a4, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a4, MemOperand(a0, offsetof(T, lwl_0)));
+    __ Sw(a4, MemOperand(a0, offsetof(T, lwl_0)));
 
-    __ lw(a5, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, reg_init)));
     __ lwl(a5, MemOperand(a0, offsetof(T, mem_init) + 1));
-    __ sw(a5, MemOperand(a0, offsetof(T, lwl_1)));
+    __ Sw(a5, MemOperand(a0, offsetof(T, lwl_1)));
 
-    __ lw(a6, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a6, MemOperand(a0, offsetof(T, reg_init)));
     __ lwl(a6, MemOperand(a0, offsetof(T, mem_init) + 2));
-    __ sw(a6, MemOperand(a0, offsetof(T, lwl_2)));
+    __ Sw(a6, MemOperand(a0, offsetof(T, lwl_2)));
 
-    __ lw(a7, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a7, MemOperand(a0, offsetof(T, reg_init)));
     __ lwl(a7, MemOperand(a0, offsetof(T, mem_init) + 3));
-    __ sw(a7, MemOperand(a0, offsetof(T, lwl_3)));
+    __ Sw(a7, MemOperand(a0, offsetof(T, lwl_3)));
 
     // Test all combinations of LWR and vAddr.
-    __ lw(a4, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, reg_init)));
     __ lwr(a4, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a4, MemOperand(a0, offsetof(T, lwr_0)));
+    __ Sw(a4, MemOperand(a0, offsetof(T, lwr_0)));
 
-    __ lw(a5, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, reg_init)));
     __ lwr(a5, MemOperand(a0, offsetof(T, mem_init) + 1));
-    __ sw(a5, MemOperand(a0, offsetof(T, lwr_1)));
+    __ Sw(a5, MemOperand(a0, offsetof(T, lwr_1)));
 
-    __ lw(a6, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a6, MemOperand(a0, offsetof(T, reg_init)));
     __ lwr(a6, MemOperand(a0, offsetof(T, mem_init) + 2));
-    __ sw(a6, MemOperand(a0, offsetof(T, lwr_2)) );
+    __ Sw(a6, MemOperand(a0, offsetof(T, lwr_2)));
 
-    __ lw(a7, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a7, MemOperand(a0, offsetof(T, reg_init)));
     __ lwr(a7, MemOperand(a0, offsetof(T, mem_init) + 3));
-    __ sw(a7, MemOperand(a0, offsetof(T, lwr_3)) );
+    __ Sw(a7, MemOperand(a0, offsetof(T, lwr_3)));
 
     // Test all combinations of SWL and vAddr.
-    __ lw(a4, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a4, MemOperand(a0, offsetof(T, swl_0)));
-    __ lw(a4, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a4, MemOperand(a0, offsetof(T, swl_0)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, reg_init)));
     __ swl(a4, MemOperand(a0, offsetof(T, swl_0)));
 
-    __ lw(a5, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a5, MemOperand(a0, offsetof(T, swl_1)));
-    __ lw(a5, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a5, MemOperand(a0, offsetof(T, swl_1)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, reg_init)));
     __ swl(a5, MemOperand(a0, offsetof(T, swl_1) + 1));
 
-    __ lw(a6, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a6, MemOperand(a0, offsetof(T, swl_2)));
-    __ lw(a6, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a6, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a6, MemOperand(a0, offsetof(T, swl_2)));
+    __ Lw(a6, MemOperand(a0, offsetof(T, reg_init)));
     __ swl(a6, MemOperand(a0, offsetof(T, swl_2) + 2));
 
-    __ lw(a7, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a7, MemOperand(a0, offsetof(T, swl_3)));
-    __ lw(a7, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a7, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a7, MemOperand(a0, offsetof(T, swl_3)));
+    __ Lw(a7, MemOperand(a0, offsetof(T, reg_init)));
     __ swl(a7, MemOperand(a0, offsetof(T, swl_3) + 3));
 
     // Test all combinations of SWR and vAddr.
-    __ lw(a4, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a4, MemOperand(a0, offsetof(T, swr_0)));
-    __ lw(a4, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a4, MemOperand(a0, offsetof(T, swr_0)));
+    __ Lw(a4, MemOperand(a0, offsetof(T, reg_init)));
     __ swr(a4, MemOperand(a0, offsetof(T, swr_0)));
 
-    __ lw(a5, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a5, MemOperand(a0, offsetof(T, swr_1)));
-    __ lw(a5, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a5, MemOperand(a0, offsetof(T, swr_1)));
+    __ Lw(a5, MemOperand(a0, offsetof(T, reg_init)));
     __ swr(a5, MemOperand(a0, offsetof(T, swr_1) + 1));
 
-    __ lw(a6, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a6, MemOperand(a0, offsetof(T, swr_2)));
-    __ lw(a6, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a6, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a6, MemOperand(a0, offsetof(T, swr_2)));
+    __ Lw(a6, MemOperand(a0, offsetof(T, reg_init)));
     __ swr(a6, MemOperand(a0, offsetof(T, swr_2) + 2));
 
-    __ lw(a7, MemOperand(a0, offsetof(T, mem_init)));
-    __ sw(a7, MemOperand(a0, offsetof(T, swr_3)));
-    __ lw(a7, MemOperand(a0, offsetof(T, reg_init)));
+    __ Lw(a7, MemOperand(a0, offsetof(T, mem_init)));
+    __ Sw(a7, MemOperand(a0, offsetof(T, swr_3)));
+    __ Lw(a7, MemOperand(a0, offsetof(T, reg_init)));
     __ swr(a7, MemOperand(a0, offsetof(T, swr_3) + 3));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
@@ skipping 60 matching lines @@
       int32_t  y2;
       int32_t  y3;
       int32_t  y4;
   } T;
   T t;
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ mov(t2, fp);  // Save frame pointer.
   __ mov(fp, a0);  // Access struct T by fp.
-  __ lw(a4, MemOperand(a0, offsetof(T, y)));
-  __ lw(a7, MemOperand(a0, offsetof(T, y4)));
+  __ Lw(a4, MemOperand(a0, offsetof(T, y)));
+  __ Lw(a7, MemOperand(a0, offsetof(T, y4)));
 
   __ addu(a5, a4, a7);
   __ subu(t0, a4, a7);
   __ nop();
   __ push(a4);  // These instructions disappear after opt.
   __ Pop();
   __ addu(a4, a4, a4);
   __ nop();
   __ Pop();     // These instructions disappear after opt.
   __ push(a7);
   __ nop();
   __ push(a7);  // These instructions disappear after opt.
   __ pop(a7);
   __ nop();
   __ push(a7);
   __ pop(t0);
   __ nop();
-  __ sw(a4, MemOperand(fp, offsetof(T, y)));
-  __ lw(a4, MemOperand(fp, offsetof(T, y)));
+  __ Sw(a4, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a4, MemOperand(fp, offsetof(T, y)));
   __ nop();
-  __ sw(a4, MemOperand(fp, offsetof(T, y)));
-  __ lw(a5, MemOperand(fp, offsetof(T, y)));
+  __ Sw(a4, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a5, MemOperand(fp, offsetof(T, y)));
   __ nop();
   __ push(a5);
-  __ lw(a5, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a5, MemOperand(fp, offsetof(T, y)));
   __ pop(a5);
   __ nop();
   __ push(a5);
-  __ lw(a6, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a5);
   __ nop();
   __ push(a5);
-  __ lw(a6, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a6);
   __ nop();
   __ push(a6);
-  __ lw(a6, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a5);
   __ nop();
   __ push(a5);
-  __ lw(a6, MemOperand(fp, offsetof(T, y)));
+  __ Lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a7);
   __ nop();
 
   __ mov(fp, t2);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
@@ skipping 24 matching lines @@
     double cvt_small_out;
     uint32_t trunc_big_out;
     uint32_t trunc_small_out;
     uint32_t cvt_big_in;
     uint32_t cvt_small_in;
   } T;
   T t;
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
-  __ sw(a4, MemOperand(a0, offsetof(T, cvt_small_in)));
+  __ Sw(a4, MemOperand(a0, offsetof(T, cvt_small_in)));
   __ Cvt_d_uw(f10, a4);
-  __ sdc1(f10, MemOperand(a0, offsetof(T, cvt_small_out)));
+  __ Sdc1(f10, MemOperand(a0, offsetof(T, cvt_small_out)));
 
   __ Trunc_uw_d(f10, f10, f4);
-  __ swc1(f10, MemOperand(a0, offsetof(T, trunc_small_out)));
+  __ Swc1(f10, MemOperand(a0, offsetof(T, trunc_small_out)));
 
-  __ sw(a4, MemOperand(a0, offsetof(T, cvt_big_in)));
+  __ Sw(a4, MemOperand(a0, offsetof(T, cvt_big_in)));
   __ Cvt_d_uw(f8, a4);
-  __ sdc1(f8, MemOperand(a0, offsetof(T, cvt_big_out)));
+  __ Sdc1(f8, MemOperand(a0, offsetof(T, cvt_big_out)));
 
   __ Trunc_uw_d(f8, f8, f4);
-  __ swc1(f8, MemOperand(a0, offsetof(T, trunc_big_out)));
+  __ Swc1(f8, MemOperand(a0, offsetof(T, trunc_big_out)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
@@ skipping 49 matching lines @@
   T t;
 
 #undef ROUND_STRUCT_ELEMENT
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // Save FCSR.
   __ cfc1(a1, FCSR);
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
-#define RUN_ROUND_TEST(x) \
-  __ cfc1(t0, FCSR);\
-  __ sw(t0, MemOperand(a0, offsetof(T, x##_isNaN2008))); \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, round_up_in))); \
-  __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, offsetof(T, x##_up_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, round_down_in))); \
-  __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, offsetof(T, x##_down_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, neg_round_up_in))); \
-  __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, offsetof(T, neg_##x##_up_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, neg_round_down_in))); \
-  __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, offsetof(T, neg_##x##_down_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, err1_in))); \
-  __ ctc1(zero_reg, FCSR); \
-  __ x##_w_d(f0, f0); \
-  __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, offsetof(T, x##_err1_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, err2_in))); \
-  __ ctc1(zero_reg, FCSR); \
-  __ x##_w_d(f0, f0); \
-  __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, offsetof(T, x##_err2_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, err3_in))); \
-  __ ctc1(zero_reg, FCSR); \
-  __ x##_w_d(f0, f0); \
-  __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, offsetof(T, x##_err3_out))); \
-  \
-  __ ldc1(f0, MemOperand(a0, offsetof(T, err4_in))); \
-  __ ctc1(zero_reg, FCSR); \
-  __ x##_w_d(f0, f0); \
-  __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, offsetof(T, x##_err4_out))); \
-  __ swc1(f0, MemOperand(a0, offsetof(T, x##_invalid_result)));
+#define RUN_ROUND_TEST(x)                                       \
+  __ cfc1(t0, FCSR);                                            \
+  __ Sw(t0, MemOperand(a0, offsetof(T, x##_isNaN2008)));        \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, round_up_in)));        \
+  __ x##_w_d(f0, f0);                                           \
+  __ Swc1(f0, MemOperand(a0, offsetof(T, x##_up_out)));         \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, round_down_in)));      \
+  __ x##_w_d(f0, f0);                                           \
+  __ Swc1(f0, MemOperand(a0, offsetof(T, x##_down_out)));       \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, neg_round_up_in)));    \
+  __ x##_w_d(f0, f0);                                           \
+  __ Swc1(f0, MemOperand(a0, offsetof(T, neg_##x##_up_out)));   \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, neg_round_down_in)));  \
+  __ x##_w_d(f0, f0);                                           \
+  __ Swc1(f0, MemOperand(a0, offsetof(T, neg_##x##_down_out))); \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, err1_in)));            \
+  __ ctc1(zero_reg, FCSR);                                      \
+  __ x##_w_d(f0, f0);                                           \
+  __ cfc1(a2, FCSR);                                            \
+  __ Sw(a2, MemOperand(a0, offsetof(T, x##_err1_out)));         \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, err2_in)));            \
+  __ ctc1(zero_reg, FCSR);                                      \
+  __ x##_w_d(f0, f0);                                           \
+  __ cfc1(a2, FCSR);                                            \
+  __ Sw(a2, MemOperand(a0, offsetof(T, x##_err2_out)));         \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, err3_in)));            \
+  __ ctc1(zero_reg, FCSR);                                      \
+  __ x##_w_d(f0, f0);                                           \
+  __ cfc1(a2, FCSR);                                            \
+  __ Sw(a2, MemOperand(a0, offsetof(T, x##_err3_out)));         \
+                                                                \
+  __ Ldc1(f0, MemOperand(a0, offsetof(T, err4_in)));            \
+  __ ctc1(zero_reg, FCSR);                                      \
+  __ x##_w_d(f0, f0);                                           \
+  __ cfc1(a2, FCSR);                                            \
+  __ Sw(a2, MemOperand(a0, offsetof(T, x##_err4_out)));         \
+  __ Swc1(f0, MemOperand(a0, offsetof(T, x##_invalid_result)));
 
   RUN_ROUND_TEST(round)
   RUN_ROUND_TEST(floor)
   RUN_ROUND_TEST(ceil)
   RUN_ROUND_TEST(trunc)
   RUN_ROUND_TEST(cvt)
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
@@ skipping 74 matching lines @@
     int64_t r8;
     int64_t r9;
     int64_t r10;
     int64_t r11;
     int64_t r12;
     uint32_t ui;
     int32_t si;
   };
   T t;
 
-  Assembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   // Basic 32-bit word load/store, with un-signed data.
-  __ lw(a4, MemOperand(a0, offsetof(T, ui)));
-  __ sw(a4, MemOperand(a0, offsetof(T, r1)));
+  __ Lw(a4, MemOperand(a0, offsetof(T, ui)));
+  __ Sw(a4, MemOperand(a0, offsetof(T, r1)));
 
   // Check that the data got zero-extended into 64-bit a4.
-  __ sd(a4, MemOperand(a0, offsetof(T, r2)));
+  __ Sd(a4, MemOperand(a0, offsetof(T, r2)));
 
   // Basic 32-bit word load/store, with SIGNED data.
-  __ lw(a5, MemOperand(a0, offsetof(T, si)));
-  __ sw(a5, MemOperand(a0, offsetof(T, r3)));
+  __ Lw(a5, MemOperand(a0, offsetof(T, si)));
+  __ Sw(a5, MemOperand(a0, offsetof(T, r3)));
 
   // Check that the data got sign-extended into 64-bit a4.
-  __ sd(a5, MemOperand(a0, offsetof(T, r4)));
+  __ Sd(a5, MemOperand(a0, offsetof(T, r4)));
 
   // 32-bit UNSIGNED word load/store, with SIGNED data.
-  __ lwu(a6, MemOperand(a0, offsetof(T, si)));
-  __ sw(a6, MemOperand(a0, offsetof(T, r5)));
+  __ Lwu(a6, MemOperand(a0, offsetof(T, si)));
+  __ Sw(a6, MemOperand(a0, offsetof(T, r5)));
 
   // Check that the data got zero-extended into 64-bit a4.
-  __ sd(a6, MemOperand(a0, offsetof(T, r6)));
+  __ Sd(a6, MemOperand(a0, offsetof(T, r6)));
 
   // lh with positive data.
-  __ lh(a5, MemOperand(a0, offsetof(T, ui)));
-  __ sw(a5, MemOperand(a0, offsetof(T, r7)));
+  __ Lh(a5, MemOperand(a0, offsetof(T, ui)));
+  __ Sw(a5, MemOperand(a0, offsetof(T, r7)));
 
   // lh with negative data.
-  __ lh(a6, MemOperand(a0, offsetof(T, si)));
-  __ sw(a6, MemOperand(a0, offsetof(T, r8)));
+  __ Lh(a6, MemOperand(a0, offsetof(T, si)));
+  __ Sw(a6, MemOperand(a0, offsetof(T, r8)));
 
   // lhu with negative data.
-  __ lhu(a7, MemOperand(a0, offsetof(T, si)));
-  __ sw(a7, MemOperand(a0, offsetof(T, r9)));
+  __ Lhu(a7, MemOperand(a0, offsetof(T, si)));
+  __ Sw(a7, MemOperand(a0, offsetof(T, r9)));
 
-  // lb with negative data.
-  __ lb(t0, MemOperand(a0, offsetof(T, si)));
-  __ sw(t0, MemOperand(a0, offsetof(T, r10)));
+  // Lb with negative data.
+  __ Lb(t0, MemOperand(a0, offsetof(T, si)));
+  __ Sw(t0, MemOperand(a0, offsetof(T, r10)));
 
   // sh writes only 1/2 of word.
-  __ lw(a4, MemOperand(a0, offsetof(T, ui)));
-  __ sh(a4, MemOperand(a0, offsetof(T, r11)));
-  __ lw(a4, MemOperand(a0, offsetof(T, si)));
-  __ sh(a4, MemOperand(a0, offsetof(T, r12)));
+  __ Lw(a4, MemOperand(a0, offsetof(T, ui)));
+  __ Sh(a4, MemOperand(a0, offsetof(T, r11)));
+  __ Lw(a4, MemOperand(a0, offsetof(T, si)));
+  __ Sh(a4, MemOperand(a0, offsetof(T, r12)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.ui = 0x44332211;
@@ skipping 91 matching lines @@
       float i;
       float j;
       float k;
       float l;
     } Test;
 
     Test test;
     // Integer part of test.
     __ addiu(t1, zero_reg, 1);                      // t1 = 1
     __ seleqz(t3, t1, zero_reg);                    // t3 = 1
-    __ sw(t3, MemOperand(a0, offsetof(Test, a)));  // a = 1
+    __ Sw(t3, MemOperand(a0, offsetof(Test, a)));   // a = 1
     __ seleqz(t2, t1, t1);                          // t2 = 0
-    __ sw(t2, MemOperand(a0, offsetof(Test, b)));  // b = 0
+    __ Sw(t2, MemOperand(a0, offsetof(Test, b)));   // b = 0
     __ selnez(t3, t1, zero_reg);                    // t3 = 1;
-    __ sw(t3, MemOperand(a0, offsetof(Test, c)));  // c = 0
+    __ Sw(t3, MemOperand(a0, offsetof(Test, c)));   // c = 0
     __ selnez(t3, t1, t1);                          // t3 = 1
-    __ sw(t3, MemOperand(a0, offsetof(Test, d)));  // d = 1
+    __ Sw(t3, MemOperand(a0, offsetof(Test, d)));   // d = 1
     // Floating point part of test.
-    __ ldc1(f0, MemOperand(a0, offsetof(Test, e)) );  // src
-    __ ldc1(f2, MemOperand(a0, offsetof(Test, f)) );  // test
-    __ lwc1(f8, MemOperand(a0, offsetof(Test, i)) );  // src
-    __ lwc1(f10, MemOperand(a0, offsetof(Test, j)) );  // test
+    __ Ldc1(f0, MemOperand(a0, offsetof(Test, e)));   // src
+    __ Ldc1(f2, MemOperand(a0, offsetof(Test, f)));   // test
+    __ Lwc1(f8, MemOperand(a0, offsetof(Test, i)));   // src
+    __ Lwc1(f10, MemOperand(a0, offsetof(Test, j)));  // test
     __ seleqz_d(f4, f0, f2);
     __ selnez_d(f6, f0, f2);
     __ seleqz_s(f12, f8, f10);
     __ selnez_s(f14, f8, f10);
-    __ sdc1(f4, MemOperand(a0, offsetof(Test, g)) );  // src
-    __ sdc1(f6, MemOperand(a0, offsetof(Test, h)) );  // src
-    __ swc1(f12, MemOperand(a0, offsetof(Test, k)) );  // src
-    __ swc1(f14, MemOperand(a0, offsetof(Test, l)) );  // src
+    __ Sdc1(f4, MemOperand(a0, offsetof(Test, g)));   // src
+    __ Sdc1(f6, MemOperand(a0, offsetof(Test, h)));   // src
+    __ Swc1(f12, MemOperand(a0, offsetof(Test, k)));  // src
+    __ Swc1(f14, MemOperand(a0, offsetof(Test, l)));  // src
     __ jr(ra);
     __ nop();
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
@@ skipping 83 matching lines @@
     float inputse[kTableLength] = {2.0,  3.0,  fnan, 3.0,   -0.0, 0.0, finf,
                                    fnan, 42.0, finf, fminf, finf, fnan};
     float inputsf[kTableLength] = {3.0,  2.0,  3.0,  fnan, 0.0,   -0.0, fnan,
                                    finf, finf, 42.0, finf, fminf, fnan};
     float outputsfmin[kTableLength] = {2.0,   2.0,   3.0,  3.0,  -0.0,
                                        -0.0,  finf,  finf, 42.0, 42.0,
                                        fminf, fminf, fnan};
     float outputsfmax[kTableLength] = {3.0,  3.0,  3.0,  3.0,  0.0,  0.0, finf,
                                        finf, finf, finf, finf, finf, fnan};
 
-    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
-    __ ldc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
-    __ lwc1(f2, MemOperand(a0, offsetof(TestFloat, e)));
-    __ lwc1(f6, MemOperand(a0, offsetof(TestFloat, f)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
+    __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
+    __ Lwc1(f2, MemOperand(a0, offsetof(TestFloat, e)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(TestFloat, f)));
     __ min_d(f10, f4, f8);
     __ max_d(f12, f4, f8);
     __ min_s(f14, f2, f6);
     __ max_s(f16, f2, f6);
-    __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
-    __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, d)));
-    __ swc1(f14, MemOperand(a0, offsetof(TestFloat, g)));
-    __ swc1(f16, MemOperand(a0, offsetof(TestFloat, h)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
+    __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, d)));
+    __ Swc1(f14, MemOperand(a0, offsetof(TestFloat, g)));
+    __ Swc1(f16, MemOperand(a0, offsetof(TestFloat, h)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 4; i < kTableLength; i++) {
       test.a = inputsa[i];
@@ skipping 84 matching lines @@
       2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
       -3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
       37778931862957161709568.0, 37778931862957161709569.0,
       37778931862957161709580.0, 37778931862957161709581.0,
       37778931862957161709582.0, 37778931862957161709583.0,
       37778931862957161709584.0, 37778931862957161709585.0,
       37778931862957161709586.0, 37778931862957161709587.0};
     int fcsr_inputs[4] =
       {kRoundToNearest, kRoundToZero, kRoundToPlusInf, kRoundToMinusInf};
     double* outputs[4] = {outputs_RN, outputs_RZ, outputs_RP, outputs_RM};
-    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)) );
-    __ lw(t0, MemOperand(a0, offsetof(TestFloat, fcsr)) );
+    __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
+    __ Lw(t0, MemOperand(a0, offsetof(TestFloat, fcsr)));
     __ ctc1(t0, FCSR);
     __ rint_d(f8, f4);
-    __ sdc1(f8, MemOperand(a0, offsetof(TestFloat, b)) );
+    __ Sdc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     for (int j = 0; j < 4; j++) {
@@ skipping 19 matching lines @@
     typedef struct test {
       double dd;
       double ds;
       double dt;
       float fd;
       float fs;
       float ft;
     } Test;
 
     Test test;
-    __ ldc1(f0, MemOperand(a0, offsetof(Test, dd)) );  // test
-    __ ldc1(f2, MemOperand(a0, offsetof(Test, ds)) );  // src1
-    __ ldc1(f4, MemOperand(a0, offsetof(Test, dt)) );  // src2
-    __ lwc1(f6, MemOperand(a0, offsetof(Test, fd)) );  // test
-    __ lwc1(f8, MemOperand(a0, offsetof(Test, fs)) );  // src1
-    __ lwc1(f10, MemOperand(a0, offsetof(Test, ft)) );  // src2
+    __ Ldc1(f0, MemOperand(a0, offsetof(Test, dd)));   // test
+    __ Ldc1(f2, MemOperand(a0, offsetof(Test, ds)));   // src1
+    __ Ldc1(f4, MemOperand(a0, offsetof(Test, dt)));   // src2
+    __ Lwc1(f6, MemOperand(a0, offsetof(Test, fd)));   // test
+    __ Lwc1(f8, MemOperand(a0, offsetof(Test, fs)));   // src1
+    __ Lwc1(f10, MemOperand(a0, offsetof(Test, ft)));  // src2
     __ sel_d(f0, f2, f4);
     __ sel_s(f6, f8, f10);
-    __ sdc1(f0, MemOperand(a0, offsetof(Test, dd)) );
-    __ swc1(f6, MemOperand(a0, offsetof(Test, fd)) );
+    __ Sdc1(f0, MemOperand(a0, offsetof(Test, dd)));
+    __ Swc1(f6, MemOperand(a0, offsetof(Test, fd)));
     __ jr(ra);
     __ nop();
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     const int test_size = 3;
     const int input_size = 5;
@@ skipping 105 matching lines @@
       2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
       -3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
       37778931862957161709568.0, 37778931862957161709569.0,
       37778931862957161709580.0, 37778931862957161709581.0,
       37778931862957161709582.0, 37778931862957161709583.0,
       37778931862957161709584.0, 37778931862957161709585.0,
       37778931862957161709586.0, 37778931862957161709587.0};
     int fcsr_inputs[4] =
       {kRoundToNearest, kRoundToZero, kRoundToPlusInf, kRoundToMinusInf};
     float* outputs[4] = {outputs_RN, outputs_RZ, outputs_RP, outputs_RM};
-    __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, a)) );
-    __ lw(t0, MemOperand(a0, offsetof(TestFloat, fcsr)) );
+    __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
+    __ Lw(t0, MemOperand(a0, offsetof(TestFloat, fcsr)));
     __ cfc1(t1, FCSR);
     __ ctc1(t0, FCSR);
     __ rint_s(f8, f4);
-    __ swc1(f8, MemOperand(a0, offsetof(TestFloat, b)) );
+    __ Swc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
     __ ctc1(t1, FCSR);
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
@@ skipping 55 matching lines @@
                                    9.8,  9.8,  9.8,  -9.8,  -11.2, -9.8,
                                    3.0,  fnan, -0.0, 0.0,   fnan,  finf,
                                    finf, 42.0, finf, fminf, fnan};
     float resf[kTableLength] = {
         4.8, 4.8, 6.1,  9.8,  -8.9, -9.8, 9.8,  -8.9, -9.8,  -9.8,  -8.9, -9.8,
         3.0, 3.0, -0.0, -0.0, finf, finf, 42.0, 42.0, fminf, fminf, fnan};
     float resf1[kTableLength] = {
         5.3, 5.3, 6.1, -10.0, 9.8,  9.8,  -10.0, 9.8,  9.8,  -10.0, -11.2, -9.8,
         3.0, 3.0, 0.0, 0.0,   finf, finf, finf,  finf, finf, finf,  fnan};
 
-    __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
-    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, b)) );
-    __ lwc1(f8, MemOperand(a0, offsetof(TestFloat, c)) );
-    __ lwc1(f10, MemOperand(a0, offsetof(TestFloat, d)) );
+    __ Ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, b)));
+    __ Lwc1(f8, MemOperand(a0, offsetof(TestFloat, c)));
+    __ Lwc1(f10, MemOperand(a0, offsetof(TestFloat, d)));
     __ mina_d(f6, f2, f4);
     __ mina_s(f12, f8, f10);
     __ maxa_d(f14, f2, f4);
     __ maxa_s(f16, f8, f10);
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, resf)) );
-    __ sdc1(f6, MemOperand(a0, offsetof(TestFloat, resd)) );
-    __ swc1(f16, MemOperand(a0, offsetof(TestFloat, resf1)) );
-    __ sdc1(f14, MemOperand(a0, offsetof(TestFloat, resd1)) );
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, resf)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(TestFloat, resd)));
+    __ Swc1(f16, MemOperand(a0, offsetof(TestFloat, resf1)));
+    __ Sdc1(f14, MemOperand(a0, offsetof(TestFloat, resd1)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputsa[i];
@@ skipping 55 matching lines @@
         -2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
         2147483648.0, dFPU64InvalidResult,
         dFPU64InvalidResult};
     double outputsNaN2008[kTableLength] = {
         2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
         -2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
         2147483648.0, dFPU64InvalidResult,
         dFPU64InvalidResult};
 
     __ cfc1(t1, FCSR);
-    __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-    __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+    __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ trunc_l_d(f8, f4);
     __ trunc_l_s(f10, f6);
-    __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
+    __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 42 matching lines @@
       4.8, 4.8, -4.8, -0.29
     };
 
     float outputs_S[kTableLength] = {
       4.8, 4.8, -4.8, -0.29
     };
     double outputs_D[kTableLength] = {
       5.3, -5.3, 5.3, -2.9
     };
 
-    __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
-    __ lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)) );
-    __ ld(t0, MemOperand(a0, offsetof(TestFloat, rt)));
+    __ Ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)));
+    __ Ld(t0, MemOperand(a0, offsetof(TestFloat, rt)));
     __ Move(f12, 0.0);
     __ Move(f10, 0.0);
     __ Move(f16, 0.0);
     __ Move(f14, 0.0);
-    __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, bold)) );
-    __ swc1(f10, MemOperand(a0, offsetof(TestFloat, dold)) );
-    __ sdc1(f16, MemOperand(a0, offsetof(TestFloat, bold1)) );
-    __ swc1(f14, MemOperand(a0, offsetof(TestFloat, dold1)) );
+    __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, bold)));
+    __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, dold)));
+    __ Sdc1(f16, MemOperand(a0, offsetof(TestFloat, bold1)));
+    __ Swc1(f14, MemOperand(a0, offsetof(TestFloat, dold1)));
     __ movz_s(f10, f6, t0);
     __ movz_d(f12, f2, t0);
     __ movn_s(f14, f6, t0);
     __ movn_d(f16, f2, t0);
-    __ swc1(f10, MemOperand(a0, offsetof(TestFloat, d)) );
-    __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, b)) );
-    __ swc1(f14, MemOperand(a0, offsetof(TestFloat, d1)) );
-    __ sdc1(f16, MemOperand(a0, offsetof(TestFloat, b1)) );
+    __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, d)));
+    __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, b)));
+    __ Swc1(f14, MemOperand(a0, offsetof(TestFloat, d1)));
+    __ Sdc1(f16, MemOperand(a0, offsetof(TestFloat, b1)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 60 matching lines @@
       for (int j = 0; j< 8; j++) {
         test.cc = condition_flags[j];
         if (test.cc == 0) {
           test.fcsr = 1 << 23;
         } else {
           test.fcsr = 1 << (24+condition_flags[j]);
         }
         HandleScope scope(isolate);
         MacroAssembler assm(isolate, NULL, 0,
                             v8::internal::CodeObjectRequired::kYes);
-        __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, srcd)) );
-        __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, srcf)) );
-        __ lw(t1, MemOperand(a0, offsetof(TestFloat, fcsr)) );
+        __ Ldc1(f2, MemOperand(a0, offsetof(TestFloat, srcd)));
+        __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, srcf)));
+        __ Lw(t1, MemOperand(a0, offsetof(TestFloat, fcsr)));
         __ cfc1(t0, FCSR);
         __ ctc1(t1, FCSR);
         __ li(t2, 0x0);
         __ mtc1(t2, f12);
         __ mtc1(t2, f10);
-        __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstdold)) );
-        __ swc1(f12, MemOperand(a0, offsetof(TestFloat, dstfold)) );
+        __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstdold)));
+        __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, dstfold)));
         __ movt_s(f12, f4, test.cc);
         __ movt_d(f10, f2, test.cc);
-        __ swc1(f12, MemOperand(a0, offsetof(TestFloat, dstf)) );
-        __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstd)) );
-        __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstdold1)) );
-        __ swc1(f12, MemOperand(a0, offsetof(TestFloat, dstfold1)) );
+        __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, dstf)));
+        __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstd)));
+        __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstdold1)));
+        __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, dstfold1)));
         __ movf_s(f12, f4, test.cc);
         __ movf_d(f10, f2, test.cc);
-        __ swc1(f12, MemOperand(a0, offsetof(TestFloat, dstf1)) );
-        __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstd1)) );
+        __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, dstf1)));
+        __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstd1)));
         __ ctc1(t0, FCSR);
         __ jr(ra);
         __ nop();
 
         CodeDesc desc;
         assm.GetCode(&desc);
         Handle<Code> code = isolate->factory()->NewCode(
             desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
         F3 f = FUNCTION_CAST<F3>(code->entry());
 
@@ skipping 60 matching lines @@
   double outputs_RM[kTableLength] = {
       2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
       -3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
       2147483637.0, 2147483638.0, 2147483639.0,
       2147483640.0, 2147483641.0, 2147483642.0,
       2147483643.0, 2147483644.0, 2147483645.0,
       2147483646.0, 2147483647.0, kFPUInvalidResult};
   int fcsr_inputs[4] =
       {kRoundToNearest, kRoundToZero, kRoundToPlusInf, kRoundToMinusInf};
   double* outputs[4] = {outputs_RN, outputs_RZ, outputs_RP, outputs_RM};
-  __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-  __ lw(t0, MemOperand(a0, offsetof(Test, fcsr)) );
+  __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+  __ Lw(t0, MemOperand(a0, offsetof(Test, fcsr)));
   __ cfc1(t1, FCSR);
   __ ctc1(t0, FCSR);
   __ cvt_w_d(f8, f4);
-  __ swc1(f8, MemOperand(a0, offsetof(Test, b)) );
+  __ Swc1(f8, MemOperand(a0, offsetof(Test, b)));
   __ ctc1(t1, FCSR);
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int j = 0; j < 4; j++) {
@@ skipping 41 matching lines @@
       kFPUInvalidResult, kFPUInvalidResult,
       kFPUInvalidResult};
   double outputsNaN2008[kTableLength] = {
       2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
       -2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
       kFPUInvalidResult,
       0,
       kFPUInvalidResult};
 
   __ cfc1(t1, FCSR);
-  __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-  __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+  __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+  __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ trunc_w_d(f8, f4);
   __ trunc_w_s(f10, f6);
-  __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
-  __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
+  __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
+  __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 42 matching lines @@
       -2.0, -3.0, -2.0, -3.0, -4.0, -4.0,
       kFPUInvalidResult, kFPUInvalidResult,
       kFPUInvalidResult};
   double outputsNaN2008[kTableLength] = {
       2.0, 3.0, 2.0, 3.0, 4.0, 4.0,
       -2.0, -3.0, -2.0, -3.0, -4.0, -4.0,
       kFPUInvalidResult, 0,
       kFPUInvalidResult};
 
   __ cfc1(t1, FCSR);
-  __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-  __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+  __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+  __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ round_w_d(f8, f4);
   __ round_w_s(f10, f6);
-  __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
-  __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
+  __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
+  __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 44 matching lines @@
         2147483648.0, dFPU64InvalidResult,
         dFPU64InvalidResult};
     double outputsNaN2008[kTableLength] = {
         2.0, 3.0, 2.0, 3.0, 4.0, 4.0,
         -2.0, -3.0, -2.0, -3.0, -4.0, -4.0,
         2147483648.0,
         0,
         dFPU64InvalidResult};
 
     __ cfc1(t1, FCSR);
-    __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-    __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+    __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ round_l_d(f8, f4);
     __ round_l_s(f10, f6);
-    __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
+    __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 44 matching lines @@
     5.3, 4.8, 2.9, -5.3, -4.8, -2.9
   };
   float inputft_S[kTableLength] = {
     4.8, 5.3, 2.9, 4.8, 5.3, 2.9,
     -4.8, -5.3, -2.9, -4.8, -5.3, -2.9
   };
   float outputs_S[kTableLength] = {
     0.5, -0.5, 0.0, -10.1, -10.1, -5.8,
     10.1, 10.1, 5.8, -0.5, 0.5, 0.0
   };
-  __ lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
-  __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)) );
-  __ ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)) );
-  __ ldc1(f10, MemOperand(a0, offsetof(TestFloat, d)) );
+  __ Lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)));
+  __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)));
+  __ Ldc1(f10, MemOperand(a0, offsetof(TestFloat, d)));
   __ sub_s(f6, f2, f4);
   __ sub_d(f12, f8, f10);
-  __ swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)) );
+  __ Swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)));
+  __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputfs_S[i];
@@ skipping 38 matching lines @@
     0.0L, 2.0L, sqrt2_d, 2e-14L
   };
   float inputs_S[kTableLength] = {
     0.0, 4.0, 2.0, 4e-28
   };
 
   float outputs_S[kTableLength] = {
     0.0, 2.0, sqrt2_s, 2e-14
   };
 
-
-  __ lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
-  __ ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)) );
+  __ Lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)));
   __ sqrt_s(f6, f2);
   __ sqrt_d(f12, f8);
   __ rsqrt_d(f14, f8);
   __ rsqrt_s(f16, f2);
   __ recip_d(f18, f8);
   __ recip_s(f4, f2);
-  __ swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)) );
-  __ swc1(f16, MemOperand(a0, offsetof(TestFloat, resultS1)) );
-  __ sdc1(f14, MemOperand(a0, offsetof(TestFloat, resultD1)) );
-  __ swc1(f4, MemOperand(a0, offsetof(TestFloat, resultS2)) );
-  __ sdc1(f18, MemOperand(a0, offsetof(TestFloat, resultD2)) );
+  __ Swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)));
+  __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
+  __ Swc1(f16, MemOperand(a0, offsetof(TestFloat, resultS1)));
+  __ Sdc1(f14, MemOperand(a0, offsetof(TestFloat, resultD1)));
+  __ Swc1(f4, MemOperand(a0, offsetof(TestFloat, resultS2)));
+  __ Sdc1(f18, MemOperand(a0, offsetof(TestFloat, resultD2)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   for (int i = 0; i < kTableLength; i++) {
@@ skipping 52 matching lines @@
   double outputs_D[kTableLength] = {
     -4.0, 2.0
   };
   float inputs_S[kTableLength] = {
     4.0, -2.0
   };
 
   float outputs_S[kTableLength] = {
     -4.0, 2.0
   };
-  __ lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
-  __ ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)) );
+  __ Lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)));
   __ neg_s(f6, f2);
   __ neg_d(f12, f8);
-  __ swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)) );
+  __ Swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)));
+  __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_S[i];
@@ skipping 30 matching lines @@
     4.8, 4.8, -4.8, -0.29
   };
 
   float inputfs_S[kTableLength] = {
     5.3, -5.3, 5.3, -2.9
   };
   float inputft_S[kTableLength] = {
     4.8, 4.8, -4.8, -0.29
   };
 
-  __ lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
-  __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)) );
-  __ ldc1(f6, MemOperand(a0, offsetof(TestFloat, c)) );
-  __ ldc1(f8, MemOperand(a0, offsetof(TestFloat, d)) );
+  __ Lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)));
+  __ Ldc1(f6, MemOperand(a0, offsetof(TestFloat, c)));
+  __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, d)));
   __ mul_s(f10, f2, f4);
   __ mul_d(f12, f6, f8);
-  __ swc1(f10, MemOperand(a0, offsetof(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)) );
+  __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, resultS)));
+  __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputfs_S[i];
@@ skipping 29 matching lines @@
     4.8, 4.8, -4.8, -0.29
   };
 
   float outputs_S[kTableLength] = {
     4.8, 4.8, -4.8, -0.29
   };
   double outputs_D[kTableLength] = {
     5.3, -5.3, 5.3, -2.9
   };
 
-  __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)) );
-  __ lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)) );
+  __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)));
   __ mov_s(f8, f6);
   __ mov_d(f10, f4);
-  __ swc1(f8, MemOperand(a0, offsetof(TestFloat, d)) );
-  __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, b)) );
+  __ Swc1(f8, MemOperand(a0, offsetof(TestFloat, d)));
+  __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, b)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 40 matching lines @@
       kFPUInvalidResult, kFPUInvalidResult,
       kFPUInvalidResult};
   double outputsNaN2008[kTableLength] = {
       2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
       -3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
       kFPUInvalidResult,
       0,
       kFPUInvalidResult};
 
   __ cfc1(t1, FCSR);
-  __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-  __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+  __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+  __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ floor_w_d(f8, f4);
   __ floor_w_s(f10, f6);
-  __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
-  __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
+  __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
+  __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 44 matching lines @@
         2147483648.0, dFPU64InvalidResult,
         dFPU64InvalidResult};
     double outputsNaN2008[kTableLength] = {
         2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
         -3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
         2147483648.0,
         0,
         dFPU64InvalidResult};
 
     __ cfc1(t1, FCSR);
-    __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-    __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+    __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ floor_l_d(f8, f4);
     __ floor_l_s(f10, f6);
-    __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
+    __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 44 matching lines @@
       kFPUInvalidResult, kFPUInvalidResult,
       kFPUInvalidResult};
   double outputsNaN2008[kTableLength] = {
       3.0, 3.0, 3.0, 4.0, 4.0, 4.0,
       -2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
       kFPUInvalidResult,
       0,
       kFPUInvalidResult};
 
   __ cfc1(t1, FCSR);
-  __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-  __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+  __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+  __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ ceil_w_d(f8, f4);
   __ ceil_w_s(f10, f6);
-  __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
-  __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
+  __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
+  __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 44 matching lines @@
         2147483648.0, dFPU64InvalidResult,
         dFPU64InvalidResult};
     double outputsNaN2008[kTableLength] = {
         3.0, 3.0, 3.0, 4.0, 4.0, 4.0,
         -2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
         2147483648.0,
         0,
         dFPU64InvalidResult};
 
     __ cfc1(t1, FCSR);
-    __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
-    __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
+    __ Sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ ceil_l_d(f8, f4);
     __ ceil_l_s(f10, f6);
-    __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
+    __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
       test.b = inputs_S[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
               kArchVariant == kMips64r6) {
         CHECK_EQ(test.c, outputsNaN2008[i]);
       } else {
         CHECK_EQ(test.c, outputs[i]);
       }
       CHECK_EQ(test.d, test.c);
     }
 }
 
 
 TEST(jump_tables1) {
   // Test jump tables with forward jumps.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  Assembler assm(isolate, nullptr, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   const int kNumCases = 512;
   int values[kNumCases];
   isolate->random_number_generator()->NextBytes(values, sizeof(values));
   Label labels[kNumCases];
 
   __ daddiu(sp, sp, -8);
-  __ sd(ra, MemOperand(sp));
+  __ Sd(ra, MemOperand(sp));
   __ Align(8);
 
   Label done;
   {
     __ BlockTrampolinePoolFor(kNumCases * 2 + 6);
     PredictableCodeSizeScope predictable(
         &assm, (kNumCases * 2 + 6) * Assembler::kInstrSize);
     Label here;
 
     __ bal(&here);
     __ dsll(at, a0, 3);  // In delay slot.
     __ bind(&here);
     __ daddu(at, at, ra);
-    __ ld(at, MemOperand(at, 4 * Assembler::kInstrSize));
+    __ Ld(at, MemOperand(at, 4 * Assembler::kInstrSize));
     __ jr(at);
     __ nop();
     for (int i = 0; i < kNumCases; ++i) {
       __ dd(&labels[i]);
     }
   }
 
   for (int i = 0; i < kNumCases; ++i) {
     __ bind(&labels[i]);
     __ lui(v0, (values[i] >> 16) & 0xffff);
     __ ori(v0, v0, values[i] & 0xffff);
     __ b(&done);
     __ nop();
   }
 
   __ bind(&done);
-  __ ld(ra, MemOperand(sp));
+  __ Ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
   CHECK_EQ(0, assm.UnboundLabelsCount());
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   for (int i = 0; i < kNumCases; ++i) {
     int64_t res = reinterpret_cast<int64_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
     CHECK_EQ(values[i], static_cast<int>(res));
   }
 }
 
 
 TEST(jump_tables2) {
   // Test jump tables with backward jumps.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  Assembler assm(isolate, nullptr, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   const int kNumCases = 512;
   int values[kNumCases];
   isolate->random_number_generator()->NextBytes(values, sizeof(values));
   Label labels[kNumCases];
 
   __ daddiu(sp, sp, -8);
-  __ sd(ra, MemOperand(sp));
+  __ Sd(ra, MemOperand(sp));
 
   Label done, dispatch;
   __ b(&dispatch);
   __ nop();
 
   for (int i = 0; i < kNumCases; ++i) {
     __ bind(&labels[i]);
     __ lui(v0, (values[i] >> 16) & 0xffff);
     __ ori(v0, v0, values[i] & 0xffff);
     __ b(&done);
     __ nop();
   }
 
   __ Align(8);
   __ bind(&dispatch);
   {
     __ BlockTrampolinePoolFor(kNumCases * 2 + 6);
     PredictableCodeSizeScope predictable(
         &assm, (kNumCases * 2 + 6) * Assembler::kInstrSize);
     Label here;
 
     __ bal(&here);
     __ dsll(at, a0, 3);  // In delay slot.
     __ bind(&here);
     __ daddu(at, at, ra);
-    __ ld(at, MemOperand(at, 4 * Assembler::kInstrSize));
+    __ Ld(at, MemOperand(at, 4 * Assembler::kInstrSize));
     __ jr(at);
     __ nop();
     for (int i = 0; i < kNumCases; ++i) {
       __ dd(&labels[i]);
     }
   }
 
   __ bind(&done);
-  __ ld(ra, MemOperand(sp));
+  __ Ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   for (int i = 0; i < kNumCases; ++i) {
     int64_t res = reinterpret_cast<int64_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
     CHECK_EQ(values[i], res);
   }
 }
 
 
 TEST(jump_tables3) {
   // Test jump tables with backward jumps and embedded heap objects.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  Assembler assm(isolate, nullptr, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   const int kNumCases = 512;
   Handle<Object> values[kNumCases];
   for (int i = 0; i < kNumCases; ++i) {
     double value = isolate->random_number_generator()->NextDouble();
     values[i] = isolate->factory()->NewHeapNumber(value, IMMUTABLE, TENURED);
   }
   Label labels[kNumCases];
   Object* obj;
   int64_t imm64;
 
   __ daddiu(sp, sp, -8);
-  __ sd(ra, MemOperand(sp));
+  __ Sd(ra, MemOperand(sp));
 
   Label done, dispatch;
   __ b(&dispatch);
   __ nop();
 
 
   for (int i = 0; i < kNumCases; ++i) {
     __ bind(&labels[i]);
     obj = *values[i];
     imm64 = reinterpret_cast<intptr_t>(obj);
@@ skipping 10 matching lines @@
   {
     __ BlockTrampolinePoolFor(kNumCases * 2 + 6);
     PredictableCodeSizeScope predictable(
         &assm, (kNumCases * 2 + 6) * Assembler::kInstrSize);
     Label here;
 
     __ bal(&here);
     __ dsll(at, a0, 3);  // In delay slot.
     __ bind(&here);
     __ daddu(at, at, ra);
-    __ ld(at, MemOperand(at, 4 * Assembler::kInstrSize));
+    __ Ld(at, MemOperand(at, 4 * Assembler::kInstrSize));
     __ jr(at);
     __ nop();
     for (int i = 0; i < kNumCases; ++i) {
       __ dd(&labels[i]);
     }
   }
 
   __ bind(&done);
-  __ ld(ra, MemOperand(sp));
+  __ Ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
@@ skipping 22 matching lines @@
     typedef struct {
       int64_t r1;
       int64_t r2;
       int64_t r3;
       int64_t r4;
       int64_t r5;
       int64_t r6;
     } T;
     T t;
 
-    Assembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
-    __ ld(a4, MemOperand(a0, offsetof(T, r1)));
+    __ Ld(a4, MemOperand(a0, offsetof(T, r1)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, offsetof(T, r1)));
+    __ Sd(a6, MemOperand(a0, offsetof(T, r1)));
 
-    __ ld(a4, MemOperand(a0, offsetof(T, r2)));
+    __ Ld(a4, MemOperand(a0, offsetof(T, r2)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, offsetof(T, r2)));
+    __ Sd(a6, MemOperand(a0, offsetof(T, r2)));
 
-    __ ld(a4, MemOperand(a0, offsetof(T, r3)));
+    __ Ld(a4, MemOperand(a0, offsetof(T, r3)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, offsetof(T, r3)));
+    __ Sd(a6, MemOperand(a0, offsetof(T, r3)));
 
-    __ ld(a4, MemOperand(a0, offsetof(T, r4)));
+    __ Ld(a4, MemOperand(a0, offsetof(T, r4)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, offsetof(T, r4)));
+    __ Sd(a6, MemOperand(a0, offsetof(T, r4)));
 
-    __ ld(a4, MemOperand(a0, offsetof(T, r5)));
+    __ Ld(a4, MemOperand(a0, offsetof(T, r5)));
     __ nop();
     __ dbitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, offsetof(T, r5)));
+    __ Sd(a6, MemOperand(a0, offsetof(T, r5)));
 
-    __ ld(a4, MemOperand(a0, offsetof(T, r6)));
+    __ Ld(a4, MemOperand(a0, offsetof(T, r6)));
     __ nop();
     __ dbitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, offsetof(T, r6)));
+    __ Sd(a6, MemOperand(a0, offsetof(T, r6)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.r1 = 0x00102100781A15C3;
@@ skipping 43 matching lines @@
       float  fPosNorm;
       float  fPosSubnorm;
       float  fPosZero;  } T;
     T t;
 
     // Create a function that accepts &t, and loads, manipulates, and stores
     // the doubles t.a ... t.f.
     MacroAssembler assm(isolate, NULL, 0,
                         v8::internal::CodeObjectRequired::kYes);
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dSignalingNan)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dSignalingNan)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dSignalingNan)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dSignalingNan)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dQuietNan)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dQuietNan)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dQuietNan)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dQuietNan)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegInf)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dNegInf)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegInf)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dNegInf)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegNorm)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dNegNorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegNorm)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dNegNorm)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegSubnorm)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dNegSubnorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegSubnorm)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dNegSubnorm)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegZero)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dNegZero)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegZero)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dNegZero)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosInf)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dPosInf)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosInf)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dPosInf)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosNorm)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dPosNorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosNorm)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dPosNorm)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosSubnorm)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dPosSubnorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosSubnorm)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dPosSubnorm)));
 
-    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosZero)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(T, dPosZero)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosZero)));
+    __ Sdc1(f6, MemOperand(a0, offsetof(T, dPosZero)));
 
     // Testing instruction CLASS.S
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fSignalingNan)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fSignalingNan)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fSignalingNan)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fSignalingNan)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fQuietNan)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fQuietNan)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fQuietNan)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fQuietNan)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegInf)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fNegInf)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fNegInf)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fNegInf)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegNorm)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fNegNorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fNegNorm)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fNegNorm)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegSubnorm)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fNegSubnorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fNegSubnorm)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fNegSubnorm)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegZero)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fNegZero)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fNegZero)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fNegZero)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosInf)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fPosInf)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fPosInf)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fPosInf)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosNorm)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fPosNorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fPosNorm)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fPosNorm)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosSubnorm)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fPosSubnorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fPosSubnorm)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fPosSubnorm)));
 
-    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosZero)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(T, fPosZero)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, offsetof(T, fPosZero)));
+    __ Swc1(f6, MemOperand(a0, offsetof(T, fPosZero)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
@@ skipping 60 matching lines @@
     int64_t fir;
     double a;
     float b;
     double fcsr;
   } TestFloat;
 
   TestFloat test;
 
   // Save FIR.
   __ cfc1(a1, FCSR);
-  __ sd(a1, MemOperand(a0, offsetof(TestFloat, fcsr)));
+  __ Sd(a1, MemOperand(a0, offsetof(TestFloat, fcsr)));
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 
-  __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
   __ abs_d(f10, f4);
-  __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, a)));
 
-  __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)));
+  __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)));
   __ abs_s(f10, f4);
-  __ swc1(f10, MemOperand(a0, offsetof(TestFloat, b)));
+  __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, b)));
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
@@ skipping 67 matching lines @@
     double a;
     double b;
     double c;
     float fa;
     float fb;
     float fc;
   } TestFloat;
 
   TestFloat test;
 
-  __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
-  __ ldc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
+  __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
+  __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
   __ add_d(f10, f8, f4);
-  __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
+  __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
 
-  __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, fa)));
-  __ lwc1(f8, MemOperand(a0, offsetof(TestFloat, fb)));
+  __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, fa)));
+  __ Lwc1(f8, MemOperand(a0, offsetof(TestFloat, fb)));
   __ add_s(f10, f8, f4);
-  __ swc1(f10, MemOperand(a0, offsetof(TestFloat, fc)));
+  __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, fc)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   test.a = 2.0;
@@ skipping 58 matching lines @@
       uint32_t fOlt;
       uint32_t fUlt;
       uint32_t fOle;
       uint32_t fUle;
     } TestFloat;
 
     TestFloat test;
 
     __ li(t1, 1);
 
-    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, dOp1)));
-    __ ldc1(f6, MemOperand(a0, offsetof(TestFloat, dOp2)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, dOp1)));
+    __ Ldc1(f6, MemOperand(a0, offsetof(TestFloat, dOp2)));
 
-    __ lwc1(f14, MemOperand(a0, offsetof(TestFloat, fOp1)));
-    __ lwc1(f16, MemOperand(a0, offsetof(TestFloat, fOp2)));
+    __ Lwc1(f14, MemOperand(a0, offsetof(TestFloat, fOp1)));
+    __ Lwc1(f16, MemOperand(a0, offsetof(TestFloat, fOp2)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(F, f4, f6, 0);
     __ c_s(F, f14, f16, 2);
     __ movt(t2, t1, 0);
     __ movt(t3, t1, 2);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dF)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fF)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dF)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fF)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(UN, f4, f6, 2);
     __ c_s(UN, f14, f16, 4);
     __ movt(t2, t1, 2);
     __ movt(t3, t1, 4);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dUn)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fUn)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dUn)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fUn)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(EQ, f4, f6, 4);
     __ c_s(EQ, f14, f16, 6);
     __ movt(t2, t1, 4);
     __ movt(t3, t1, 6);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dEq)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fEq)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dEq)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fEq)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(UEQ, f4, f6, 6);
     __ c_s(UEQ, f14, f16, 0);
     __ movt(t2, t1, 6);
     __ movt(t3, t1, 0);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dUeq)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fUeq)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dUeq)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fUeq)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(OLT, f4, f6, 0);
     __ c_s(OLT, f14, f16, 2);
     __ movt(t2, t1, 0);
     __ movt(t3, t1, 2);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dOlt)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fOlt)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dOlt)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fOlt)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(ULT, f4, f6, 2);
     __ c_s(ULT, f14, f16, 4);
     __ movt(t2, t1, 2);
     __ movt(t3, t1, 4);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dUlt)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fUlt)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dUlt)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fUlt)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(OLE, f4, f6, 4);
     __ c_s(OLE, f14, f16, 6);
     __ movt(t2, t1, 4);
     __ movt(t3, t1, 6);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dOle)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fOle)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dOle)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fOle)));
 
     __ mov(t2, zero_reg);
     __ mov(t3, zero_reg);
     __ c_d(ULE, f4, f6, 6);
     __ c_s(ULE, f14, f16, 0);
     __ movt(t2, t1, 6);
     __ movt(t3, t1, 0);
-    __ sw(t2, MemOperand(a0, offsetof(TestFloat, dUle)) );
-    __ sw(t3, MemOperand(a0, offsetof(TestFloat, fUle)) );
+    __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dUle)));
+    __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fUle)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     test.dOp1 = 2.0;
@@ skipping 121 matching lines @@
       float fUle;
       float fOr;
       float fUne;
       float fNe;
     } TestFloat;
 
     TestFloat test;
 
     __ li(t1, 1);
 
-    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, dOp1)));
-    __ ldc1(f6, MemOperand(a0, offsetof(TestFloat, dOp2)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, dOp1)));
+    __ Ldc1(f6, MemOperand(a0, offsetof(TestFloat, dOp2)));
 
-    __ lwc1(f14, MemOperand(a0, offsetof(TestFloat, fOp1)));
-    __ lwc1(f16, MemOperand(a0, offsetof(TestFloat, fOp2)));
+    __ Lwc1(f14, MemOperand(a0, offsetof(TestFloat, fOp1)));
+    __ Lwc1(f16, MemOperand(a0, offsetof(TestFloat, fOp2)));
 
     __ cmp_d(F, f2, f4, f6);
     __ cmp_s(F, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dF)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fF)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dF)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fF)));
 
     __ cmp_d(UN, f2, f4, f6);
     __ cmp_s(UN, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUn)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fUn)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUn)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fUn)));
 
     __ cmp_d(EQ, f2, f4, f6);
     __ cmp_s(EQ, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dEq)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fEq)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dEq)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fEq)));
 
     __ cmp_d(UEQ, f2, f4, f6);
     __ cmp_s(UEQ, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUeq)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fUeq)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUeq)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fUeq)));
 
     __ cmp_d(LT, f2, f4, f6);
     __ cmp_s(LT, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dOlt)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fOlt)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dOlt)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fOlt)));
 
     __ cmp_d(ULT, f2, f4, f6);
     __ cmp_s(ULT, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUlt)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fUlt)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUlt)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fUlt)));
 
     __ cmp_d(LE, f2, f4, f6);
     __ cmp_s(LE, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dOle)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fOle)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dOle)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fOle)));
 
     __ cmp_d(ULE, f2, f4, f6);
     __ cmp_s(ULE, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUle)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fUle)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUle)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fUle)));
 
     __ cmp_d(ORD, f2, f4, f6);
     __ cmp_s(ORD, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dOr)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fOr)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dOr)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fOr)));
 
     __ cmp_d(UNE, f2, f4, f6);
     __ cmp_s(UNE, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUne)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fUne)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dUne)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fUne)));
 
     __ cmp_d(NE, f2, f4, f6);
     __ cmp_s(NE, f12, f14, f16);
-    __ sdc1(f2, MemOperand(a0, offsetof(TestFloat, dNe)) );
-    __ swc1(f12, MemOperand(a0, offsetof(TestFloat, fNe)) );
+    __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dNe)));
+    __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fNe)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     uint64_t dTrue  = 0xFFFFFFFFFFFFFFFF;
@@ skipping 316 matching lines @@
     float  fRes;
   } Test;
 
   Test test;
 
   // Save FCSR.
   __ cfc1(a1, FCSR);
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 
-  __ ldc1(f4, MemOperand(a0, offsetof(Test, dOp1)) );
-  __ ldc1(f2, MemOperand(a0, offsetof(Test, dOp2)) );
+  __ Ldc1(f4, MemOperand(a0, offsetof(Test, dOp1)));
+  __ Ldc1(f2, MemOperand(a0, offsetof(Test, dOp2)));
   __ nop();
   __ div_d(f6, f4, f2);
-  __ sdc1(f6, MemOperand(a0, offsetof(Test, dRes)) );
+  __ Sdc1(f6, MemOperand(a0, offsetof(Test, dRes)));
 
-  __ lwc1(f4, MemOperand(a0, offsetof(Test, fOp1)) );
-  __ lwc1(f2, MemOperand(a0, offsetof(Test, fOp2)) );
+  __ Lwc1(f4, MemOperand(a0, offsetof(Test, fOp1)));
+  __ Lwc1(f2, MemOperand(a0, offsetof(Test, fOp2)));
   __ nop();
   __ div_s(f6, f4, f2);
-  __ swc1(f6, MemOperand(a0, offsetof(Test, fRes)) );
+  __ Swc1(f6, MemOperand(a0, offsetof(Test, fRes)));
 
-    // Restore FCSR.
+  // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
@@ skipping 1380 matching lines @@
       {x2, y2, -z2, 0.0, 0.0},
       {x2, -y2, z2, 0.0, 0.0},
       {x2, -y2, -z2, 0.0, 0.0},
       {-x2, y2, z2, 0.0, 0.0},
       {-x2, y2, -z2, 0.0, 0.0},
       {-x2, -y2, z2, 0.0, 0.0},
       {-x2, -y2, -z2, 0.0, 0.0},
   };
 
   if (std::is_same<T, float>::value) {
-    __ lwc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
-    __ lwc1(f6, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fs)));
-    __ lwc1(f8, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, ft)));
-    __ lwc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
+    __ Lwc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
+    __ Lwc1(f6, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fs)));
+    __ Lwc1(f8, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, ft)));
+    __ Lwc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
   } else if (std::is_same<T, double>::value) {
-    __ ldc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
-    __ ldc1(f6, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fs)));
-    __ ldc1(f8, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, ft)));
-    __ ldc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
+    __ Ldc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
+    __ Ldc1(f6, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fs)));
+    __ Ldc1(f8, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, ft)));
+    __ Ldc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fr)));
   } else {
     UNREACHABLE();
   }
 
   func(assm);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
@@ skipping 23 matching lines @@
 
     CHECK_EQ(tc.fd_add, res_add);
     CHECK_EQ(tc.fd_sub, res_sub);
   }
 }
 
 TEST(madd_msub_s) {
   if (kArchVariant == kMips64r6) return;
   helper_madd_msub_maddf_msubf<float>([](MacroAssembler& assm) {
     __ madd_s(f10, f4, f6, f8);
-    __ swc1(f10, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_add)));
+    __ Swc1(f10, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_add)));
     __ msub_s(f16, f4, f6, f8);
-    __ swc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_sub)));
+    __ Swc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_sub)));
   });
 }
 
 TEST(madd_msub_d) {
   if (kArchVariant == kMips64r6) return;
   helper_madd_msub_maddf_msubf<double>([](MacroAssembler& assm) {
     __ madd_d(f10, f4, f6, f8);
-    __ sdc1(f10, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_add)));
+    __ Sdc1(f10, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_add)));
     __ msub_d(f16, f4, f6, f8);
-    __ sdc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_sub)));
+    __ Sdc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_sub)));
   });
 }
 
 TEST(maddf_msubf_s) {
   if (kArchVariant != kMips64r6) return;
   helper_madd_msub_maddf_msubf<float>([](MacroAssembler& assm) {
     __ maddf_s(f4, f6, f8);
-    __ swc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_add)));
+    __ Swc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_add)));
     __ msubf_s(f16, f6, f8);
-    __ swc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_sub)));
+    __ Swc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_sub)));
   });
 }
 
 TEST(maddf_msubf_d) {
   if (kArchVariant != kMips64r6) return;
   helper_madd_msub_maddf_msubf<double>([](MacroAssembler& assm) {
     __ maddf_d(f4, f6, f8);
-    __ sdc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_add)));
+    __ Sdc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_add)));
     __ msubf_d(f16, f6, f8);
-    __ sdc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_sub)));
+    __ Sdc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_sub)));
   });
 }
 
 #undef __