Replace OFFSET_OF with offsetof as far as possible.

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 271 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);
   Label L, C;
 
   // Double precision floating point instructions.
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, a)) );
-  __ ldc1(f6, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(T, d)) );  // d = c - (-b).
+  __ sdc1(f10, MemOperand(a0, offsetof(T, d)) );  // d = c - (-b).
 
-  __ sdc1(f4, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(T, g)) );
+  __ sdc1(f14, MemOperand(a0, offsetof(T, g)) );
   // g = sqrt(f) = 10.97451593465515908537
 
   if (kArchVariant == kMips64r2) {
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, h)) );
-    __ ldc1(f6, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, h)) );
+    __ sdc1(f14, MemOperand(a0, offsetof(T, h)) );
   }
 
   // Single precision floating point instructions.
-  __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fa)) );
-  __ lwc1(f6, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(T, fd)) );  // fd = fc - (-fb).
+  __ swc1(f10, MemOperand(a0, offsetof(T, fd)) );  // fd = fc - (-fb).
 
-  __ swc1(f4, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, fe)) );  // fe = fd * 120
+  __ swc1(f10, MemOperand(a0, offsetof(T, fe)) );  // fe = fd * 120
 
   __ div_s(f12, f10, f4);
-  __ swc1(f12, MemOperand(a0, OFFSET_OF(T, ff)) );  // ff = fe / fa
+  __ swc1(f12, MemOperand(a0, offsetof(T, ff)) );  // ff = fe / fa
 
   __ sqrt_s(f14, f12);
-  __ swc1(f14, MemOperand(a0, OFFSET_OF(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 48 matching lines @@
     double c;
     double d;
     int64_t high;
     int64_t low;
   } T;
   T t;
 
   Assembler assm(isolate, NULL, 0);
   Label L, C;
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, a)));
-  __ ldc1(f5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, a)));
-  __ sdc1(f5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, d)));
+  __ ldc1(f4, MemOperand(a0, offsetof(T, d)));
   __ mfhc1(a4, f4);
   __ mfc1(a5, f4);
 
-  __ sd(a4, MemOperand(a0, OFFSET_OF(T, high)));
-  __ sd(a5, MemOperand(a0, OFFSET_OF(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 22 matching lines @@
     double b;
     int i;
     int j;
   } T;
   T t;
 
   Assembler assm(isolate, NULL, 0);
   Label L, C;
 
   // Load all structure elements to registers.
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, a)) );
-  __ ldc1(f6, MemOperand(a0, OFFSET_OF(T, b)) );
-  __ lw(a4, MemOperand(a0, OFFSET_OF(T, i)) );
-  __ lw(a5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(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 25 matching lines @@
     int32_t r4;
     int32_t r5;
     int32_t r6;
   } T;
   T t;
 
   Assembler assm(isolate, NULL, 0);
   Label L, C;
 
   // Basic word load/store.
-  __ lw(a4, MemOperand(a0, OFFSET_OF(T, ui)) );
-  __ sw(a4, MemOperand(a0, OFFSET_OF(T, r1)) );
+  __ lw(a4, MemOperand(a0, offsetof(T, ui)) );
+  __ sw(a4, MemOperand(a0, offsetof(T, r1)) );
 
   // lh with positive data.
-  __ lh(a5, MemOperand(a0, OFFSET_OF(T, ui)) );
-  __ sw(a5, MemOperand(a0, OFFSET_OF(T, r2)) );
+  __ lh(a5, MemOperand(a0, offsetof(T, ui)) );
+  __ sw(a5, MemOperand(a0, offsetof(T, r2)) );
 
   // lh with negative data.
-  __ lh(a6, MemOperand(a0, OFFSET_OF(T, si)) );
-  __ sw(a6, MemOperand(a0, OFFSET_OF(T, r3)) );
+  __ lh(a6, MemOperand(a0, offsetof(T, si)) );
+  __ sw(a6, MemOperand(a0, offsetof(T, r3)) );
 
   // lhu with negative data.
-  __ lhu(a7, MemOperand(a0, OFFSET_OF(T, si)) );
-  __ sw(a7, MemOperand(a0, OFFSET_OF(T, r4)) );
+  __ lhu(a7, MemOperand(a0, offsetof(T, si)) );
+  __ sw(a7, MemOperand(a0, offsetof(T, r4)) );
 
   // lb with negative data.
-  __ lb(t0, MemOperand(a0, OFFSET_OF(T, si)) );
-  __ sw(t0, MemOperand(a0, OFFSET_OF(T, r5)) );
+  __ 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, OFFSET_OF(T, r6)) );
-  __ lhu(t1, MemOperand(a0, OFFSET_OF(T, si)) );
-  __ sh(t1, MemOperand(a0, OFFSET_OF(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 25 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);
   Label neither_is_nan, less_than, outa_here;
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, a)) );
-  __ ldc1(f6, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(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, OFFSET_OF(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;
@@ skipping 38 matching lines @@
       int32_t result_rotrv_16;
       int32_t result_rotrv_20;
       int32_t result_rotrv_24;
       int32_t result_rotrv_28;
     } T;
     T t;
 
     MacroAssembler assm(isolate, NULL, 0);
 
     // Basic word load.
-    __ lw(a4, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, result_rotr_4)) );
-    __ sw(a6, MemOperand(a0, OFFSET_OF(T, result_rotr_8)) );
-    __ sw(a7, MemOperand(a0, OFFSET_OF(T, result_rotr_12)) );
-    __ sw(t0, MemOperand(a0, OFFSET_OF(T, result_rotr_16)) );
-    __ sw(t1, MemOperand(a0, OFFSET_OF(T, result_rotr_20)) );
-    __ sw(t2, MemOperand(a0, OFFSET_OF(T, result_rotr_24)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, result_rotrv_4)) );
-    __ sw(a6, MemOperand(a0, OFFSET_OF(T, result_rotrv_8)) );
-    __ sw(a7, MemOperand(a0, OFFSET_OF(T, result_rotrv_12)) );
-    __ sw(t0, MemOperand(a0, OFFSET_OF(T, result_rotrv_16)) );
-    __ sw(t1, MemOperand(a0, OFFSET_OF(T, result_rotrv_20)) );
-    __ sw(t2, MemOperand(a0, OFFSET_OF(T, result_rotrv_24)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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 67 matching lines @@
   T t;
 
   Assembler assm(isolate, NULL, 0);
   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, OFFSET_OF(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, OFFSET_OF(T, dbl_mant)));
-    __ sw(a5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, long_lo)));
-    __ sw(a5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, a_converted)));
+    __ sdc1(f1, MemOperand(a0, offsetof(T, a_converted)));
 
 
     // Convert the b long integers to double b.
