MIPS: Move ldc1/sdc1 to macro-assembler.

test/cctest/test-macro-assembler-mips.cc

 // Copyright 2013 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 991 matching lines @@
   float inputsf[kTableLength] = {3.0,   2.0, 0.0,  -0.0, finf, 42.0, finf,
                                  fminf, 3.0, fnan, fnan, finf, fnan};
   float outputsfmin[kTableLength] = {2.0,   2.0,  -0.0, -0.0, 42.0, 42.0, fminf,
                                      fminf, fnan, fnan, fnan, fnan, fnan};
   float outputsfmax[kTableLength] = {3.0,  3.0,  0.0,  0.0,  finf, finf, finf,
                                      finf, fnan, fnan, fnan, fnan, fnan};
 
   auto handle_dnan = [masm](FPURegister dst, Label* nan, Label* back) {
     __ bind(nan);
     __ LoadRoot(at, Heap::kNanValueRootIndex);
-    __ ldc1(dst, FieldMemOperand(at, HeapNumber::kValueOffset));
+    __ Ldc1(dst, FieldMemOperand(at, HeapNumber::kValueOffset));
     __ Branch(back);
   };
 
   auto handle_snan = [masm, fnan](FPURegister dst, Label* nan, Label* back) {
     __ bind(nan);
     __ Move(dst, fnan);
     __ Branch(back);
   };
 
   Label handle_mind_nan, handle_maxd_nan, handle_mins_nan, handle_maxs_nan;
   Label back_mind_nan, back_maxd_nan, back_mins_nan, back_maxs_nan;
 
   __ push(s6);
   __ InitializeRootRegister();
-  __ 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)));
   __ lwc1(f2, MemOperand(a0, offsetof(TestFloat, e)));
   __ lwc1(f6, MemOperand(a0, offsetof(TestFloat, f)));
   __ Float64Min(f10, f4, f8, &handle_mind_nan);
   __ bind(&back_mind_nan);
   __ Float64Max(f12, f4, f8, &handle_maxd_nan);
   __ bind(&back_maxd_nan);
   __ Float32Min(f14, f2, f6, &handle_mins_nan);
   __ bind(&back_mins_nan);
   __ Float32Max(f16, f2, f6, &handle_maxs_nan);
   __ bind(&back_maxs_nan);
-  __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
-  __ sdc1(f12, MemOperand(a0, offsetof(TestFloat, d)));
+  __ 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)));
   __ pop(s6);
   __ jr(ra);
   __ nop();
 
   handle_dnan(f10, &handle_mind_nan, &back_mind_nan);
   handle_dnan(f12, &handle_maxd_nan, &back_maxd_nan);
   handle_snan(f14, &handle_mins_nan, &back_mins_nan);
   handle_snan(f16, &handle_maxs_nan, &back_maxs_nan);
@@ skipping 463 matching lines @@
   T b = T::from_code(6);  // f6
   T c = T::from_code(8);  // f8
 
   Label ool_min_abc, ool_min_aab, ool_min_aba;
   Label ool_max_abc, ool_max_aab, ool_max_aba;
 
   Label done_min_abc, done_min_aab, done_min_aba;
   Label done_max_abc, done_max_aab, done_max_aba;
 
 #define FLOAT_MIN_MAX(fminmax, res, x, y, done, ool, res_field) \
-  __ ldc1(x, MemOperand(a0, offsetof(Inputs, src1_)));          \
-  __ ldc1(y, MemOperand(a0, offsetof(Inputs, src2_)));          \
+  __ Ldc1(x, MemOperand(a0, offsetof(Inputs, src1_)));          \
+  __ Ldc1(y, MemOperand(a0, offsetof(Inputs, src2_)));          \
   __ fminmax(res, x, y, &ool);                                  \
   __ bind(&done);                                               \
-  __ sdc1(a, MemOperand(a1, offsetof(Results, res_field)))
+  __ Sdc1(a, MemOperand(a1, offsetof(Results, res_field)))
 
   // a = min(b, c);
   FLOAT_MIN_MAX(Float64Min, a, b, c, done_min_abc, ool_min_abc, min_abc_);
   // a = min(a, b);
   FLOAT_MIN_MAX(Float64Min, a, a, b, done_min_aab, ool_min_aab, min_aab_);
   // a = min(b, a);
   FLOAT_MIN_MAX(Float64Min, a, b, a, done_min_aba, ool_min_aba, min_aba_);
 
   // a = max(b, c);
   FLOAT_MIN_MAX(Float64Max, a, b, c, done_max_abc, ool_max_abc, max_abc_);
@@ skipping 106 matching lines @@
 
   CHECK_MINMAX(0.0, nan_a, nan_a, nan_a);
   CHECK_MINMAX(nan_a, 0.0, nan_a, nan_a);
   CHECK_MINMAX(nan_a, nan_b, nan_a, nan_a);
   CHECK_MINMAX(nan_b, nan_a, nan_b, nan_b);
 
 #undef CHECK_MINMAX
 }
 
 #undef __