MIPS[64]: Fix tests for macro-assembler.

test/cctest/test-macro-assembler-mips64.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 677 matching lines @@
   F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
 
   return reinterpret_cast<RET_TYPE>(
       CALL_GENERATED_CODE(isolate, f, x, 0, 0, 0, 0));
 }
 
 TEST(Cvt_s_uw_Trunc_uw_s) {
   CcTest::InitializeVM();
   FOR_UINT32_INPUTS(i, cvt_trunc_uint32_test_values) {
     uint32_t input = *i;
-    CHECK_EQ(static_cast<float>(input),
-             run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
-               __ Cvt_s_uw(f0, a0);
-               __ mthc1(zero_reg, f2);
-               __ Trunc_uw_s(f2, f0, f1);
-             }));
+    auto fn = [](MacroAssembler* masm) {
+      __ Cvt_s_uw(f0, a0);
+      __ mthc1(zero_reg, f2);
+      __ Trunc_uw_s(f2, f0, f1);
+    };
+    CHECK_EQ(static_cast<float>(input), run_Cvt<uint64_t>(input, fn));
   }
 }
 
 TEST(Cvt_s_ul_Trunc_ul_s) {
   CcTest::InitializeVM();
   FOR_UINT64_INPUTS(i, cvt_trunc_uint64_test_values) {
     uint64_t input = *i;
-    CHECK_EQ(static_cast<float>(input),
-             run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
-               __ Cvt_s_ul(f0, a0);
-               __ Trunc_ul_s(f2, f0, f1, v0);
-             }));
+    auto fn = [](MacroAssembler* masm) {
+      __ Cvt_s_ul(f0, a0);
+      __ Trunc_ul_s(f2, f0, f1, v0);
+    };
+    CHECK_EQ(static_cast<float>(input), run_Cvt<uint64_t>(input, fn));
   }
 }
 
 TEST(Cvt_d_ul_Trunc_ul_d) {
   CcTest::InitializeVM();
   FOR_UINT64_INPUTS(i, cvt_trunc_uint64_test_values) {
     uint64_t input = *i;
-    CHECK_EQ(static_cast<double>(input),
-             run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
-               __ Cvt_d_ul(f0, a0);
-               __ Trunc_ul_d(f2, f0, f1, v0);
-             }));
+    auto fn = [](MacroAssembler* masm) {
+      __ Cvt_d_ul(f0, a0);
+      __ Trunc_ul_d(f2, f0, f1, v0);
+    };
+    CHECK_EQ(static_cast<double>(input), run_Cvt<uint64_t>(input, fn));
   }
 }
 
 TEST(cvt_d_l_Trunc_l_d) {
   CcTest::InitializeVM();
   FOR_INT64_INPUTS(i, cvt_trunc_int64_test_values) {
     int64_t input = *i;
-    CHECK_EQ(static_cast<double>(input),
-             run_Cvt<int64_t>(input, [](MacroAssembler* masm) {
-               __ dmtc1(a0, f4);
-               __ cvt_d_l(f0, f4);
-               __ Trunc_l_d(f2, f0);
-             }));
+    auto fn = [](MacroAssembler* masm) {
+      __ dmtc1(a0, f4);
+      __ cvt_d_l(f0, f4);
+      __ Trunc_l_d(f2, f0);
+    };
+    CHECK_EQ(static_cast<double>(input), run_Cvt<int64_t>(input, fn));
   }
 }
 
 TEST(cvt_d_l_Trunc_l_ud) {
   CcTest::InitializeVM();
   FOR_INT64_INPUTS(i, cvt_trunc_int64_test_values) {
     int64_t input = *i;
     uint64_t abs_input = (input < 0) ? -input : input;
-    CHECK_EQ(static_cast<double>(abs_input),
-             run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
-               __ dmtc1(a0, f4);
-               __ cvt_d_l(f0, f4);
-               __ Trunc_l_ud(f2, f0, f6);
-             }));
+    auto fn = [](MacroAssembler* masm) {
+      __ dmtc1(a0, f4);
+      __ cvt_d_l(f0, f4);
+      __ Trunc_l_ud(f2, f0, f6);
+    };
+    CHECK_EQ(static_cast<double>(abs_input), run_Cvt<uint64_t>(input, fn));
   }
 }
 
 TEST(cvt_d_w_Trunc_w_d) {
   CcTest::InitializeVM();
   FOR_INT32_INPUTS(i, cvt_trunc_int32_test_values) {
     int32_t input = *i;
-    CHECK_EQ(static_cast<double>(input),
-             run_Cvt<int64_t>(input, [](MacroAssembler* masm) {
-               __ mtc1(a0, f4);
-               __ cvt_d_w(f0, f4);
-               __ Trunc_w_d(f2, f0);
-               __ mfc1(v1, f2);
-               __ dmtc1(v1, f2);
-             }));
+    auto fn = [](MacroAssembler* masm) {
+      __ mtc1(a0, f4);
+      __ cvt_d_w(f0, f4);
+      __ Trunc_w_d(f2, f0);
+      __ mfc1(v1, f2);
+      __ dmtc1(v1, f2);
+    };
+    CHECK_EQ(static_cast<double>(input), run_Cvt<int64_t>(input, fn));
   }
 }
 
 static const std::vector<int32_t> overflow_int32_test_values() {
   static const int32_t kValues[] = {
       static_cast<int32_t>(0xf0000000), static_cast<int32_t>(0x00000001),
       static_cast<int32_t>(0xff000000), static_cast<int32_t>(0x0000f000),
       static_cast<int32_t>(0x0f000000), static_cast<int32_t>(0x991234ab),
       static_cast<int32_t>(0xb0ffff01), static_cast<int32_t>(0x00006fff),
       static_cast<int32_t>(0xffffffff)};
@@ skipping 830 matching lines @@
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         uint16_t value = static_cast<uint64_t>(*i & 0xFFFF);
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<uint16_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Ulh(v0, MemOperand(a0, in_offset));
-                             __ Ush(v0, MemOperand(a0, out_offset), v0);
-                           }));
-        CHECK_EQ(true, run_Unaligned<uint16_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ mov(t0, a0);
-                             __ Ulh(a0, MemOperand(a0, in_offset));
-                             __ Ush(a0, MemOperand(t0, out_offset), v0);
-                           }));
-        CHECK_EQ(true, run_Unaligned<uint16_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ mov(t0, a0);
-                             __ Ulhu(a0, MemOperand(a0, in_offset));
-                             __ Ush(a0, MemOperand(t0, out_offset), t1);
-                           }));
-        CHECK_EQ(true, run_Unaligned<uint16_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Ulhu(v0, MemOperand(a0, in_offset));
-                             __ Ush(v0, MemOperand(a0, out_offset), t1);
-                           }));
+        auto fn_1 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ Ulh(v0, MemOperand(a0, in_offset));
+          __ Ush(v0, MemOperand(a0, out_offset), v0);
+        };
+        CHECK_EQ(true, run_Unaligned<uint16_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_1));
+
+        auto fn_2 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ mov(t0, a0);
+          __ Ulh(a0, MemOperand(a0, in_offset));
+          __ Ush(a0, MemOperand(t0, out_offset), v0);
+        };
+        CHECK_EQ(true, run_Unaligned<uint16_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_2));
+
+        auto fn_3 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ mov(t0, a0);
+          __ Ulhu(a0, MemOperand(a0, in_offset));
+          __ Ush(a0, MemOperand(t0, out_offset), t1);
+        };
+        CHECK_EQ(true, run_Unaligned<uint16_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_3));
+
+        auto fn_4 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ Ulhu(v0, MemOperand(a0, in_offset));
+          __ Ush(v0, MemOperand(a0, out_offset), t1);
+        };
+        CHECK_EQ(true, run_Unaligned<uint16_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_4));
       }
     }
   }
 }
 
 TEST(Ulh_bitextension) {
   CcTest::InitializeVM();
 
   static const int kBufferSize = 300 * KB;
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         uint16_t value = static_cast<uint64_t>(*i & 0xFFFF);
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<uint16_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             Label success, fail, end, different;
-                             __ Ulh(t0, MemOperand(a0, in_offset));
-                             __ Ulhu(t1, MemOperand(a0, in_offset));
-                             __ Branch(&different, ne, t0, Operand(t1));
+        auto fn = [](MacroAssembler* masm, int32_t in_offset,
+                     int32_t out_offset) {
+          Label success, fail, end, different;
+          __ Ulh(t0, MemOperand(a0, in_offset));
+          __ Ulhu(t1, MemOperand(a0, in_offset));
+          __ Branch(&different, ne, t0, Operand(t1));
 
-                             // If signed and unsigned values are same, check
-                             // the upper bits to see if they are zero
-                             __ sra(t0, t0, 15);
-                             __ Branch(&success, eq, t0, Operand(zero_reg));
-                             __ Branch(&fail);
+          // If signed and unsigned values are same, check
+          // the upper bits to see if they are zero
+          __ sra(t0, t0, 15);
+          __ Branch(&success, eq, t0, Operand(zero_reg));
+          __ Branch(&fail);
 
-                             // If signed and unsigned values are different,
-                             // check that the upper bits are complementary
-                             __ bind(&different);
-                             __ sra(t1, t1, 15);
-                             __ Branch(&fail, ne, t1, Operand(1));
-                             __ sra(t0, t0, 15);
-                             __ addiu(t0, t0, 1);
-                             __ Branch(&fail, ne, t0, Operand(zero_reg));
-                             // Fall through to success
+          // If signed and unsigned values are different,
+          // check that the upper bits are complementary
+          __ bind(&different);
+          __ sra(t1, t1, 15);
+          __ Branch(&fail, ne, t1, Operand(1));
+          __ sra(t0, t0, 15);
+          __ addiu(t0, t0, 1);
+          __ Branch(&fail, ne, t0, Operand(zero_reg));
+          // Fall through to success
 
-                             __ bind(&success);
-                             __ Ulh(t0, MemOperand(a0, in_offset));
-                             __ Ush(t0, MemOperand(a0, out_offset), v0);
-                             __ Branch(&end);
-                             __ bind(&fail);
-                             __ Ush(zero_reg, MemOperand(a0, out_offset), v0);
-                             __ bind(&end);
-                           }));
+          __ bind(&success);
+          __ Ulh(t0, MemOperand(a0, in_offset));
+          __ Ush(t0, MemOperand(a0, out_offset), v0);
+          __ Branch(&end);
+          __ bind(&fail);
+          __ Ush(zero_reg, MemOperand(a0, out_offset), v0);
+          __ bind(&end);
+        };
+        CHECK_EQ(true, run_Unaligned<uint16_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn));
       }
     }
   }
 }
 
 TEST(Ulw) {
   CcTest::InitializeVM();
 
   static const int kBufferSize = 300 * KB;
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         uint32_t value = static_cast<uint32_t>(*i & 0xFFFFFFFF);
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<uint32_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Ulw(v0, MemOperand(a0, in_offset));
-                             __ Usw(v0, MemOperand(a0, out_offset));
-                           }));
+        auto fn_1 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ Ulw(v0, MemOperand(a0, in_offset));
+          __ Usw(v0, MemOperand(a0, out_offset));
+        };
+        CHECK_EQ(true, run_Unaligned<uint32_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_1));
+
+        auto fn_2 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ mov(t0, a0);
+          __ Ulw(a0, MemOperand(a0, in_offset));
+          __ Usw(a0, MemOperand(t0, out_offset));
+        };
         CHECK_EQ(true,
-                 run_Unaligned<uint32_t>(
-                     buffer_middle, in_offset, out_offset, (uint32_t)value,
-                     [](MacroAssembler* masm, int32_t in_offset,
-                        int32_t out_offset) {
-                       __ mov(t0, a0);
-                       __ Ulw(a0, MemOperand(a0, in_offset));
-                       __ Usw(a0, MemOperand(t0, out_offset));
-                     }));
-        CHECK_EQ(true, run_Unaligned<uint32_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Ulwu(v0, MemOperand(a0, in_offset));
-                             __ Usw(v0, MemOperand(a0, out_offset));
-                           }));
+                 run_Unaligned<uint32_t>(buffer_middle, in_offset, out_offset,
+                                         (uint32_t)value, fn_2));
+
+        auto fn_3 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ Ulwu(v0, MemOperand(a0, in_offset));
+          __ Usw(v0, MemOperand(a0, out_offset));
+        };
+        CHECK_EQ(true, run_Unaligned<uint32_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_3));
+
+        auto fn_4 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ mov(t0, a0);
+          __ Ulwu(a0, MemOperand(a0, in_offset));
+          __ Usw(a0, MemOperand(t0, out_offset));
+        };
         CHECK_EQ(true,
-                 run_Unaligned<uint32_t>(
-                     buffer_middle, in_offset, out_offset, (uint32_t)value,
-                     [](MacroAssembler* masm, int32_t in_offset,
-                        int32_t out_offset) {
-                       __ mov(t0, a0);
-                       __ Ulwu(a0, MemOperand(a0, in_offset));
-                       __ Usw(a0, MemOperand(t0, out_offset));
-                     }));
+                 run_Unaligned<uint32_t>(buffer_middle, in_offset, out_offset,
+                                         (uint32_t)value, fn_4));
       }
     }
   }
 }
 
 TEST(Ulw_extension) {
   CcTest::InitializeVM();
 
   static const int kBufferSize = 300 * KB;
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         uint32_t value = static_cast<uint32_t>(*i & 0xFFFFFFFF);
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<uint32_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             Label success, fail, end, different;
-                             __ Ulw(t0, MemOperand(a0, in_offset));
-                             __ Ulwu(t1, MemOperand(a0, in_offset));
-                             __ Branch(&different, ne, t0, Operand(t1));
+        auto fn = [](MacroAssembler* masm, int32_t in_offset,
+                     int32_t out_offset) {
+          Label success, fail, end, different;
+          __ Ulw(t0, MemOperand(a0, in_offset));
+          __ Ulwu(t1, MemOperand(a0, in_offset));
+          __ Branch(&different, ne, t0, Operand(t1));
 
-                             // If signed and unsigned values are same, check
-                             // the upper bits to see if they are zero
-                             __ dsra(t0, t0, 31);
-                             __ Branch(&success, eq, t0, Operand(zero_reg));
-                             __ Branch(&fail);
+          // If signed and unsigned values are same, check
+          // the upper bits to see if they are zero
+          __ dsra(t0, t0, 31);
+          __ Branch(&success, eq, t0, Operand(zero_reg));
+          __ Branch(&fail);
 
-                             // If signed and unsigned values are different,
-                             // check that the upper bits are complementary
-                             __ bind(&different);
-                             __ dsra(t1, t1, 31);
-                             __ Branch(&fail, ne, t1, Operand(1));
-                             __ dsra(t0, t0, 31);
-                             __ daddiu(t0, t0, 1);
-                             __ Branch(&fail, ne, t0, Operand(zero_reg));
-                             // Fall through to success
+          // If signed and unsigned values are different,
+          // check that the upper bits are complementary
+          __ bind(&different);
+          __ dsra(t1, t1, 31);
+          __ Branch(&fail, ne, t1, Operand(1));
+          __ dsra(t0, t0, 31);
+          __ daddiu(t0, t0, 1);
+          __ Branch(&fail, ne, t0, Operand(zero_reg));
+          // Fall through to success
 
-                             __ bind(&success);
-                             __ Ulw(t0, MemOperand(a0, in_offset));
-                             __ Usw(t0, MemOperand(a0, out_offset));
-                             __ Branch(&end);
-                             __ bind(&fail);
-                             __ Usw(zero_reg, MemOperand(a0, out_offset));
-                             __ bind(&end);
-                           }));
+          __ bind(&success);
+          __ Ulw(t0, MemOperand(a0, in_offset));
+          __ Usw(t0, MemOperand(a0, out_offset));
+          __ Branch(&end);
+          __ bind(&fail);
+          __ Usw(zero_reg, MemOperand(a0, out_offset));
+          __ bind(&end);
+        };
+        CHECK_EQ(true, run_Unaligned<uint32_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn));
       }
     }
   }
 }
 
 TEST(Uld) {
   CcTest::InitializeVM();
 
   static const int kBufferSize = 300 * KB;
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         uint64_t value = *i;
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<uint64_t>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Uld(v0, MemOperand(a0, in_offset));
-                             __ Usd(v0, MemOperand(a0, out_offset));
-                           }));
+        auto fn_1 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ Uld(v0, MemOperand(a0, in_offset));
+          __ Usd(v0, MemOperand(a0, out_offset));
+        };
+        CHECK_EQ(true, run_Unaligned<uint64_t>(buffer_middle, in_offset,
+                                               out_offset, value, fn_1));
+
+        auto fn_2 = [](MacroAssembler* masm, int32_t in_offset,
+                       int32_t out_offset) {
+          __ mov(t0, a0);
+          __ Uld(a0, MemOperand(a0, in_offset));
+          __ Usd(a0, MemOperand(t0, out_offset));
+        };
         CHECK_EQ(true,
-                 run_Unaligned<uint64_t>(
-                     buffer_middle, in_offset, out_offset, (uint32_t)value,
-                     [](MacroAssembler* masm, int32_t in_offset,
-                        int32_t out_offset) {
-                       __ mov(t0, a0);
-                       __ Uld(a0, MemOperand(a0, in_offset));
-                       __ Usd(a0, MemOperand(t0, out_offset));
-                     }));
+                 run_Unaligned<uint64_t>(buffer_middle, in_offset, out_offset,
+                                         (uint32_t)value, fn_2));
       }
     }
   }
 }
 
 TEST(Ulwc1) {
   CcTest::InitializeVM();
 
   static const int kBufferSize = 300 * KB;
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         float value = static_cast<float>(*i & 0xFFFFFFFF);
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<float>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Ulwc1(f0, MemOperand(a0, in_offset), t0);
-                             __ Uswc1(f0, MemOperand(a0, out_offset), t0);
-                           }));
+        auto fn = [](MacroAssembler* masm, int32_t in_offset,
+                     int32_t out_offset) {
+          __ Ulwc1(f0, MemOperand(a0, in_offset), t0);
+          __ Uswc1(f0, MemOperand(a0, out_offset), t0);
+        };
+        CHECK_EQ(true, run_Unaligned<float>(buffer_middle, in_offset,
+                                            out_offset, value, fn));
       }
     }
   }
 }
 
 TEST(Uldc1) {
   CcTest::InitializeVM();
 
   static const int kBufferSize = 300 * KB;
   char memory_buffer[kBufferSize];
   char* buffer_middle = memory_buffer + (kBufferSize / 2);
 
   FOR_UINT64_INPUTS(i, unsigned_test_values) {
     FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
       FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
         double value = static_cast<double>(*i);
         int32_t in_offset = *j1 + *k1;
         int32_t out_offset = *j2 + *k2;
 
-        CHECK_EQ(true, run_Unaligned<double>(
-                           buffer_middle, in_offset, out_offset, value,
-                           [](MacroAssembler* masm, int32_t in_offset,
-                              int32_t out_offset) {
-                             __ Uldc1(f0, MemOperand(a0, in_offset), t0);
-                             __ Usdc1(f0, MemOperand(a0, out_offset), t0);
-                           }));
+        auto fn = [](MacroAssembler* masm, int32_t in_offset,
+                     int32_t out_offset) {
+          __ Uldc1(f0, MemOperand(a0, in_offset), t0);
+          __ Usdc1(f0, MemOperand(a0, out_offset), t0);
+        };
+        CHECK_EQ(true, run_Unaligned<double>(buffer_middle, in_offset,
+                                             out_offset, value, fn));
       }
     }
   }
 }
 
 static const std::vector<uint64_t> sltu_test_values() {
   static const uint64_t kValues[] = {
       0,
       1,
       0x7ffe,
@@ skipping 38 matching lines @@
 }
 
 TEST(Sltu) {
   CcTest::InitializeVM();
 
   FOR_UINT64_INPUTS(i, sltu_test_values) {
     FOR_UINT64_INPUTS(j, sltu_test_values) {
       uint64_t rs = *i;
       uint64_t rd = *j;
 
-      CHECK_EQ(rs < rd, run_Sltu(rs, rd,
-                                 [](MacroAssembler* masm, uint64_t imm) {
-                                   __ Sltu(v0, a0, Operand(imm));
-                                 }));
-      CHECK_EQ(rs < rd,
-               run_Sltu(rs, rd, [](MacroAssembler* masm,
-                                   uint64_t imm) { __ Sltu(v0, a0, a1); }));
+      auto fn_1 = [](MacroAssembler* masm, uint64_t imm) {
+        __ Sltu(v0, a0, Operand(imm));
+      };
+      CHECK_EQ(rs < rd, run_Sltu(rs, rd, fn_1));
+
+      auto fn_2 = [](MacroAssembler* masm, uint64_t imm) {
+        __ Sltu(v0, a0, a1);
+      };
+      CHECK_EQ(rs < rd, run_Sltu(rs, rd, fn_2));
     }
   }
 }
 
 #undef __