-    __ lw(a4, MemOperand(a0, OFFSET_OF(T, b_long_lo)));
-    __ lw(a5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, b)));
+    __ sdc1(f10, MemOperand(a0, offsetof(T, b)));
 
     // Convert double b back to long-int.
-    __ ldc1(f31, MemOperand(a0, OFFSET_OF(T, b)));
+    __ ldc1(f31, MemOperand(a0, offsetof(T, b)));
     __ cvt_l_d(f31, f31);
     __ dmfc1(a7, f31);
-    __ sd(a7, MemOperand(a0, OFFSET_OF(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());
@@ skipping 42 matching lines @@
       int32_t swr_0;
       int32_t swr_1;
       int32_t swr_2;
       int32_t swr_3;
     } T;
     T t;
 
     Assembler assm(isolate, NULL, 0);
 
     // Test all combinations of LWL and vAddr.
-    __ lw(a4, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwl(a4, MemOperand(a0, OFFSET_OF(T, mem_init)));
-    __ sw(a4, MemOperand(a0, OFFSET_OF(T, lwl_0)));
+    __ lw(a4, MemOperand(a0, offsetof(T, reg_init)));
+    __ lwl(a4, MemOperand(a0, offsetof(T, mem_init)));
+    __ sw(a4, MemOperand(a0, offsetof(T, lwl_0)));
 
-    __ lw(a5, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwl(a5, MemOperand(a0, OFFSET_OF(T, mem_init) + 1));
-    __ sw(a5, MemOperand(a0, OFFSET_OF(T, lwl_1)));
+    __ 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)));
 
-    __ lw(a6, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwl(a6, MemOperand(a0, OFFSET_OF(T, mem_init) + 2));
-    __ sw(a6, MemOperand(a0, OFFSET_OF(T, lwl_2)));
+    __ 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)));
 
-    __ lw(a7, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwl(a7, MemOperand(a0, OFFSET_OF(T, mem_init) + 3));
-    __ sw(a7, MemOperand(a0, OFFSET_OF(T, lwl_3)));
+    __ 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)));
 
     // Test all combinations of LWR and vAddr.
-    __ lw(a4, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwr(a4, MemOperand(a0, OFFSET_OF(T, mem_init)));
-    __ sw(a4, MemOperand(a0, OFFSET_OF(T, lwr_0)));
+    __ lw(a4, MemOperand(a0, offsetof(T, reg_init)));
+    __ lwr(a4, MemOperand(a0, offsetof(T, mem_init)));
+    __ sw(a4, MemOperand(a0, offsetof(T, lwr_0)));
 
-    __ lw(a5, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwr(a5, MemOperand(a0, OFFSET_OF(T, mem_init) + 1));
-    __ sw(a5, MemOperand(a0, OFFSET_OF(T, lwr_1)));
+    __ 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)));
 
-    __ lw(a6, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwr(a6, MemOperand(a0, OFFSET_OF(T, mem_init) + 2));
-    __ sw(a6, MemOperand(a0, OFFSET_OF(T, lwr_2)) );
+    __ 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)) );
 
-    __ lw(a7, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ lwr(a7, MemOperand(a0, OFFSET_OF(T, mem_init) + 3));
-    __ sw(a7, MemOperand(a0, OFFSET_OF(T, lwr_3)) );
+    __ 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)) );
 
     // Test all combinations of SWL and vAddr.
-    __ lw(a4, MemOperand(a0, OFFSET_OF(T, mem_init)));
-    __ sw(a4, MemOperand(a0, OFFSET_OF(T, swl_0)));
-    __ lw(a4, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swl(a4, MemOperand(a0, OFFSET_OF(T, swl_0)));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a5, MemOperand(a0, OFFSET_OF(T, swl_1)));
-    __ lw(a5, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swl(a5, MemOperand(a0, OFFSET_OF(T, swl_1) + 1));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a6, MemOperand(a0, OFFSET_OF(T, swl_2)));
-    __ lw(a6, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swl(a6, MemOperand(a0, OFFSET_OF(T, swl_2) + 2));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a7, MemOperand(a0, OFFSET_OF(T, swl_3)));
-    __ lw(a7, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swl(a7, MemOperand(a0, OFFSET_OF(T, swl_3) + 3));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a4, MemOperand(a0, OFFSET_OF(T, swr_0)));
-    __ lw(a4, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swr(a4, MemOperand(a0, OFFSET_OF(T, swr_0)));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a5, MemOperand(a0, OFFSET_OF(T, swr_1)));
-    __ lw(a5, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swr(a5, MemOperand(a0, OFFSET_OF(T, swr_1) + 1));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a6, MemOperand(a0, OFFSET_OF(T, swr_2)));
-    __ lw(a6, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swr(a6, MemOperand(a0, OFFSET_OF(T, swr_2) + 2));
+    __ 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, OFFSET_OF(T, mem_init)));
-    __ sw(a7, MemOperand(a0, OFFSET_OF(T, swr_3)));
-    __ lw(a7, MemOperand(a0, OFFSET_OF(T, reg_init)));
-    __ swr(a7, MemOperand(a0, OFFSET_OF(T, swr_3) + 3));
+    __ 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());
     t.reg_init = 0xaabbccdd;
@@ skipping 37 matching lines @@
       int32_t  y2;
       int32_t  y3;
       int32_t  y4;
   } T;
   T t;
 
   MacroAssembler assm(isolate, NULL, 0);
 
   __ mov(t2, fp);  // Save frame pointer.
   __ mov(fp, a0);  // Access struct T by fp.
-  __ lw(a4, MemOperand(a0, OFFSET_OF(T, y)));
-  __ lw(a7, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, y)));
-  __ lw(a4, MemOperand(fp, OFFSET_OF(T, y)));
+  __ sw(a4, MemOperand(fp, offsetof(T, y)));
+  __ lw(a4, MemOperand(fp, offsetof(T, y)));
   __ nop();
-  __ sw(a4, MemOperand(fp, OFFSET_OF(T, y)));
-  __ lw(a5, MemOperand(fp, OFFSET_OF(T, y)));
+  __ sw(a4, MemOperand(fp, offsetof(T, y)));
+  __ lw(a5, MemOperand(fp, offsetof(T, y)));
   __ nop();
   __ push(a5);
-  __ lw(a5, MemOperand(fp, OFFSET_OF(T, y)));
+  __ lw(a5, MemOperand(fp, offsetof(T, y)));
   __ pop(a5);
   __ nop();
   __ push(a5);
-  __ lw(a6, MemOperand(fp, OFFSET_OF(T, y)));
+  __ lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a5);
   __ nop();
   __ push(a5);
-  __ lw(a6, MemOperand(fp, OFFSET_OF(T, y)));
+  __ lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a6);
   __ nop();
   __ push(a6);
-  __ lw(a6, MemOperand(fp, OFFSET_OF(T, y)));
+  __ lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a5);
   __ nop();
   __ push(a5);
-  __ lw(a6, MemOperand(fp, OFFSET_OF(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);
 
-  __ sw(a4, MemOperand(a0, OFFSET_OF(T, cvt_small_in)));
+  __ sw(a4, MemOperand(a0, offsetof(T, cvt_small_in)));
   __ Cvt_d_uw(f10, a4, f22);
-  __ sdc1(f10, MemOperand(a0, OFFSET_OF(T, cvt_small_out)));
+  __ sdc1(f10, MemOperand(a0, offsetof(T, cvt_small_out)));
 
   __ Trunc_uw_d(f10, f10, f22);
-  __ swc1(f10, MemOperand(a0, OFFSET_OF(T, trunc_small_out)));
+  __ swc1(f10, MemOperand(a0, offsetof(T, trunc_small_out)));
 
-  __ sw(a4, MemOperand(a0, OFFSET_OF(T, cvt_big_in)));
+  __ sw(a4, MemOperand(a0, offsetof(T, cvt_big_in)));
   __ Cvt_d_uw(f8, a4, f22);
-  __ sdc1(f8, MemOperand(a0, OFFSET_OF(T, cvt_big_out)));
+  __ sdc1(f8, MemOperand(a0, offsetof(T, cvt_big_out)));
 
   __ Trunc_uw_d(f8, f8, f22);
-  __ swc1(f8, MemOperand(a0, OFFSET_OF(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 @@
 
 #undef ROUND_STRUCT_ELEMENT
 
   MacroAssembler assm(isolate, NULL, 0);
 
   // Save FCSR.
   __ cfc1(a1, FCSR);
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 #define RUN_ROUND_TEST(x) \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, round_up_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, round_up_in))); \
   __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, OFFSET_OF(T, x##_up_out))); \
+  __ swc1(f0, MemOperand(a0, offsetof(T, x##_up_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, round_down_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, round_down_in))); \
   __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, OFFSET_OF(T, x##_down_out))); \
+  __ swc1(f0, MemOperand(a0, offsetof(T, x##_down_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, neg_round_up_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, neg_round_up_in))); \
   __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, OFFSET_OF(T, neg_##x##_up_out))); \
+  __ swc1(f0, MemOperand(a0, offsetof(T, neg_##x##_up_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, neg_round_down_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, neg_round_down_in))); \
   __ x##_w_d(f0, f0); \
-  __ swc1(f0, MemOperand(a0, OFFSET_OF(T, neg_##x##_down_out))); \
+  __ swc1(f0, MemOperand(a0, offsetof(T, neg_##x##_down_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, err1_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, err1_in))); \
   __ ctc1(zero_reg, FCSR); \
   __ x##_w_d(f0, f0); \
   __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, OFFSET_OF(T, x##_err1_out))); \
+  __ sw(a2, MemOperand(a0, offsetof(T, x##_err1_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, err2_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, err2_in))); \
   __ ctc1(zero_reg, FCSR); \
   __ x##_w_d(f0, f0); \
   __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, OFFSET_OF(T, x##_err2_out))); \
+  __ sw(a2, MemOperand(a0, offsetof(T, x##_err2_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, err3_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, err3_in))); \
   __ ctc1(zero_reg, FCSR); \
   __ x##_w_d(f0, f0); \
   __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, OFFSET_OF(T, x##_err3_out))); \
+  __ sw(a2, MemOperand(a0, offsetof(T, x##_err3_out))); \
   \
-  __ ldc1(f0, MemOperand(a0, OFFSET_OF(T, err4_in))); \
+  __ ldc1(f0, MemOperand(a0, offsetof(T, err4_in))); \
   __ ctc1(zero_reg, FCSR); \
   __ x##_w_d(f0, f0); \
   __ cfc1(a2, FCSR); \
-  __ sw(a2, MemOperand(a0, OFFSET_OF(T, x##_err4_out))); \
-  __ swc1(f0, MemOperand(a0, OFFSET_OF(T, x##_invalid_result)));
+  __ 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 67 matching lines @@
     int64_t r6;
     uint32_t ui;
     int32_t si;
   } T;
   T t;
 
   Assembler assm(isolate, NULL, 0);
   Label L, C;
 
   // Basic 32-bit word load/store, with un-signed data.
-  __ lw(a4, MemOperand(a0, OFFSET_OF(T, ui)));
-  __ sw(a4, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, r2)));
+  __ sd(a4, MemOperand(a0, offsetof(T, r2)));
 
   // Basic 32-bit word load/store, with SIGNED data.
-  __ lw(a5, MemOperand(a0, OFFSET_OF(T, si)));
-  __ sw(a5, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, r4)));
+  __ sd(a5, MemOperand(a0, offsetof(T, r4)));
 
   // 32-bit UNSIGNED word load/store, with SIGNED data.
-  __ lwu(a6, MemOperand(a0, OFFSET_OF(T, si)));
-  __ sw(a6, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(T, r6)));
+  __ sd(a6, MemOperand(a0, offsetof(T, r6)));
 
   // lh with positive data.
-  __ lh(a5, MemOperand(a0, OFFSET_OF(T, ui)));
-  __ sw(a5, MemOperand(a0, OFFSET_OF(T, r2)));
+  __ lh(a5, MemOperand(a0, offsetof(T, ui)));
+  __ sw(a5, MemOperand(a0, offsetof(T, r2)));
 
   // lh with negative data.
-  __ lh(a6, MemOperand(a0, OFFSET_OF(T, si)));
-  __ sw(a6, MemOperand(a0, OFFSET_OF(T, r3)));
+  __ lh(a6, MemOperand(a0, offsetof(T, si)));
+  __ sw(a6, MemOperand(a0, offsetof(T, r3)));
 
   // lhu with negative data.
-  __ lhu(a7, MemOperand(a0, OFFSET_OF(T, si)));
-  __ sw(a7, MemOperand(a0, OFFSET_OF(T, r4)));
+  __ lhu(a7, MemOperand(a0, offsetof(T, si)));
+  __ sw(a7, MemOperand(a0, offsetof(T, r4)));
 
   // lb with negative data.
-  __ lb(t0, MemOperand(a0, OFFSET_OF(T, si)));
-  __ sw(t0, MemOperand(a0, OFFSET_OF(T, r5)));
+  __ 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, OFFSET_OF(T, r6)));
-  __ lhu(t1, MemOperand(a0, OFFSET_OF(T, si)));
-  __ sh(t1, MemOperand(a0, OFFSET_OF(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 = 0x44332211;
@@ skipping 41 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, OFFSET_OF(Test, a)));  // a = 1
+    __ sw(t3, MemOperand(a0, offsetof(Test, a)));  // a = 1
     __ seleqz(t2, t1, t1);                          // t2 = 0
-    __ sw(t2, MemOperand(a0, OFFSET_OF(Test, b)));  // b = 0
+    __ sw(t2, MemOperand(a0, offsetof(Test, b)));  // b = 0
     __ selnez(t3, t1, zero_reg);                    // t3 = 1;
-    __ sw(t3, MemOperand(a0, OFFSET_OF(Test, c)));  // c = 0
+    __ sw(t3, MemOperand(a0, offsetof(Test, c)));  // c = 0
     __ selnez(t3, t1, t1);                          // t3 = 1
-    __ sw(t3, MemOperand(a0, OFFSET_OF(Test, d)));  // d = 1
+    __ sw(t3, MemOperand(a0, offsetof(Test, d)));  // d = 1
     // Floating point part of test.
-    __ ldc1(f0, MemOperand(a0, OFFSET_OF(Test, e)) );  // src
-    __ ldc1(f2, MemOperand(a0, OFFSET_OF(Test, f)) );  // test
-    __ lwc1(f8, MemOperand(a0, OFFSET_OF(Test, i)) );  // src
-    __ lwc1(f10, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(Test, g)) );  // src
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(Test, h)) );  // src
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(Test, k)) );  // src
-    __ swc1(f14, MemOperand(a0, OFFSET_OF(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(f, &test, 0, 0, 0, 0));
 
@@ skipping 68 matching lines @@
     double inputsa[tableLength] = {2.0, 3.0, dblNaN, 3.0, dblNaN};
     double inputsb[tableLength] = {3.0, 2.0, 3.0, dblNaN, dblNaN};
     double outputsdmin[tableLength] = {2.0, 2.0, 3.0, 3.0, dblNaN};
     double outputsdmax[tableLength] = {3.0, 3.0, 3.0, 3.0, dblNaN};
 
     float inputse[tableLength] = {2.0, 3.0, fltNaN, 3.0, fltNaN};
     float inputsf[tableLength] = {3.0, 2.0, 3.0, fltNaN, fltNaN};
     float outputsfmin[tableLength] = {2.0, 2.0, 3.0, 3.0, fltNaN};
     float outputsfmax[tableLength] = {3.0, 3.0, 3.0, 3.0, fltNaN};
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, a)));
-    __ ldc1(f8, MemOperand(a0, OFFSET_OF(TestFloat, b)));
-    __ lwc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, e)));
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, c)));
-    __ sdc1(f12, MemOperand(a0, OFFSET_OF(TestFloat, d)));
-    __ swc1(f14, MemOperand(a0, OFFSET_OF(TestFloat, g)));
-    __ swc1(f16, MemOperand(a0, OFFSET_OF(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 = 0; i < tableLength; i++) {
       test.a = inputsa[i];
@@ skipping 90 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, OFFSET_OF(TestFloat, a)) );
-    __ lw(t0, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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 18 matching lines @@
     typedef struct test {
       double dd;
       double ds;
       double dt;
       float fd;
       float fs;
       float ft;
     } Test;
 
     Test test;
-    __ ldc1(f0, MemOperand(a0, OFFSET_OF(Test, dd)) );  // test
-    __ ldc1(f2, MemOperand(a0, OFFSET_OF(Test, ds)) );  // src1
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, dt)) );  // src2
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, fd)) );  // test
-    __ lwc1(f8, MemOperand(a0, OFFSET_OF(Test, fs)) );  // src1
-    __ lwc1(f10, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(Test, dd)) );
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(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 104 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, OFFSET_OF(TestFloat, a)) );
-    __ lw(t0, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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 71 matching lines @@
       9.8, -8.9, 9.8,
       -9.8, -8.9, -9.8
     };
     float resf1[tableLength] = {
       5.3, 5.3, 6.1,
       -10.0, 9.8, 9.8,
       -10.0, 9.8, 9.8,
       -10.0, -11.2, -9.8
     };
 
-    __ ldc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, a)) );
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, b)) );
-    __ lwc1(f8, MemOperand(a0, OFFSET_OF(TestFloat, c)) );
-    __ lwc1(f10, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, resf)) );
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, resd)) );
-    __ swc1(f16, MemOperand(a0, OFFSET_OF(TestFloat, resf1)) );
-    __ sdc1(f14, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
       test.a = inputsa[i];
@@ skipping 40 matching lines @@
         2147483648.0,
         std::numeric_limits<float>::quiet_NaN(),
         std::numeric_limits<float>::infinity()
         };
     double outputs[tableLength] = {
         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};
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+    __ 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, OFFSET_OF(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 36 matching lines @@
       4.8, 4.8, -4.8, -0.29
     };
 
     float outputs_S[tableLength] = {
       4.8, 4.8, -4.8, -0.29
     };
     double outputs_D[tableLength] = {
       5.3, -5.3, 5.3, -2.9
     };
 
-    __ ldc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, a)) );
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, c)) );
-    __ lw(t0, MemOperand(a0, OFFSET_OF(TestFloat, rt)) );
+    __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
+    __ lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)) );
+    __ lw(t0, MemOperand(a0, offsetof(TestFloat, rt)) );
     __ li(t1, 0x0);
     __ mtc1(t1, f12);
     __ mtc1(t1, f10);
     __ mtc1(t1, f16);
     __ mtc1(t1, f14);
-    __ sdc1(f12, MemOperand(a0, OFFSET_OF(TestFloat, bold)) );
-    __ swc1(f10, MemOperand(a0, OFFSET_OF(TestFloat, dold)) );
-    __ sdc1(f16, MemOperand(a0, OFFSET_OF(TestFloat, bold1)) );
-    __ swc1(f14, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, d)) );
-    __ sdc1(f12, MemOperand(a0, OFFSET_OF(TestFloat, b)) );
-    __ swc1(f14, MemOperand(a0, OFFSET_OF(TestFloat, d1)) );
-    __ sdc1(f16, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 59 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);
-        __ ldc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, srcd)) );
-        __ lwc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, srcf)) );
-        __ lw(t1, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dstdold)) );
-        __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dstf)) );
-        __ sdc1(f10, MemOperand(a0, OFFSET_OF(TestFloat, dstd)) );
-        __ sdc1(f10, MemOperand(a0, OFFSET_OF(TestFloat, dstdold1)) );
-        __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dstf1)) );
-        __ sdc1(f10, MemOperand(a0, OFFSET_OF(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[tableLength] = {
       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, OFFSET_OF(Test, a)) );
-  __ lw(t0, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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 33 matching lines @@
       2147483648.0,
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::infinity()
       };
   double outputs[tableLength] = {
       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, kFPUInvalidResult,
       kFPUInvalidResult};
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+  __ 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, OFFSET_OF(Test, c)) );
-  __ swc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 31 matching lines @@
       2147483648.0,
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::infinity()
       };
   double outputs[tableLength] = {
       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, kFPUInvalidResult,
       kFPUInvalidResult};
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+  __ 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, OFFSET_OF(Test, c)) );
-  __ swc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 31 matching lines @@
         2147483648.0,
         std::numeric_limits<float>::quiet_NaN(),
         std::numeric_limits<float>::infinity()
         };
     double outputs[tableLength] = {
         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, dFPU64InvalidResult,
         dFPU64InvalidResult};
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+    __ 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, OFFSET_OF(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 40 matching lines @@
     5.3, 4.8, 2.9, -5.3, -4.8, -2.9
   };
   float inputft_S[tableLength] = {
     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[tableLength] = {
     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, OFFSET_OF(TestFloat, a)) );
-  __ lwc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, b)) );
-  __ ldc1(f8, MemOperand(a0, OFFSET_OF(TestFloat, c)) );
-  __ ldc1(f10, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputfs_S[i];
@@ skipping 39 matching lines @@
   };
   float inputs_S[tableLength] = {
     0.0, 4.0, 2.0, 4e-28
   };
 
   float outputs_S[tableLength] = {
     0.0, 2.0, sqrt2_s, 2e-14
   };
 
 
-  __ lwc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, a)) );
-  __ ldc1(f8, MemOperand(a0, OFFSET_OF(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(f20, f2);
-  __ swc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, OFFSET_OF(TestFloat, resultD)) );
-  __ swc1(f16, MemOperand(a0, OFFSET_OF(TestFloat, resultS1)) );
-  __ sdc1(f14, MemOperand(a0, OFFSET_OF(TestFloat, resultD1)) );
-  __ swc1(f20, MemOperand(a0, OFFSET_OF(TestFloat, resultS2)) );
-  __ sdc1(f18, MemOperand(a0, OFFSET_OF(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(f20, 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 < tableLength; i++) {
@@ skipping 52 matching lines @@
   double outputs_D[tableLength] = {
     -4.0, 2.0
   };
   float inputs_S[tableLength] = {
     4.0, -2.0
   };
 
   float outputs_S[tableLength] = {
     -4.0, 2.0
   };
-  __ lwc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, a)) );
-  __ ldc1(f8, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputs_S[i];
@@ skipping 30 matching lines @@
     4.8, 4.8, -4.8, -0.29
   };
 
   float inputfs_S[tableLength] = {
     5.3, -5.3, 5.3, -2.9
   };
   float inputft_S[tableLength] = {
     4.8, 4.8, -4.8, -0.29
   };
 
-  __ lwc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, a)) );
-  __ lwc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, b)) );
-  __ ldc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, c)) );
-  __ ldc1(f8, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, resultS)) );
-  __ sdc1(f12, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputfs_S[i];
@@ skipping 29 matching lines @@
     4.8, 4.8, -4.8, -0.29
   };
 
   float outputs_S[tableLength] = {
     4.8, 4.8, -4.8, -0.29
   };
   double outputs_D[tableLength] = {
     5.3, -5.3, 5.3, -2.9
   };
 
-  __ ldc1(f2, MemOperand(a0, OFFSET_OF(TestFloat, a)) );
-  __ lwc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, c)) );
+  __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
+  __ lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)) );
   __ mov_s(f18, f6);
   __ mov_d(f20, f2);
-  __ swc1(f18, MemOperand(a0, OFFSET_OF(TestFloat, d)) );
-  __ sdc1(f20, MemOperand(a0, OFFSET_OF(TestFloat, b)) );
+  __ swc1(f18, MemOperand(a0, offsetof(TestFloat, d)) );
+  __ sdc1(f20, 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 < tableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 32 matching lines @@
       2147483648.0,
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::infinity()
       };
   double outputs[tableLength] = {
       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, kFPUInvalidResult,
       kFPUInvalidResult};
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+  __ 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, OFFSET_OF(Test, c)) );
-  __ swc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 31 matching lines @@
         2147483648.0,
         std::numeric_limits<float>::quiet_NaN(),
         std::numeric_limits<float>::infinity()
         };
     double outputs[tableLength] = {
         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, dFPU64InvalidResult,
         dFPU64InvalidResult};
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+    __ 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, OFFSET_OF(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 31 matching lines @@
       2147483648.0,
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::infinity()
       };
   double outputs[tableLength] = {
       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, kFPUInvalidResult,
       kFPUInvalidResult};
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-  __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+  __ 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, OFFSET_OF(Test, c)) );
-  __ swc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
     test.a = inputs_D[i];
@@ skipping 31 matching lines @@
         2147483648.0,
         std::numeric_limits<float>::quiet_NaN(),
         std::numeric_limits<float>::infinity()
         };
     double outputs[tableLength] = {
         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, dFPU64InvalidResult,
         dFPU64InvalidResult};
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, a)) );
-    __ lwc1(f6, MemOperand(a0, OFFSET_OF(Test, b)) );
+    __ 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, OFFSET_OF(Test, c)) );
-    __ sdc1(f10, MemOperand(a0, OFFSET_OF(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 < tableLength; i++) {
       test.a = inputs_D[i];
@@ skipping 242 matching lines @@
       int64_t r2;
       int64_t r3;
       int64_t r4;
       int64_t r5;
       int64_t r6;
     } T;
     T t;
 
     Assembler assm(isolate, NULL, 0);
 
-    __ ld(a4, MemOperand(a0, OFFSET_OF(T, r1)));
+    __ ld(a4, MemOperand(a0, offsetof(T, r1)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, OFFSET_OF(T, r1)));
+    __ sd(a6, MemOperand(a0, offsetof(T, r1)));
 
-    __ ld(a4, MemOperand(a0, OFFSET_OF(T, r2)));
+    __ ld(a4, MemOperand(a0, offsetof(T, r2)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, OFFSET_OF(T, r2)));
+    __ sd(a6, MemOperand(a0, offsetof(T, r2)));
 
-    __ ld(a4, MemOperand(a0, OFFSET_OF(T, r3)));
+    __ ld(a4, MemOperand(a0, offsetof(T, r3)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, OFFSET_OF(T, r3)));
+    __ sd(a6, MemOperand(a0, offsetof(T, r3)));
 
-    __ ld(a4, MemOperand(a0, OFFSET_OF(T, r4)));
+    __ ld(a4, MemOperand(a0, offsetof(T, r4)));
     __ nop();
     __ bitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, OFFSET_OF(T, r4)));
+    __ sd(a6, MemOperand(a0, offsetof(T, r4)));
 
-    __ ld(a4, MemOperand(a0, OFFSET_OF(T, r5)));
+    __ ld(a4, MemOperand(a0, offsetof(T, r5)));
     __ nop();
     __ dbitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, OFFSET_OF(T, r5)));
+    __ sd(a6, MemOperand(a0, offsetof(T, r5)));
 
-    __ ld(a4, MemOperand(a0, OFFSET_OF(T, r6)));
+    __ ld(a4, MemOperand(a0, offsetof(T, r6)));
     __ nop();
     __ dbitswap(a6, a4);
-    __ sd(a6, MemOperand(a0, OFFSET_OF(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 42 matching lines @@
       float  fPosInf;
       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);
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dSignalingNan)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dSignalingNan)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dSignalingNan)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dSignalingNan)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dQuietNan)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dQuietNan)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dQuietNan)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dQuietNan)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dNegInf)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegInf)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dNegInf)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegInf)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dNegNorm)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegNorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dNegNorm)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegNorm)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dNegSubnorm)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegSubnorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dNegSubnorm)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegSubnorm)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dNegZero)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dNegZero)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dNegZero)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dNegZero)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dPosInf)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosInf)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dPosInf)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosInf)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dPosNorm)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosNorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dPosNorm)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosNorm)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dPosSubnorm)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosSubnorm)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dPosSubnorm)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosSubnorm)));
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(T, dPosZero)));
+    __ ldc1(f4, MemOperand(a0, offsetof(T, dPosZero)));
     __ class_d(f6, f4);
-    __ sdc1(f6, MemOperand(a0, OFFSET_OF(T, dPosZero)));
+    __ sdc1(f6, MemOperand(a0, offsetof(T, dPosZero)));
 
     // Testing instruction CLASS.S
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fSignalingNan)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fSignalingNan)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fSignalingNan)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fSignalingNan)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fQuietNan)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fQuietNan)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fQuietNan)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fQuietNan)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fNegInf)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegInf)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fNegInf)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fNegInf)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fNegNorm)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegNorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fNegNorm)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fNegNorm)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fNegSubnorm)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegSubnorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fNegSubnorm)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fNegSubnorm)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fNegZero)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fNegZero)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fNegZero)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fNegZero)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fPosInf)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosInf)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fPosInf)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fPosInf)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fPosNorm)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosNorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fPosNorm)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fPosNorm)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fPosSubnorm)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosSubnorm)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(T, fPosSubnorm)));
+    __ swc1(f6, MemOperand(a0, offsetof(T, fPosSubnorm)));
 
-    __ lwc1(f4, MemOperand(a0, OFFSET_OF(T, fPosZero)));
+    __ lwc1(f4, MemOperand(a0, offsetof(T, fPosZero)));
     __ class_s(f6, f4);
-    __ swc1(f6, MemOperand(a0, OFFSET_OF(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 56 matching lines @@
     int64_t fir;
     double a;
     float b;
     double fcsr;
   } TestFloat;
 
   TestFloat test;
 
   // Save FIR.
   __ cfc1(a1, FCSR);
-  __ sd(a1, MemOperand(a0, OFFSET_OF(TestFloat, fcsr)));
+  __ sd(a1, MemOperand(a0, offsetof(TestFloat, fcsr)));
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, a)));
+  __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
   __ abs_d(f10, f4);
-  __ sdc1(f10, MemOperand(a0, OFFSET_OF(TestFloat, a)));
+  __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, a)));
 
-  __ lwc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, b)));
+  __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, b)));
   __ abs_s(f10, f4);
-  __ swc1(f10, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, a)));
-  __ ldc1(f8, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, c)));
+  __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
 
-  __ lwc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, fa)));
-  __ lwc1(f8, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(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 57 matching lines @@
       uint32_t fOlt;
       uint32_t fUlt;
       uint32_t fOle;
       uint32_t fUle;
     } TestFloat;
 
     TestFloat test;
 
     __ li(t1, 1);
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, dOp1)));
-    __ ldc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, dOp2)));
+    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, dOp1)));
+    __ ldc1(f6, MemOperand(a0, offsetof(TestFloat, dOp2)));
 
-    __ lwc1(f14, MemOperand(a0, OFFSET_OF(TestFloat, fOp1)));
-    __ lwc1(f16, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dF)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUn)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dEq)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUeq)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dOlt)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUlt)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dOle)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUle)) );
-    __ sw(t3, MemOperand(a0, OFFSET_OF(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 120 matching lines @@
       float fUle;
       float fOr;
       float fUne;
       float fNe;
     } TestFloat;
 
     TestFloat test;
 
     __ li(t1, 1);
 
-    __ ldc1(f4, MemOperand(a0, OFFSET_OF(TestFloat, dOp1)));
-    __ ldc1(f6, MemOperand(a0, OFFSET_OF(TestFloat, dOp2)));
+    __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, dOp1)));
+    __ ldc1(f6, MemOperand(a0, offsetof(TestFloat, dOp2)));
 
-    __ lwc1(f14, MemOperand(a0, OFFSET_OF(TestFloat, fOp1)));
-    __ lwc1(f16, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dF)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUn)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dEq)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUeq)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dOlt)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUlt)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dOle)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUle)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dOr)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dUne)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(TestFloat, dNe)) );
-    __ swc1(f12, MemOperand(a0, OFFSET_OF(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 137 matching lines @@
   } TestFloat;
 
   TestFloat test;
 
   // Save FCSR.
   __ cfc1(a1, FCSR);
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 
 #define GENERATE_CVT_TEST(x, y, z) \
-  __ y##c1(f0, MemOperand(a0, OFFSET_OF(TestFloat, x##_in))); \
+  __ y##c1(f0, MemOperand(a0, offsetof(TestFloat, x##_in))); \
   __ x(f0, f0); \
   __ nop(); \
-  __ z##c1(f0, MemOperand(a0, OFFSET_OF(TestFloat, x##_out)));
+  __ z##c1(f0, MemOperand(a0, offsetof(TestFloat, x##_out)));
 
   GENERATE_CVT_TEST(cvt_d_s, lw, sd)
   GENERATE_CVT_TEST(cvt_d_w, lw, sd)
   GENERATE_CVT_TEST(cvt_d_l, ld, sd)
 
   GENERATE_CVT_TEST(cvt_l_s, lw, sd)
   GENERATE_CVT_TEST(cvt_l_d, ld, sd)
 
   GENERATE_CVT_TEST(cvt_s_d, ld, sw)
   GENERATE_CVT_TEST(cvt_s_w, lw, sw)
@@ skipping 156 matching lines @@
     float  fRes;
   } Test;
 
   Test test;
 
   // Save FCSR.
   __ cfc1(a1, FCSR);
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 
-  __ ldc1(f4, MemOperand(a0, OFFSET_OF(Test, dOp1)) );
-  __ ldc1(f2, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(Test, dRes)) );
+  __ sdc1(f6, MemOperand(a0, offsetof(Test, dRes)) );
 
-  __ lwc1(f4, MemOperand(a0, OFFSET_OF(Test, fOp1)) );
-  __ lwc1(f2, MemOperand(a0, OFFSET_OF(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, OFFSET_OF(Test, fRes)) );
+  __ swc1(f6, MemOperand(a0, offsetof(Test, fRes)) );
 
     // 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>());
@@ skipping 68 matching lines @@
   test.fOp1 = std::numeric_limits<float>::quiet_NaN();
   test.fOp2 = -5.0;
 
   (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
   CHECK_EQ(true, std::isnan(test.dRes));
   CHECK_EQ(true, std::isnan(test.fRes));
 }
 
 
 #undef __