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

src/mips64/code-stubs-mips64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_MIPS64
 
 #include "src/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/ic/handler-compiler.h"
 #include "src/ic/ic.h"
 #include "src/ic/stub-cache.h"
 #include "src/isolate.h"
 #include "src/mips64/code-stubs-mips64.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-macro-assembler.h"
 #include "src/runtime/runtime.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm)
 
 void ArrayNArgumentsConstructorStub::Generate(MacroAssembler* masm) {
   __ dsll(t9, a0, kPointerSizeLog2);
   __ Daddu(t9, sp, t9);
-  __ sd(a1, MemOperand(t9, 0));
+  __ Sd(a1, MemOperand(t9, 0));
   __ Push(a1);
   __ Push(a2);
   __ Daddu(a0, a0, 3);
   __ TailCallRuntime(Runtime::kNewArray);
 }
 
 static void EmitIdenticalObjectComparison(MacroAssembler* masm, Label* slow,
                                           Condition cc);
 static void EmitSmiNonsmiComparison(MacroAssembler* masm,
                                     Register lhs,
@@ skipping 15 matching lines @@
   int param_count = descriptor.GetRegisterParameterCount();
   {
     // Call the runtime system in a fresh internal frame.
     FrameScope scope(masm, StackFrame::INTERNAL);
     DCHECK((param_count == 0) ||
            a0.is(descriptor.GetRegisterParameter(param_count - 1)));
     // Push arguments, adjust sp.
     __ Dsubu(sp, sp, Operand(param_count * kPointerSize));
     for (int i = 0; i < param_count; ++i) {
       // Store argument to stack.
-      __ sd(descriptor.GetRegisterParameter(i),
+      __ Sd(descriptor.GetRegisterParameter(i),
             MemOperand(sp, (param_count - 1 - i) * kPointerSize));
     }
     __ CallExternalReference(miss, param_count);
   }
 
   __ Ret();
 }
 
 
 void DoubleToIStub::Generate(MacroAssembler* masm) {
   Label out_of_range, only_low, negate, done;
   Register input_reg = source();
   Register result_reg = destination();
 
   int double_offset = offset();
   // Account for saved regs if input is sp.
   if (input_reg.is(sp)) double_offset += 3 * kPointerSize;
 
   Register scratch =
       GetRegisterThatIsNotOneOf(input_reg, result_reg);
   Register scratch2 =
       GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch);
   Register scratch3 =
       GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch, scratch2);
   DoubleRegister double_scratch = kLithiumScratchDouble;
 
   __ Push(scratch, scratch2, scratch3);
   if (!skip_fastpath()) {
     // Load double input.
-    __ ldc1(double_scratch, MemOperand(input_reg, double_offset));
+    __ Ldc1(double_scratch, MemOperand(input_reg, double_offset));
 
     // Clear cumulative exception flags and save the FCSR.
     __ cfc1(scratch2, FCSR);
     __ ctc1(zero_reg, FCSR);
 
     // Try a conversion to a signed integer.
     __ Trunc_w_d(double_scratch, double_scratch);
     // Move the converted value into the result register.
     __ mfc1(scratch3, double_scratch);
 
@@ skipping 11 matching lines @@
     __ Branch(&error, ne, scratch, Operand(zero_reg));
     __ Move(result_reg, scratch3);
     __ Branch(&done);
     __ bind(&error);
   }
 
   // Load the double value and perform a manual truncation.
   Register input_high = scratch2;
   Register input_low = scratch3;
 
-  __ lw(input_low,
+  __ Lw(input_low,
         MemOperand(input_reg, double_offset + Register::kMantissaOffset));
-  __ lw(input_high,
+  __ Lw(input_high,
         MemOperand(input_reg, double_offset + Register::kExponentOffset));
 
   Label normal_exponent, restore_sign;
   // Extract the biased exponent in result.
   __ Ext(result_reg,
          input_high,
          HeapNumber::kExponentShift,
          HeapNumber::kExponentBits);
 
   // Check for Infinity and NaNs, which should return 0.
@@ skipping 135 matching lines @@
   // x < x is false regardless.  For the others here is some code to check
   // for NaN.
   if (cc != lt && cc != gt) {
     __ bind(&heap_number);
     // It is a heap number, so return non-equal if it's NaN and equal if it's
     // not NaN.
 
     // The representation of NaN values has all exponent bits (52..62) set,
     // and not all mantissa bits (0..51) clear.
     // Read top bits of double representation (second word of value).
-    __ lwu(a6, FieldMemOperand(a0, HeapNumber::kExponentOffset));
+    __ Lwu(a6, FieldMemOperand(a0, HeapNumber::kExponentOffset));
     // Test that exponent bits are all set.
     __ And(a7, a6, Operand(exp_mask_reg));
     // If all bits not set (ne cond), then not a NaN, objects are equal.
     __ Branch(&return_equal, ne, a7, Operand(exp_mask_reg));
 
     // Shift out flag and all exponent bits, retaining only mantissa.
     __ sll(a6, a6, HeapNumber::kNonMantissaBitsInTopWord);
     // Or with all low-bits of mantissa.
-    __ lwu(a7, FieldMemOperand(a0, HeapNumber::kMantissaOffset));
+    __ Lwu(a7, FieldMemOperand(a0, HeapNumber::kMantissaOffset));
     __ Or(v0, a7, Operand(a6));
     // For equal we already have the right value in v0:  Return zero (equal)
     // if all bits in mantissa are zero (it's an Infinity) and non-zero if
     // not (it's a NaN).  For <= and >= we need to load v0 with the failing
     // value if it's a NaN.
     if (cc != eq) {
       // All-zero means Infinity means equal.
       __ Ret(eq, v0, Operand(zero_reg));
       DCHECK(is_int16(GREATER) && is_int16(LESS));
       __ Ret(USE_DELAY_SLOT);
@@ skipping 32 matching lines @@
   } else {
     // Smi compared non-strictly with a non-Smi non-heap-number. Call
     // the runtime.
     __ Branch(slow, ne, t0, Operand(HEAP_NUMBER_TYPE));
   }
   // Rhs is a smi, lhs is a number.
   // Convert smi rhs to double.
   __ SmiUntag(at, rhs);
   __ mtc1(at, f14);
   __ cvt_d_w(f14, f14);
-  __ ldc1(f12, FieldMemOperand(lhs, HeapNumber::kValueOffset));
+  __ Ldc1(f12, FieldMemOperand(lhs, HeapNumber::kValueOffset));
 
   // We now have both loaded as doubles.
   __ jmp(both_loaded_as_doubles);
 
   __ bind(&lhs_is_smi);
   // Lhs is a Smi.  Check whether the non-smi is a heap number.
   __ GetObjectType(rhs, t0, t0);
   if (strict) {
     // If lhs was not a number and rhs was a Smi then strict equality cannot
     // succeed. Return non-equal.
     __ Ret(USE_DELAY_SLOT, ne, t0, Operand(HEAP_NUMBER_TYPE));
     __ li(v0, Operand(1));
   } else {
     // Smi compared non-strictly with a non-Smi non-heap-number. Call
     // the runtime.
     __ Branch(slow, ne, t0, Operand(HEAP_NUMBER_TYPE));
   }
 
   // Lhs is a smi, rhs is a number.
   // Convert smi lhs to double.
   __ SmiUntag(at, lhs);
   __ mtc1(at, f12);
   __ cvt_d_w(f12, f12);
-  __ ldc1(f14, FieldMemOperand(rhs, HeapNumber::kValueOffset));
+  __ Ldc1(f14, FieldMemOperand(rhs, HeapNumber::kValueOffset));
   // Fall through to both_loaded_as_doubles.
 }
 
 
 static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,
                                            Register lhs,
                                            Register rhs) {
     // If either operand is a JS object or an oddball value, then they are
     // not equal since their pointers are different.
     // There is no test for undetectability in strict equality.
@@ skipping 30 matching lines @@
 
 
 static void EmitCheckForTwoHeapNumbers(MacroAssembler* masm,
                                        Register lhs,
                                        Register rhs,
                                        Label* both_loaded_as_doubles,
                                        Label* not_heap_numbers,
                                        Label* slow) {
   __ GetObjectType(lhs, a3, a2);
   __ Branch(not_heap_numbers, ne, a2, Operand(HEAP_NUMBER_TYPE));
-  __ ld(a2, FieldMemOperand(rhs, HeapObject::kMapOffset));
+  __ Ld(a2, FieldMemOperand(rhs, HeapObject::kMapOffset));
   // If first was a heap number & second wasn't, go to slow case.
   __ Branch(slow, ne, a3, Operand(a2));
 
   // Both are heap numbers. Load them up then jump to the code we have
   // for that.
-  __ ldc1(f12, FieldMemOperand(lhs, HeapNumber::kValueOffset));
-  __ ldc1(f14, FieldMemOperand(rhs, HeapNumber::kValueOffset));
+  __ Ldc1(f12, FieldMemOperand(lhs, HeapNumber::kValueOffset));
+  __ Ldc1(f14, FieldMemOperand(rhs, HeapNumber::kValueOffset));
 
   __ jmp(both_loaded_as_doubles);
 }
 
 
 // Fast negative check for internalized-to-internalized equality.
 static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,
                                                      Register lhs, Register rhs,
                                                      Label* possible_strings,
                                                      Label* runtime_call) {
@@ skipping 12 matching lines @@
   __ And(at, a3, Operand(kIsNotInternalizedMask));
   __ Branch(possible_strings, ne, at, Operand(zero_reg));
 
   // Both are internalized. We already checked they weren't the same pointer so
   // they are not equal. Return non-equal by returning the non-zero object
   // pointer in v0.
   __ Ret(USE_DELAY_SLOT);
   __ mov(v0, a0);  // In delay slot.
 
   __ bind(&object_test);
-  __ ld(a2, FieldMemOperand(lhs, HeapObject::kMapOffset));
-  __ ld(a3, FieldMemOperand(rhs, HeapObject::kMapOffset));
-  __ lbu(t0, FieldMemOperand(a2, Map::kBitFieldOffset));
-  __ lbu(t1, FieldMemOperand(a3, Map::kBitFieldOffset));
+  __ Ld(a2, FieldMemOperand(lhs, HeapObject::kMapOffset));
+  __ Ld(a3, FieldMemOperand(rhs, HeapObject::kMapOffset));
+  __ Lbu(t0, FieldMemOperand(a2, Map::kBitFieldOffset));
+  __ Lbu(t1, FieldMemOperand(a3, Map::kBitFieldOffset));
   __ And(at, t0, Operand(1 << Map::kIsUndetectable));
   __ Branch(&undetectable, ne, at, Operand(zero_reg));
   __ And(at, t1, Operand(1 << Map::kIsUndetectable));
   __ Branch(&return_unequal, ne, at, Operand(zero_reg));
 
   __ GetInstanceType(a2, a2);
   __ Branch(runtime_call, lt, a2, Operand(FIRST_JS_RECEIVER_TYPE));
   __ GetInstanceType(a3, a3);
   __ Branch(runtime_call, lt, a3, Operand(FIRST_JS_RECEIVER_TYPE));
 
@@ skipping 278 matching lines @@
   const DoubleRegister double_scratch = f6;
   const FPURegister single_scratch = f8;
   const Register scratch = t1;
   const Register scratch2 = a7;
 
   Label call_runtime, done, int_exponent;
   if (exponent_type() == TAGGED) {
     // Base is already in double_base.
     __ UntagAndJumpIfSmi(scratch, exponent, &int_exponent);
 
-    __ ldc1(double_exponent,
+    __ Ldc1(double_exponent,
             FieldMemOperand(exponent, HeapNumber::kValueOffset));
   }
 
   if (exponent_type() != INTEGER) {
     Label int_exponent_convert;
     // Detect integer exponents stored as double.
     __ EmitFPUTruncate(kRoundToMinusInf,
                        scratch,
                        double_exponent,
                        at,
@@ skipping 215 matching lines @@
       __ addiupc(ra, kNumInstructionsToJump + 1);
     } else {
       // This branch-and-link sequence is needed to find the current PC on mips
       // before r6, saved to the ra register.
       __ bal(&find_ra);  // bal exposes branch delay slot.
       __ Daddu(ra, ra, kNumInstructionsToJump * Instruction::kInstrSize);
     }
     __ bind(&find_ra);
 
     // This spot was reserved in EnterExitFrame.
-    __ sd(ra, MemOperand(sp, result_stack_size));
+    __ Sd(ra, MemOperand(sp, result_stack_size));
     // Stack space reservation moved to the branch delay slot below.
     // Stack is still aligned.
 
     // Call the C routine.
     __ mov(t9, s2);  // Function pointer to t9 to conform to ABI for PIC.
     __ jalr(t9);
     // Set up sp in the delay slot.
     __ daddiu(sp, sp, -kCArgsSlotsSize);
     // Make sure the stored 'ra' points to this position.
     DCHECK_EQ(kNumInstructionsToJump,
               masm->InstructionsGeneratedSince(&find_ra));
   }
   if (result_size() > 2) {
     DCHECK_EQ(3, result_size());
     // Read result values stored on stack.
-    __ ld(a0, MemOperand(v0, 2 * kPointerSize));
-    __ ld(v1, MemOperand(v0, 1 * kPointerSize));
-    __ ld(v0, MemOperand(v0, 0 * kPointerSize));
+    __ Ld(a0, MemOperand(v0, 2 * kPointerSize));
+    __ Ld(v1, MemOperand(v0, 1 * kPointerSize));
+    __ Ld(v0, MemOperand(v0, 0 * kPointerSize));
   }
   // Result returned in v0, v1:v0 or a0:v1:v0 - do not destroy these registers!
 
   // Check result for exception sentinel.
   Label exception_returned;
   __ LoadRoot(a4, Heap::kExceptionRootIndex);
   __ Branch(&exception_returned, eq, a4, Operand(v0));
 
   // Check that there is no pending exception, otherwise we
   // should have returned the exception sentinel.
   if (FLAG_debug_code) {
     Label okay;
     ExternalReference pending_exception_address(
         Isolate::kPendingExceptionAddress, isolate());
     __ li(a2, Operand(pending_exception_address));
-    __ ld(a2, MemOperand(a2));
+    __ Ld(a2, MemOperand(a2));
     __ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
     // Cannot use check here as it attempts to generate call into runtime.
     __ Branch(&okay, eq, a4, Operand(a2));
     __ stop("Unexpected pending exception");
     __ bind(&okay);
   }
 
   // Exit C frame and return.
   // v0:v1: result
   // sp: stack pointer
@@ skipping 30 matching lines @@
     FrameScope scope(masm, StackFrame::MANUAL);
     __ PrepareCallCFunction(3, 0, a0);
     __ mov(a0, zero_reg);
     __ mov(a1, zero_reg);
     __ li(a2, Operand(ExternalReference::isolate_address(isolate())));
     __ CallCFunction(find_handler, 3);
   }
 
   // Retrieve the handler context, SP and FP.
   __ li(cp, Operand(pending_handler_context_address));
-  __ ld(cp, MemOperand(cp));
+  __ Ld(cp, MemOperand(cp));
   __ li(sp, Operand(pending_handler_sp_address));
-  __ ld(sp, MemOperand(sp));
+  __ Ld(sp, MemOperand(sp));
   __ li(fp, Operand(pending_handler_fp_address));
-  __ ld(fp, MemOperand(fp));
+  __ Ld(fp, MemOperand(fp));
 
   // If the handler is a JS frame, restore the context to the frame. Note that
   // the context will be set to (cp == 0) for non-JS frames.
   Label zero;
   __ Branch(&zero, eq, cp, Operand(zero_reg));
-  __ sd(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  __ Sd(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   __ bind(&zero);
 
   // Compute the handler entry address and jump to it.
   __ li(a1, Operand(pending_handler_code_address));
-  __ ld(a1, MemOperand(a1));
+  __ Ld(a1, MemOperand(a1));
   __ li(a2, Operand(pending_handler_offset_address));
-  __ ld(a2, MemOperand(a2));
+  __ Ld(a2, MemOperand(a2));
   __ Daddu(a1, a1, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Daddu(t9, a1, a2);
   __ Jump(t9);
 }
 
 
 void JSEntryStub::Generate(MacroAssembler* masm) {
   Label invoke, handler_entry, exit;
   Isolate* isolate = masm->isolate();
 
@@ skipping 24 matching lines @@
 
   __ InitializeRootRegister();
 
   // We build an EntryFrame.
   __ li(a7, Operand(-1));  // Push a bad frame pointer to fail if it is used.
   StackFrame::Type marker = type();
   __ li(a6, Operand(StackFrame::TypeToMarker(marker)));
   __ li(a5, Operand(StackFrame::TypeToMarker(marker)));
   ExternalReference c_entry_fp(Isolate::kCEntryFPAddress, isolate);
   __ li(a4, Operand(c_entry_fp));
-  __ ld(a4, MemOperand(a4));
+  __ Ld(a4, MemOperand(a4));
   __ Push(a7, a6, a5, a4);
   // Set up frame pointer for the frame to be pushed.
   __ daddiu(fp, sp, -EntryFrameConstants::kCallerFPOffset);
 
   // Registers:
   // a0: entry_address
   // a1: function
   // a2: receiver_pointer
   // a3: argc
   // s0: argv
   //
   // Stack:
   // caller fp          |
   // function slot      | entry frame
   // context slot       |
   // bad fp (0xff...f)  |
   // callee saved registers + ra
   // [ O32: 4 args slots]
   // args
 
   // If this is the outermost JS call, set js_entry_sp value.
   Label non_outermost_js;
   ExternalReference js_entry_sp(Isolate::kJSEntrySPAddress, isolate);
   __ li(a5, Operand(ExternalReference(js_entry_sp)));
-  __ ld(a6, MemOperand(a5));
+  __ Ld(a6, MemOperand(a5));
   __ Branch(&non_outermost_js, ne, a6, Operand(zero_reg));
-  __ sd(fp, MemOperand(a5));
+  __ Sd(fp, MemOperand(a5));
   __ li(a4, Operand(StackFrame::OUTERMOST_JSENTRY_FRAME));
   Label cont;
   __ b(&cont);
   __ nop();   // Branch delay slot nop.
   __ bind(&non_outermost_js);
   __ li(a4, Operand(StackFrame::INNER_JSENTRY_FRAME));
   __ bind(&cont);
   __ push(a4);
 
   // Jump to a faked try block that does the invoke, with a faked catch
   // block that sets the pending exception.
   __ jmp(&invoke);
   __ bind(&handler_entry);
   handler_offset_ = handler_entry.pos();
   // Caught exception: Store result (exception) in the pending exception
   // field in the JSEnv and return a failure sentinel.  Coming in here the
   // fp will be invalid because the PushStackHandler below sets it to 0 to
   // signal the existence of the JSEntry frame.
   __ li(a4, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
                                       isolate)));
-  __ sd(v0, MemOperand(a4));  // We come back from 'invoke'. result is in v0.
+  __ Sd(v0, MemOperand(a4));  // We come back from 'invoke'. result is in v0.
   __ LoadRoot(v0, Heap::kExceptionRootIndex);
   __ b(&exit);  // b exposes branch delay slot.
   __ nop();   // Branch delay slot nop.
 
   // Invoke: Link this frame into the handler chain.
   __ bind(&invoke);
   __ PushStackHandler();
   // If an exception not caught by another handler occurs, this handler
   // returns control to the code after the bal(&invoke) above, which
   // restores all kCalleeSaved registers (including cp and fp) to their
@@ skipping 18 matching lines @@
   // args
 
   if (type() == StackFrame::ENTRY_CONSTRUCT) {
     ExternalReference construct_entry(Builtins::kJSConstructEntryTrampoline,
                                       isolate);
     __ li(a4, Operand(construct_entry));
   } else {
     ExternalReference entry(Builtins::kJSEntryTrampoline, masm->isolate());
     __ li(a4, Operand(entry));
   }
-  __ ld(t9, MemOperand(a4));  // Deref address.
+  __ Ld(t9, MemOperand(a4));  // Deref address.
   // Call JSEntryTrampoline.
   __ daddiu(t9, t9, Code::kHeaderSize - kHeapObjectTag);
   __ Call(t9);
 
   // Unlink this frame from the handler chain.
   __ PopStackHandler();
 
   __ bind(&exit);  // v0 holds result
   // Check if the current stack frame is marked as the outermost JS frame.
   Label non_outermost_js_2;
   __ pop(a5);
   __ Branch(&non_outermost_js_2, ne, a5,
             Operand(StackFrame::OUTERMOST_JSENTRY_FRAME));
   __ li(a5, Operand(ExternalReference(js_entry_sp)));
-  __ sd(zero_reg, MemOperand(a5));
+  __ Sd(zero_reg, MemOperand(a5));
   __ bind(&non_outermost_js_2);
 
   // Restore the top frame descriptors from the stack.
   __ pop(a5);
   __ li(a4, Operand(ExternalReference(Isolate::kCEntryFPAddress,
                                       isolate)));
-  __ sd(a5, MemOperand(a4));
+  __ Sd(a5, MemOperand(a4));
 
   // Reset the stack to the callee saved registers.
   __ daddiu(sp, sp, -EntryFrameConstants::kCallerFPOffset);
 
   // Restore callee-saved fpu registers.
   __ MultiPopFPU(kCalleeSavedFPU);
 
   // Restore callee saved registers from the stack.
   __ MultiPop(kCalleeSaved | ra.bit());
   // Return.
@@ skipping 23 matching lines @@
   // Abi O32:
   //   [sp + 5] - Argument 9
   //   [sp + 4] - Argument 8
   //   [sp + 3] - Argument 7
   //   [sp + 2] - Argument 6
   //   [sp + 1] - Argument 5
   //   [sp + 0] - saved ra
 
   // Argument 9: Pass current isolate address.
   __ li(t1, Operand(ExternalReference::isolate_address(isolate())));
-  __ sd(t1, MemOperand(sp, 1 * kPointerSize));
+  __ Sd(t1, MemOperand(sp, 1 * kPointerSize));
 
   // Argument 8: Indicate that this is a direct call from JavaScript.
   __ li(a7, Operand(1));
 
   // Argument 7: Start (high end) of backtracking stack memory area.
   ExternalReference address_of_regexp_stack_memory_address =
       ExternalReference::address_of_regexp_stack_memory_address(isolate());
   ExternalReference address_of_regexp_stack_memory_size =
       ExternalReference::address_of_regexp_stack_memory_size(isolate());
   __ li(t1, Operand(address_of_regexp_stack_memory_address));
-  __ ld(t1, MemOperand(t1, 0));
+  __ Ld(t1, MemOperand(t1, 0));
   __ li(t2, Operand(address_of_regexp_stack_memory_size));
-  __ ld(t2, MemOperand(t2, 0));
+  __ Ld(t2, MemOperand(t2, 0));
   __ daddu(a6, t1, t2);
 
   // Argument 6: Set the number of capture registers to zero to force global
   // regexps to behave as non-global. This does not affect non-global regexps.
   __ mov(a5, zero_reg);
 
   // Argument 5: static offsets vector buffer.
   __ li(
       a4,
       Operand(ExternalReference::address_of_static_offsets_vector(isolate())));
@@ skipping 58 matching lines @@
   Label initialize, done, miss, megamorphic, not_array_function;
 
   DCHECK_EQ(*FeedbackVector::MegamorphicSentinel(masm->isolate()),
             masm->isolate()->heap()->megamorphic_symbol());
   DCHECK_EQ(*FeedbackVector::UninitializedSentinel(masm->isolate()),
             masm->isolate()->heap()->uninitialized_symbol());
 
   // Load the cache state into a5.
   __ dsrl(a5, a3, 32 - kPointerSizeLog2);
   __ Daddu(a5, a2, Operand(a5));
-  __ ld(a5, FieldMemOperand(a5, FixedArray::kHeaderSize));
+  __ Ld(a5, FieldMemOperand(a5, FixedArray::kHeaderSize));
 
   // A monomorphic cache hit or an already megamorphic state: invoke the
   // function without changing the state.
   // We don't know if a5 is a WeakCell or a Symbol, but it's harmless to read at
   // this position in a symbol (see static asserts in feedback-vector.h).
   Label check_allocation_site;
   Register feedback_map = a6;
   Register weak_value = t0;
-  __ ld(weak_value, FieldMemOperand(a5, WeakCell::kValueOffset));
+  __ Ld(weak_value, FieldMemOperand(a5, WeakCell::kValueOffset));
   __ Branch(&done, eq, a1, Operand(weak_value));
   __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
   __ Branch(&done, eq, a5, Operand(at));
-  __ ld(feedback_map, FieldMemOperand(a5, HeapObject::kMapOffset));
+  __ Ld(feedback_map, FieldMemOperand(a5, HeapObject::kMapOffset));
   __ LoadRoot(at, Heap::kWeakCellMapRootIndex);
   __ Branch(&check_allocation_site, ne, feedback_map, Operand(at));
 
   // If the weak cell is cleared, we have a new chance to become monomorphic.
   __ JumpIfSmi(weak_value, &initialize);
   __ jmp(&megamorphic);
 
   __ bind(&check_allocation_site);
   // If we came here, we need to see if we are the array function.
   // If we didn't have a matching function, and we didn't find the megamorph
@@ skipping 12 matching lines @@
   // A monomorphic miss (i.e, here the cache is not uninitialized) goes
   // megamorphic.
   __ LoadRoot(at, Heap::kuninitialized_symbolRootIndex);
   __ Branch(&initialize, eq, a5, Operand(at));
   // MegamorphicSentinel is an immortal immovable object (undefined) so no
   // write-barrier is needed.
   __ bind(&megamorphic);
   __ dsrl(a5, a3, 32 - kPointerSizeLog2);
   __ Daddu(a5, a2, Operand(a5));
   __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
-  __ sd(at, FieldMemOperand(a5, FixedArray::kHeaderSize));
+  __ Sd(at, FieldMemOperand(a5, FixedArray::kHeaderSize));
   __ jmp(&done);
 
   // An uninitialized cache is patched with the function.
   __ bind(&initialize);
   // Make sure the function is the Array() function.
   __ LoadNativeContextSlot(Context::ARRAY_FUNCTION_INDEX, a5);
   __ Branch(&not_array_function, ne, a1, Operand(a5));
 
   // The target function is the Array constructor,
   // Create an AllocationSite if we don't already have it, store it in the
   // slot.
   CreateAllocationSiteStub create_stub(masm->isolate());
   CallStubInRecordCallTarget(masm, &create_stub);
   __ Branch(&done);
 
   __ bind(&not_array_function);
 
   CreateWeakCellStub weak_cell_stub(masm->isolate());
   CallStubInRecordCallTarget(masm, &weak_cell_stub);
 
   __ bind(&done);
 
   // Increment the call count for all function calls.
   __ SmiScale(a4, a3, kPointerSizeLog2);
   __ Daddu(a5, a2, Operand(a4));
-  __ ld(a4, FieldMemOperand(a5, FixedArray::kHeaderSize + kPointerSize));
+  __ Ld(a4, FieldMemOperand(a5, FixedArray::kHeaderSize + kPointerSize));
   __ Daddu(a4, a4, Operand(Smi::FromInt(1)));
-  __ sd(a4, FieldMemOperand(a5, FixedArray::kHeaderSize + kPointerSize));
+  __ Sd(a4, FieldMemOperand(a5, FixedArray::kHeaderSize + kPointerSize));
 }
 
 
 void CallConstructStub::Generate(MacroAssembler* masm) {
   // a0 : number of arguments
   // a1 : the function to call
   // a2 : feedback vector
   // a3 : slot in feedback vector (Smi, for RecordCallTarget)
 
   Label non_function;
   // Check that the function is not a smi.
   __ JumpIfSmi(a1, &non_function);
   // Check that the function is a JSFunction.
   __ GetObjectType(a1, a5, a5);
   __ Branch(&non_function, ne, a5, Operand(JS_FUNCTION_TYPE));
 
   GenerateRecordCallTarget(masm);
 
   __ dsrl(at, a3, 32 - kPointerSizeLog2);
   __ Daddu(a5, a2, at);
   Label feedback_register_initialized;
   // Put the AllocationSite from the feedback vector into a2, or undefined.
-  __ ld(a2, FieldMemOperand(a5, FixedArray::kHeaderSize));
-  __ ld(a5, FieldMemOperand(a2, AllocationSite::kMapOffset));
+  __ Ld(a2, FieldMemOperand(a5, FixedArray::kHeaderSize));
+  __ Ld(a5, FieldMemOperand(a2, AllocationSite::kMapOffset));
   __ LoadRoot(at, Heap::kAllocationSiteMapRootIndex);
   __ Branch(&feedback_register_initialized, eq, a5, Operand(at));
   __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
   __ bind(&feedback_register_initialized);
 
   __ AssertUndefinedOrAllocationSite(a2, a5);
 
   // Pass function as new target.
   __ mov(a3, a1);
 
   // Tail call to the function-specific construct stub (still in the caller
   // context at this point).
-  __ ld(a4, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
-  __ ld(a4, FieldMemOperand(a4, SharedFunctionInfo::kConstructStubOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(a4, FieldMemOperand(a4, SharedFunctionInfo::kConstructStubOffset));
   __ Daddu(at, a4, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Jump(at);
 
   __ bind(&non_function);
   __ mov(a3, a1);
   __ Jump(isolate()->builtins()->Construct(), RelocInfo::CODE_TARGET);
 }
 
 
 // StringCharCodeAtGenerator.
 void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
   DCHECK(!a4.is(index_));
   DCHECK(!a4.is(result_));
   DCHECK(!a4.is(object_));
 
   // If the receiver is a smi trigger the non-string case.
   if (check_mode_ == RECEIVER_IS_UNKNOWN) {
     __ JumpIfSmi(object_, receiver_not_string_);
 
     // Fetch the instance type of the receiver into result register.
-    __ ld(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
-    __ lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+    __ Ld(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+    __ Lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
     // If the receiver is not a string trigger the non-string case.
     __ And(a4, result_, Operand(kIsNotStringMask));
     __ Branch(receiver_not_string_, ne, a4, Operand(zero_reg));
   }
 
   // If the index is non-smi trigger the non-smi case.
   __ JumpIfNotSmi(index_, &index_not_smi_);
 
   __ bind(&got_smi_index_);
 
   // Check for index out of range.
-  __ ld(a4, FieldMemOperand(object_, String::kLengthOffset));
+  __ Ld(a4, FieldMemOperand(object_, String::kLengthOffset));
   __ Branch(index_out_of_range_, ls, a4, Operand(index_));
 
   __ SmiUntag(index_);
 
   StringCharLoadGenerator::Generate(masm,
                                     object_,
                                     index_,
                                     result_,
                                     &call_runtime_);
 
@@ skipping 28 matching lines @@
   // have a chance to overwrite it.
 
   __ Move(index_, v0);
   if (embed_mode == PART_OF_IC_HANDLER) {
     __ Pop(LoadWithVectorDescriptor::VectorRegister(),
            LoadWithVectorDescriptor::SlotRegister(), object_);
   } else {
     __ pop(object_);
   }
   // Reload the instance type.
-  __ ld(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
-  __ lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+  __ Ld(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+  __ Lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
   call_helper.AfterCall(masm);
   // If index is still not a smi, it must be out of range.
   __ JumpIfNotSmi(index_, index_out_of_range_);
   // Otherwise, return to the fast path.
   __ Branch(&got_smi_index_);
 
   // Call runtime. We get here when the receiver is a string and the
   // index is a number, but the code of getting the actual character
   // is too complex (e.g., when the string needs to be flattened).
   __ bind(&call_runtime_);
@@ skipping 10 matching lines @@
   __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 void StringHelper::GenerateFlatOneByteStringEquals(
     MacroAssembler* masm, Register left, Register right, Register scratch1,
     Register scratch2, Register scratch3) {
   Register length = scratch1;
 
   // Compare lengths.
   Label strings_not_equal, check_zero_length;
-  __ ld(length, FieldMemOperand(left, String::kLengthOffset));
-  __ ld(scratch2, FieldMemOperand(right, String::kLengthOffset));
+  __ Ld(length, FieldMemOperand(left, String::kLengthOffset));
+  __ Ld(scratch2, FieldMemOperand(right, String::kLengthOffset));
   __ Branch(&check_zero_length, eq, length, Operand(scratch2));
   __ bind(&strings_not_equal);
   // Can not put li in delayslot, it has multi instructions.
   __ li(v0, Operand(Smi::FromInt(NOT_EQUAL)));
   __ Ret();
 
   // Check if the length is zero.
   Label compare_chars;
   __ bind(&check_zero_length);
   STATIC_ASSERT(kSmiTag == 0);
@@ skipping 12 matching lines @@
   __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(Smi::FromInt(EQUAL)));
 }
 
 
 void StringHelper::GenerateCompareFlatOneByteStrings(
     MacroAssembler* masm, Register left, Register right, Register scratch1,
     Register scratch2, Register scratch3, Register scratch4) {
   Label result_not_equal, compare_lengths;
   // Find minimum length and length difference.
-  __ ld(scratch1, FieldMemOperand(left, String::kLengthOffset));
-  __ ld(scratch2, FieldMemOperand(right, String::kLengthOffset));
+  __ Ld(scratch1, FieldMemOperand(left, String::kLengthOffset));
+  __ Ld(scratch2, FieldMemOperand(right, String::kLengthOffset));
   __ Dsubu(scratch3, scratch1, Operand(scratch2));
   Register length_delta = scratch3;
   __ slt(scratch4, scratch2, scratch1);
   __ Movn(scratch1, scratch2, scratch4);
   Register min_length = scratch1;
   STATIC_ASSERT(kSmiTag == 0);
   __ Branch(&compare_lengths, eq, min_length, Operand(zero_reg));
 
   // Compare loop.
   GenerateOneByteCharsCompareLoop(masm, left, right, min_length, scratch2,
@@ skipping 33 matching lines @@
   __ Daddu(left, left, Operand(scratch1));
   __ Daddu(right, right, Operand(scratch1));
   __ Dsubu(length, zero_reg, length);
   Register index = length;  // index = -length;
 
 
   // Compare loop.
   Label loop;
   __ bind(&loop);
   __ Daddu(scratch3, left, index);
-  __ lbu(scratch1, MemOperand(scratch3));
+  __ Lbu(scratch1, MemOperand(scratch3));
   __ Daddu(scratch3, right, index);
-  __ lbu(scratch2, MemOperand(scratch3));
+  __ Lbu(scratch2, MemOperand(scratch3));
   __ Branch(chars_not_equal, ne, scratch1, Operand(scratch2));
   __ Daddu(index, index, 1);
   __ Branch(&loop, ne, index, Operand(zero_reg));
 }
 
 
 void BinaryOpICWithAllocationSiteStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a1    : left
   //  -- a0    : right
   //  -- ra    : return address
   // -----------------------------------
 
   // Load a2 with the allocation site. We stick an undefined dummy value here
   // and replace it with the real allocation site later when we instantiate this
   // stub in BinaryOpICWithAllocationSiteStub::GetCodeCopyFromTemplate().
   __ li(a2, isolate()->factory()->undefined_value());
 
   // Make sure that we actually patched the allocation site.
   if (FLAG_debug_code) {
     __ And(at, a2, Operand(kSmiTagMask));
     __ Assert(ne, kExpectedAllocationSite, at, Operand(zero_reg));
-    __ ld(a4, FieldMemOperand(a2, HeapObject::kMapOffset));
+    __ Ld(a4, FieldMemOperand(a2, HeapObject::kMapOffset));
     __ LoadRoot(at, Heap::kAllocationSiteMapRootIndex);
     __ Assert(eq, kExpectedAllocationSite, a4, Operand(at));
   }
 
   // Tail call into the stub that handles binary operations with allocation
   // sites.
   BinaryOpWithAllocationSiteStub stub(isolate(), state());
   __ TailCallStub(&stub);
 }
 
 
 void CompareICStub::GenerateBooleans(MacroAssembler* masm) {
   DCHECK_EQ(CompareICState::BOOLEAN, state());
   Label miss;
 
   __ CheckMap(a1, a2, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
   __ CheckMap(a0, a3, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
   if (!Token::IsEqualityOp(op())) {
-    __ ld(a1, FieldMemOperand(a1, Oddball::kToNumberOffset));
+    __ Ld(a1, FieldMemOperand(a1, Oddball::kToNumberOffset));
     __ AssertSmi(a1);
-    __ ld(a0, FieldMemOperand(a0, Oddball::kToNumberOffset));
+    __ Ld(a0, FieldMemOperand(a0, Oddball::kToNumberOffset));
     __ AssertSmi(a0);
   }
   __ Ret(USE_DELAY_SLOT);
   __ Dsubu(v0, a1, a0);
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 
@@ skipping 35 matching lines @@
   }
 
   // Inlining the double comparison and falling back to the general compare
   // stub if NaN is involved.
   // Load left and right operand.
   Label done, left, left_smi, right_smi;
   __ JumpIfSmi(a0, &right_smi);
   __ CheckMap(a0, a2, Heap::kHeapNumberMapRootIndex, &maybe_undefined1,
               DONT_DO_SMI_CHECK);
   __ Dsubu(a2, a0, Operand(kHeapObjectTag));
-  __ ldc1(f2, MemOperand(a2, HeapNumber::kValueOffset));
+  __ Ldc1(f2, MemOperand(a2, HeapNumber::kValueOffset));
   __ Branch(&left);
   __ bind(&right_smi);
   __ SmiUntag(a2, a0);  // Can't clobber a0 yet.
   FPURegister single_scratch = f6;
   __ mtc1(a2, single_scratch);
   __ cvt_d_w(f2, single_scratch);
 
   __ bind(&left);
   __ JumpIfSmi(a1, &left_smi);
   __ CheckMap(a1, a2, Heap::kHeapNumberMapRootIndex, &maybe_undefined2,
               DONT_DO_SMI_CHECK);
   __ Dsubu(a2, a1, Operand(kHeapObjectTag));
-  __ ldc1(f0, MemOperand(a2, HeapNumber::kValueOffset));
+  __ Ldc1(f0, MemOperand(a2, HeapNumber::kValueOffset));
   __ Branch(&done);
   __ bind(&left_smi);
   __ SmiUntag(a2, a1);  // Can't clobber a1 yet.
   single_scratch = f8;
   __ mtc1(a2, single_scratch);
   __ cvt_d_w(f0, single_scratch);
 
   __ bind(&done);
 
   // Return a result of -1, 0, or 1, or use CompareStub for NaNs.
@@ skipping 51 matching lines @@
   // Registers containing left and right operands respectively.
   Register left = a1;
   Register right = a0;
   Register tmp1 = a2;
   Register tmp2 = a3;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(left, right, &miss);
 
   // Check that both operands are internalized strings.
-  __ ld(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
-  __ ld(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
-  __ lbu(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
-  __ lbu(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
+  __ Ld(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
+  __ Ld(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
+  __ Lbu(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
+  __ Lbu(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
   STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
   __ Or(tmp1, tmp1, Operand(tmp2));
   __ And(at, tmp1, Operand(kIsNotStringMask | kIsNotInternalizedMask));
   __ Branch(&miss, ne, at, Operand(zero_reg));
 
   // Make sure a0 is non-zero. At this point input operands are
   // guaranteed to be non-zero.
   DCHECK(right.is(a0));
   STATIC_ASSERT(EQUAL == 0);
   STATIC_ASSERT(kSmiTag == 0);
@@ skipping 18 matching lines @@
   Register left = a1;
   Register right = a0;
   Register tmp1 = a2;
   Register tmp2 = a3;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(left, right, &miss);
 
   // Check that both operands are unique names. This leaves the instance
   // types loaded in tmp1 and tmp2.
-  __ ld(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
-  __ ld(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
-  __ lbu(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
-  __ lbu(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
+  __ Ld(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
+  __ Ld(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
+  __ Lbu(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
+  __ Lbu(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
 
   __ JumpIfNotUniqueNameInstanceType(tmp1, &miss);
   __ JumpIfNotUniqueNameInstanceType(tmp2, &miss);
 
   // Use a0 as result
   __ mov(v0, a0);
 
   // Unique names are compared by identity.
   Label done;
   __ Branch(&done, ne, left, Operand(right));
@@ skipping 24 matching lines @@
   Register tmp2 = a3;
   Register tmp3 = a4;
   Register tmp4 = a5;
   Register tmp5 = a6;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(left, right, &miss);
 
   // Check that both operands are strings. This leaves the instance
   // types loaded in tmp1 and tmp2.
-  __ ld(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
-  __ ld(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
-  __ lbu(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
-  __ lbu(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
+  __ Ld(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
+  __ Ld(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
+  __ Lbu(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
+  __ Lbu(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
   STATIC_ASSERT(kNotStringTag != 0);
   __ Or(tmp3, tmp1, tmp2);
   __ And(tmp5, tmp3, Operand(kIsNotStringMask));
   __ Branch(&miss, ne, tmp5, Operand(zero_reg));
 
   // Fast check for identical strings.
   Label left_ne_right;
   STATIC_ASSERT(EQUAL == 0);
   STATIC_ASSERT(kSmiTag == 0);
   __ Branch(&left_ne_right, ne, left, Operand(right));
@@ skipping 76 matching lines @@
   GenerateMiss(masm);
 }
 
 
 void CompareICStub::GenerateKnownReceivers(MacroAssembler* masm) {
   Label miss;
   Handle<WeakCell> cell = Map::WeakCellForMap(known_map_);
   __ And(a2, a1, a0);
   __ JumpIfSmi(a2, &miss);
   __ GetWeakValue(a4, cell);
-  __ ld(a2, FieldMemOperand(a0, HeapObject::kMapOffset));
-  __ ld(a3, FieldMemOperand(a1, HeapObject::kMapOffset));
+  __ Ld(a2, FieldMemOperand(a0, HeapObject::kMapOffset));
+  __ Ld(a3, FieldMemOperand(a1, HeapObject::kMapOffset));
   __ Branch(&miss, ne, a2, Operand(a4));
   __ Branch(&miss, ne, a3, Operand(a4));
 
   if (Token::IsEqualityOp(op())) {
     __ Ret(USE_DELAY_SLOT);
     __ dsubu(v0, a0, a1);
   } else {
     if (op() == Token::LT || op() == Token::LTE) {
       __ li(a2, Operand(Smi::FromInt(GREATER)));
     } else {
@@ skipping 11 matching lines @@
 void CompareICStub::GenerateMiss(MacroAssembler* masm) {
   {
     // Call the runtime system in a fresh internal frame.
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(a1, a0);
     __ Push(ra, a1, a0);
     __ li(a4, Operand(Smi::FromInt(op())));
     __ daddiu(sp, sp, -kPointerSize);
     __ CallRuntime(Runtime::kCompareIC_Miss, 3, kDontSaveFPRegs,
                    USE_DELAY_SLOT);
-    __ sd(a4, MemOperand(sp));  // In the delay slot.
+    __ Sd(a4, MemOperand(sp));  // In the delay slot.
     // Compute the entry point of the rewritten stub.
     __ Daddu(a2, v0, Operand(Code::kHeaderSize - kHeapObjectTag));
     // Restore registers.
     __ Pop(a1, a0, ra);
   }
   __ Jump(a2);
 }
 
 
 void DirectCEntryStub::Generate(MacroAssembler* masm) {
   // Make place for arguments to fit C calling convention. Most of the callers
   // of DirectCEntryStub::GenerateCall are using EnterExitFrame/LeaveExitFrame
   // so they handle stack restoring and we don't have to do that here.
   // Any caller of DirectCEntryStub::GenerateCall must take care of dropping
   // kCArgsSlotsSize stack space after the call.
   __ daddiu(sp, sp, -kCArgsSlotsSize);
   // Place the return address on the stack, making the call
   // GC safe. The RegExp backend also relies on this.
-  __ sd(ra, MemOperand(sp, kCArgsSlotsSize));
+  __ Sd(ra, MemOperand(sp, kCArgsSlotsSize));
   __ Call(t9);  // Call the C++ function.
-  __ ld(t9, MemOperand(sp, kCArgsSlotsSize));
+  __ Ld(t9, MemOperand(sp, kCArgsSlotsSize));
 
   if (FLAG_debug_code && FLAG_enable_slow_asserts) {
     // In case of an error the return address may point to a memory area
     // filled with kZapValue by the GC.
     // Dereference the address and check for this.
     __ Uld(a4, MemOperand(t9));
     __ Assert(ne, kReceivedInvalidReturnAddress, a4,
         Operand(reinterpret_cast<uint64_t>(kZapValue)));
   }
   __ Jump(t9);
@@ skipping 36 matching lines @@
     // Scale the index by multiplying by the entry size.
     STATIC_ASSERT(NameDictionary::kEntrySize == 3);
     __ Dlsa(index, index, index, 1);  // index *= 3.
 
     Register entity_name = scratch0;
     // Having undefined at this place means the name is not contained.
     STATIC_ASSERT(kSmiTagSize == 1);
     Register tmp = properties;
 
     __ Dlsa(tmp, properties, index, kPointerSizeLog2);
-    __ ld(entity_name, FieldMemOperand(tmp, kElementsStartOffset));
+    __ Ld(entity_name, FieldMemOperand(tmp, kElementsStartOffset));
 
     DCHECK(!tmp.is(entity_name));
     __ LoadRoot(tmp, Heap::kUndefinedValueRootIndex);
     __ Branch(done, eq, entity_name, Operand(tmp));
 
     // Load the hole ready for use below:
     __ LoadRoot(tmp, Heap::kTheHoleValueRootIndex);
 
     // Stop if found the property.
     __ Branch(miss, eq, entity_name, Operand(Handle<Name>(name)));
 
     Label good;
     __ Branch(&good, eq, entity_name, Operand(tmp));
 
     // Check if the entry name is not a unique name.
-    __ ld(entity_name, FieldMemOperand(entity_name, HeapObject::kMapOffset));
-    __ lbu(entity_name,
-           FieldMemOperand(entity_name, Map::kInstanceTypeOffset));
+    __ Ld(entity_name, FieldMemOperand(entity_name, HeapObject::kMapOffset));
+    __ Lbu(entity_name, FieldMemOperand(entity_name, Map::kInstanceTypeOffset));
     __ JumpIfNotUniqueNameInstanceType(entity_name, miss);
     __ bind(&good);
 
     // Restore the properties.
-    __ ld(properties,
-          FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+    __ Ld(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
   }
 
   const int spill_mask =
       (ra.bit() | a6.bit() | a5.bit() | a4.bit() | a3.bit() |
        a2.bit() | a1.bit() | a0.bit() | v0.bit());
 
   __ MultiPush(spill_mask);
-  __ ld(a0, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+  __ Ld(a0, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
   __ li(a1, Operand(Handle<Name>(name)));
   NameDictionaryLookupStub stub(masm->isolate(), NEGATIVE_LOOKUP);
   __ CallStub(&stub);
   __ mov(at, v0);
   __ MultiPop(spill_mask);
 
   __ Branch(done, eq, at, Operand(zero_reg));
   __ Branch(miss, ne, at, Operand(zero_reg));
 }
 
@@ skipping 13 matching lines @@
   Register dictionary = a0;
   Register key = a1;
   Register index = a2;
   Register mask = a3;
   Register hash = a4;
   Register undefined = a5;
   Register entry_key = a6;
 
   Label in_dictionary, maybe_in_dictionary, not_in_dictionary;
 
-  __ ld(mask, FieldMemOperand(dictionary, kCapacityOffset));
+  __ Ld(mask, FieldMemOperand(dictionary, kCapacityOffset));
   __ SmiUntag(mask);
   __ Dsubu(mask, mask, Operand(1));
 
-  __ lwu(hash, FieldMemOperand(key, Name::kHashFieldOffset));
+  __ Lwu(hash, FieldMemOperand(key, Name::kHashFieldOffset));
 
   __ LoadRoot(undefined, Heap::kUndefinedValueRootIndex);
 
   for (int i = kInlinedProbes; i < kTotalProbes; i++) {
     // Compute the masked index: (hash + i + i * i) & mask.
     // Capacity is smi 2^n.
     if (i > 0) {
       // Add the probe offset (i + i * i) left shifted to avoid right shifting
       // the hash in a separate instruction. The value hash + i + i * i is right
       // shifted in the following and instruction.
       DCHECK(NameDictionary::GetProbeOffset(i) <
              1 << (32 - Name::kHashFieldOffset));
       __ Daddu(index, hash, Operand(
           NameDictionary::GetProbeOffset(i) << Name::kHashShift));
     } else {
       __ mov(index, hash);
     }
     __ dsrl(index, index, Name::kHashShift);
     __ And(index, mask, index);
 
     // Scale the index by multiplying by the entry size.
     STATIC_ASSERT(NameDictionary::kEntrySize == 3);
     // index *= 3.
     __ Dlsa(index, index, index, 1);
 
     STATIC_ASSERT(kSmiTagSize == 1);
     __ Dlsa(index, dictionary, index, kPointerSizeLog2);
-    __ ld(entry_key, FieldMemOperand(index, kElementsStartOffset));
+    __ Ld(entry_key, FieldMemOperand(index, kElementsStartOffset));
 
     // Having undefined at this place means the name is not contained.
     __ Branch(&not_in_dictionary, eq, entry_key, Operand(undefined));
 
     // Stop if found the property.
     __ Branch(&in_dictionary, eq, entry_key, Operand(key));
 
     if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) {
       // Check if the entry name is not a unique name.
-      __ ld(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset));
-      __ lbu(entry_key,
-             FieldMemOperand(entry_key, Map::kInstanceTypeOffset));
+      __ Ld(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset));
+      __ Lbu(entry_key, FieldMemOperand(entry_key, Map::kInstanceTypeOffset));
       __ JumpIfNotUniqueNameInstanceType(entry_key, &maybe_in_dictionary);
     }
   }
 
   __ bind(&maybe_in_dictionary);
   // If we are doing negative lookup then probing failure should be
   // treated as a lookup success. For positive lookup probing failure
   // should be treated as lookup failure.
   if (mode() == POSITIVE_LOOKUP) {
     __ Ret(USE_DELAY_SLOT);
@@ skipping 61 matching lines @@
   PatchBranchIntoNop(masm, 2 * Assembler::kInstrSize);
 }
 
 
 void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) {
   regs_.Save(masm);
 
   if (remembered_set_action() == EMIT_REMEMBERED_SET) {
     Label dont_need_remembered_set;
 
-    __ ld(regs_.scratch0(), MemOperand(regs_.address(), 0));
+    __ Ld(regs_.scratch0(), MemOperand(regs_.address(), 0));
     __ JumpIfNotInNewSpace(regs_.scratch0(),  // Value.
                            regs_.scratch0(),
                            &dont_need_remembered_set);
 
     __ JumpIfInNewSpace(regs_.object(), regs_.scratch0(),
                         &dont_need_remembered_set);
 
     // First notify the incremental marker if necessary, then update the
     // remembered set.
     CheckNeedsToInformIncrementalMarker(
@@ skipping 57 matching lines @@
                            value(),
                            save_fp_regs_mode(),
                            MacroAssembler::kReturnAtEnd);
   } else {
     __ Ret();
   }
 
   __ bind(&on_black);
 
   // Get the value from the slot.
-  __ ld(regs_.scratch0(), MemOperand(regs_.address(), 0));
+  __ Ld(regs_.scratch0(), MemOperand(regs_.address(), 0));
 
   if (mode == INCREMENTAL_COMPACTION) {
     Label ensure_not_white;
 
     __ CheckPageFlag(regs_.scratch0(),  // Contains value.
                      regs_.scratch1(),  // Scratch.
                      MemoryChunk::kEvacuationCandidateMask,
                      eq,
                      &ensure_not_white);
 
@@ skipping 34 matching lines @@
 
   // Fall through when we need to inform the incremental marker.
 }
 
 
 void StubFailureTrampolineStub::Generate(MacroAssembler* masm) {
   CEntryStub ces(isolate(), 1, kSaveFPRegs);
   __ Call(ces.GetCode(), RelocInfo::CODE_TARGET);
   int parameter_count_offset =
       StubFailureTrampolineFrameConstants::kArgumentsLengthOffset;
-  __ ld(a1, MemOperand(fp, parameter_count_offset));
+  __ Ld(a1, MemOperand(fp, parameter_count_offset));
   if (function_mode() == JS_FUNCTION_STUB_MODE) {
     __ Daddu(a1, a1, Operand(1));
   }
   masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE);
   __ dsll(a1, a1, kPointerSizeLog2);
   __ Ret(USE_DELAY_SLOT);
   __ Daddu(sp, sp, a1);
 }
 
 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
@@ skipping 107 matching lines @@
     STATIC_ASSERT(FAST_ELEMENTS == 2);
     STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
     STATIC_ASSERT(FAST_DOUBLE_ELEMENTS == 4);
     STATIC_ASSERT(FAST_HOLEY_DOUBLE_ELEMENTS == 5);
 
     // is the low bit set? If so, we are holey and that is good.
     __ And(at, a3, Operand(1));
     __ Branch(&normal_sequence, ne, at, Operand(zero_reg));
   }
   // look at the first argument
-  __ ld(a5, MemOperand(sp, 0));
+  __ Ld(a5, MemOperand(sp, 0));
   __ Branch(&normal_sequence, eq, a5, Operand(zero_reg));
 
   if (mode == DISABLE_ALLOCATION_SITES) {
     ElementsKind initial = GetInitialFastElementsKind();
     ElementsKind holey_initial = GetHoleyElementsKind(initial);
 
     ArraySingleArgumentConstructorStub stub_holey(masm->isolate(),
                                                   holey_initial,
                                                   DISABLE_ALLOCATION_SITES);
     __ TailCallStub(&stub_holey);
 
     __ bind(&normal_sequence);
     ArraySingleArgumentConstructorStub stub(masm->isolate(),
                                             initial,
                                             DISABLE_ALLOCATION_SITES);
     __ TailCallStub(&stub);
   } else if (mode == DONT_OVERRIDE) {
     // We are going to create a holey array, but our kind is non-holey.
     // Fix kind and retry (only if we have an allocation site in the slot).
     __ Daddu(a3, a3, Operand(1));
 
     if (FLAG_debug_code) {
-      __ ld(a5, FieldMemOperand(a2, 0));
+      __ Ld(a5, FieldMemOperand(a2, 0));
       __ LoadRoot(at, Heap::kAllocationSiteMapRootIndex);
       __ Assert(eq, kExpectedAllocationSite, a5, Operand(at));
     }
 
     // Save the resulting elements kind in type info. We can't just store a3
     // in the AllocationSite::transition_info field because elements kind is
     // restricted to a portion of the field...upper bits need to be left alone.
     STATIC_ASSERT(AllocationSite::ElementsKindBits::kShift == 0);
-    __ ld(a4, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
+    __ Ld(a4, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
     __ Daddu(a4, a4, Operand(Smi::FromInt(kFastElementsKindPackedToHoley)));
-    __ sd(a4, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
-
+    __ Sd(a4, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
 
     __ bind(&normal_sequence);
     int last_index = GetSequenceIndexFromFastElementsKind(
         TERMINAL_FAST_ELEMENTS_KIND);
     for (int i = 0; i <= last_index; ++i) {
       ElementsKind kind = GetFastElementsKindFromSequenceIndex(i);
       ArraySingleArgumentConstructorStub stub(masm->isolate(), kind);
       __ TailCallStub(&stub, eq, a3, Operand(kind));
     }
 
@@ skipping 63 matching lines @@
   //  -- a2 : AllocationSite or undefined
   //  -- a3 : new target
   //  -- sp[0] : last argument
   // -----------------------------------
 
   if (FLAG_debug_code) {
     // The array construct code is only set for the global and natives
     // builtin Array functions which always have maps.
 
     // Initial map for the builtin Array function should be a map.
-    __ ld(a4, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
+    __ Ld(a4, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     __ SmiTst(a4, at);
     __ Assert(ne, kUnexpectedInitialMapForArrayFunction,
         at, Operand(zero_reg));
     __ GetObjectType(a4, a4, a5);
     __ Assert(eq, kUnexpectedInitialMapForArrayFunction,
         a5, Operand(MAP_TYPE));
 
     // We should either have undefined in a2 or a valid AllocationSite
     __ AssertUndefinedOrAllocationSite(a2, a4);
   }
 
   // Enter the context of the Array function.
-  __ ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
+  __ Ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
 
   Label subclassing;
   __ Branch(&subclassing, ne, a1, Operand(a3));
 
   Label no_info;
   // Get the elements kind and case on that.
   __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
   __ Branch(&no_info, eq, a2, Operand(at));
 
-  __ ld(a3, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
+  __ Ld(a3, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
   __ SmiUntag(a3);
   STATIC_ASSERT(AllocationSite::ElementsKindBits::kShift == 0);
   __ And(a3, a3, Operand(AllocationSite::ElementsKindBits::kMask));
   GenerateDispatchToArrayStub(masm, DONT_OVERRIDE);
 
   __ bind(&no_info);
   GenerateDispatchToArrayStub(masm, DISABLE_ALLOCATION_SITES);
 
   // Subclassing.
   __ bind(&subclassing);
   __ Dlsa(at, sp, a0, kPointerSizeLog2);
-  __ sd(a1, MemOperand(at));
+  __ Sd(a1, MemOperand(at));
   __ li(at, Operand(3));
   __ Daddu(a0, a0, at);
   __ Push(a3, a2);
   __ JumpToExternalReference(ExternalReference(Runtime::kNewArray, isolate()));
 }
 
 
 void InternalArrayConstructorStub::GenerateCase(
     MacroAssembler* masm, ElementsKind kind) {
 
   InternalArrayNoArgumentConstructorStub stub0(isolate(), kind);
   __ TailCallStub(&stub0, lo, a0, Operand(1));
 
   ArrayNArgumentsConstructorStub stubN(isolate());
   __ TailCallStub(&stubN, hi, a0, Operand(1));
 
   if (IsFastPackedElementsKind(kind)) {
     // We might need to create a holey array
     // look at the first argument.
-    __ ld(at, MemOperand(sp, 0));
+    __ Ld(at, MemOperand(sp, 0));
 
     InternalArraySingleArgumentConstructorStub
         stub1_holey(isolate(), GetHoleyElementsKind(kind));
     __ TailCallStub(&stub1_holey, ne, at, Operand(zero_reg));
   }
 
   InternalArraySingleArgumentConstructorStub stub1(isolate(), kind);
   __ TailCallStub(&stub1);
 }
 
 
 void InternalArrayConstructorStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0 : argc
   //  -- a1 : constructor
   //  -- sp[0] : return address
   //  -- sp[4] : last argument
   // -----------------------------------
 
   if (FLAG_debug_code) {
     // The array construct code is only set for the global and natives
     // builtin Array functions which always have maps.
 
     // Initial map for the builtin Array function should be a map.
-    __ ld(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
+    __ Ld(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     __ SmiTst(a3, at);
     __ Assert(ne, kUnexpectedInitialMapForArrayFunction,
         at, Operand(zero_reg));
     __ GetObjectType(a3, a3, a4);
     __ Assert(eq, kUnexpectedInitialMapForArrayFunction,
         a4, Operand(MAP_TYPE));
   }
 
   // Figure out the right elements kind.
-  __ ld(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
+  __ Ld(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
 
   // Load the map's "bit field 2" into a3. We only need the first byte,
   // but the following bit field extraction takes care of that anyway.
-  __ lbu(a3, FieldMemOperand(a3, Map::kBitField2Offset));
+  __ Lbu(a3, FieldMemOperand(a3, Map::kBitField2Offset));
   // Retrieve elements_kind from bit field 2.
   __ DecodeField<Map::ElementsKindBits>(a3);
 
   if (FLAG_debug_code) {
     Label done;
     __ Branch(&done, eq, a3, Operand(FAST_ELEMENTS));
     __ Assert(
         eq, kInvalidElementsKindForInternalArrayOrInternalPackedArray,
         a3, Operand(FAST_HOLEY_ELEMENTS));
     __ bind(&done);
@@ skipping 29 matching lines @@
   const int kLimitOffset = AddressOffset(
       ExternalReference::handle_scope_limit_address(isolate), next_address);
   const int kLevelOffset = AddressOffset(
       ExternalReference::handle_scope_level_address(isolate), next_address);
 
   DCHECK(function_address.is(a1) || function_address.is(a2));
 
   Label profiler_disabled;
   Label end_profiler_check;
   __ li(t9, Operand(ExternalReference::is_profiling_address(isolate)));
-  __ lb(t9, MemOperand(t9, 0));
+  __ Lb(t9, MemOperand(t9, 0));
   __ Branch(&profiler_disabled, eq, t9, Operand(zero_reg));
 
   // Additional parameter is the address of the actual callback.
   __ li(t9, Operand(thunk_ref));
   __ jmp(&end_profiler_check);
 
   __ bind(&profiler_disabled);
   __ mov(t9, function_address);
   __ bind(&end_profiler_check);
 
   // Allocate HandleScope in callee-save registers.
   __ li(s3, Operand(next_address));
-  __ ld(s0, MemOperand(s3, kNextOffset));
-  __ ld(s1, MemOperand(s3, kLimitOffset));
-  __ lw(s2, MemOperand(s3, kLevelOffset));
+  __ Ld(s0, MemOperand(s3, kNextOffset));
+  __ Ld(s1, MemOperand(s3, kLimitOffset));
+  __ Lw(s2, MemOperand(s3, kLevelOffset));
   __ Addu(s2, s2, Operand(1));
-  __ sw(s2, MemOperand(s3, kLevelOffset));
+  __ Sw(s2, MemOperand(s3, kLevelOffset));
 
   if (FLAG_log_timer_events) {
     FrameScope frame(masm, StackFrame::MANUAL);
     __ PushSafepointRegisters();
     __ PrepareCallCFunction(1, a0);
     __ li(a0, Operand(ExternalReference::isolate_address(isolate)));
     __ CallCFunction(ExternalReference::log_enter_external_function(isolate),
                      1);
     __ PopSafepointRegisters();
   }
@@ skipping 13 matching lines @@
                      1);
     __ PopSafepointRegisters();
   }
 
   Label promote_scheduled_exception;
   Label delete_allocated_handles;
   Label leave_exit_frame;
   Label return_value_loaded;
 
   // Load value from ReturnValue.
-  __ ld(v0, return_value_operand);
+  __ Ld(v0, return_value_operand);
   __ bind(&return_value_loaded);
 
   // No more valid handles (the result handle was the last one). Restore
   // previous handle scope.
-  __ sd(s0, MemOperand(s3, kNextOffset));
+  __ Sd(s0, MemOperand(s3, kNextOffset));
   if (__ emit_debug_code()) {
-    __ lw(a1, MemOperand(s3, kLevelOffset));
+    __ Lw(a1, MemOperand(s3, kLevelOffset));
     __ Check(eq, kUnexpectedLevelAfterReturnFromApiCall, a1, Operand(s2));
   }
   __ Subu(s2, s2, Operand(1));
-  __ sw(s2, MemOperand(s3, kLevelOffset));
-  __ ld(at, MemOperand(s3, kLimitOffset));
+  __ Sw(s2, MemOperand(s3, kLevelOffset));
+  __ Ld(at, MemOperand(s3, kLimitOffset));
   __ Branch(&delete_allocated_handles, ne, s1, Operand(at));
 
   // Leave the API exit frame.
   __ bind(&leave_exit_frame);
 
   bool restore_context = context_restore_operand != NULL;
   if (restore_context) {
-    __ ld(cp, *context_restore_operand);
+    __ Ld(cp, *context_restore_operand);
   }
   if (stack_space_offset != kInvalidStackOffset) {
     DCHECK(kCArgsSlotsSize == 0);
-    __ ld(s0, MemOperand(sp, stack_space_offset));
+    __ Ld(s0, MemOperand(sp, stack_space_offset));
   } else {
     __ li(s0, Operand(stack_space));
   }
   __ LeaveExitFrame(false, s0, !restore_context, NO_EMIT_RETURN,
                     stack_space_offset != kInvalidStackOffset);
 
   // Check if the function scheduled an exception.
   __ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
   __ li(at, Operand(ExternalReference::scheduled_exception_address(isolate)));
-  __ ld(a5, MemOperand(at));
+  __ Ld(a5, MemOperand(at));
   __ Branch(&promote_scheduled_exception, ne, a4, Operand(a5));
 
   __ Ret();
 
   // Re-throw by promoting a scheduled exception.
   __ bind(&promote_scheduled_exception);
   __ TailCallRuntime(Runtime::kPromoteScheduledException);
 
   // HandleScope limit has changed. Delete allocated extensions.
   __ bind(&delete_allocated_handles);
-  __ sd(s1, MemOperand(s3, kLimitOffset));
+  __ Sd(s1, MemOperand(s3, kLimitOffset));
   __ mov(s0, v0);
   __ mov(a0, v0);
   __ PrepareCallCFunction(1, s1);
   __ li(a0, Operand(ExternalReference::isolate_address(isolate)));
   __ CallCFunction(ExternalReference::delete_handle_scope_extensions(isolate),
                    1);
   __ mov(v0, s0);
   __ jmp(&leave_exit_frame);
 }
 
@@ skipping 29 matching lines @@
   STATIC_ASSERT(FCA::kNewTargetIndex == 7);
   STATIC_ASSERT(FCA::kArgsLength == 8);
 
   // new target
   __ PushRoot(Heap::kUndefinedValueRootIndex);
 
   // Save context, callee and call data.
   __ Push(context, callee, call_data);
   if (!is_lazy()) {
     // Load context from callee.
-    __ ld(context, FieldMemOperand(callee, JSFunction::kContextOffset));
+    __ Ld(context, FieldMemOperand(callee, JSFunction::kContextOffset));
   }
 
   Register scratch = call_data;
   if (!call_data_undefined()) {
     __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
   }
   // Push return value and default return value.
   __ Push(scratch, scratch);
   __ li(scratch, Operand(ExternalReference::isolate_address(masm->isolate())));
   // Push isolate and holder.
   __ Push(scratch, holder);
 
   // Prepare arguments.
   __ mov(scratch, sp);
 
   // Allocate the v8::Arguments structure in the arguments' space since
   // it's not controlled by GC.
   const int kApiStackSpace = 3;
 
   FrameScope frame_scope(masm, StackFrame::MANUAL);
   __ EnterExitFrame(false, kApiStackSpace);
 
   DCHECK(!api_function_address.is(a0) && !scratch.is(a0));
   // a0 = FunctionCallbackInfo&
   // Arguments is after the return address.
   __ Daddu(a0, sp, Operand(1 * kPointerSize));
   // FunctionCallbackInfo::implicit_args_
-  __ sd(scratch, MemOperand(a0, 0 * kPointerSize));
+  __ Sd(scratch, MemOperand(a0, 0 * kPointerSize));
   // FunctionCallbackInfo::values_
   __ Daddu(at, scratch,
            Operand((FCA::kArgsLength - 1 + argc()) * kPointerSize));
-  __ sd(at, MemOperand(a0, 1 * kPointerSize));
+  __ Sd(at, MemOperand(a0, 1 * kPointerSize));
   // FunctionCallbackInfo::length_ = argc
   // Stored as int field, 32-bit integers within struct on stack always left
   // justified by n64 ABI.
   __ li(at, Operand(argc()));
-  __ sw(at, MemOperand(a0, 2 * kPointerSize));
+  __ Sw(at, MemOperand(a0, 2 * kPointerSize));
 
   ExternalReference thunk_ref =
       ExternalReference::invoke_function_callback(masm->isolate());
 
   AllowExternalCallThatCantCauseGC scope(masm);
   MemOperand context_restore_operand(
       fp, (2 + FCA::kContextSaveIndex) * kPointerSize);
   // Stores return the first js argument.
   int return_value_offset = 0;
   if (is_store()) {
@@ skipping 29 matching lines @@
   Register holder = ApiGetterDescriptor::HolderRegister();
   Register callback = ApiGetterDescriptor::CallbackRegister();
   Register scratch = a4;
   DCHECK(!AreAliased(receiver, holder, callback, scratch));
 
   Register api_function_address = a2;
 
   // Here and below +1 is for name() pushed after the args_ array.
   typedef PropertyCallbackArguments PCA;
   __ Dsubu(sp, sp, (PCA::kArgsLength + 1) * kPointerSize);
-  __ sd(receiver, MemOperand(sp, (PCA::kThisIndex + 1) * kPointerSize));
-  __ ld(scratch, FieldMemOperand(callback, AccessorInfo::kDataOffset));
-  __ sd(scratch, MemOperand(sp, (PCA::kDataIndex + 1) * kPointerSize));
+  __ Sd(receiver, MemOperand(sp, (PCA::kThisIndex + 1) * kPointerSize));
+  __ Ld(scratch, FieldMemOperand(callback, AccessorInfo::kDataOffset));
+  __ Sd(scratch, MemOperand(sp, (PCA::kDataIndex + 1) * kPointerSize));
   __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
-  __ sd(scratch, MemOperand(sp, (PCA::kReturnValueOffset + 1) * kPointerSize));
-  __ sd(scratch, MemOperand(sp, (PCA::kReturnValueDefaultValueIndex + 1) *
+  __ Sd(scratch, MemOperand(sp, (PCA::kReturnValueOffset + 1) * kPointerSize));
+  __ Sd(scratch, MemOperand(sp, (PCA::kReturnValueDefaultValueIndex + 1) *
                                     kPointerSize));
   __ li(scratch, Operand(ExternalReference::isolate_address(isolate())));
-  __ sd(scratch, MemOperand(sp, (PCA::kIsolateIndex + 1) * kPointerSize));
-  __ sd(holder, MemOperand(sp, (PCA::kHolderIndex + 1) * kPointerSize));
+  __ Sd(scratch, MemOperand(sp, (PCA::kIsolateIndex + 1) * kPointerSize));
+  __ Sd(holder, MemOperand(sp, (PCA::kHolderIndex + 1) * kPointerSize));
   // should_throw_on_error -> false
   DCHECK(Smi::kZero == nullptr);
-  __ sd(zero_reg,
+  __ Sd(zero_reg,
         MemOperand(sp, (PCA::kShouldThrowOnErrorIndex + 1) * kPointerSize));
-  __ ld(scratch, FieldMemOperand(callback, AccessorInfo::kNameOffset));
-  __ sd(scratch, MemOperand(sp, 0 * kPointerSize));
+  __ Ld(scratch, FieldMemOperand(callback, AccessorInfo::kNameOffset));
+  __ Sd(scratch, MemOperand(sp, 0 * kPointerSize));
 
   // v8::PropertyCallbackInfo::args_ array and name handle.
   const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1;
 
   // Load address of v8::PropertyAccessorInfo::args_ array and name handle.
   __ mov(a0, sp);                               // a0 = Handle<Name>
   __ Daddu(a1, a0, Operand(1 * kPointerSize));  // a1 = v8::PCI::args_
 
   const int kApiStackSpace = 1;
   FrameScope frame_scope(masm, StackFrame::MANUAL);
   __ EnterExitFrame(false, kApiStackSpace);
 
   // Create v8::PropertyCallbackInfo object on the stack and initialize
   // it's args_ field.
-  __ sd(a1, MemOperand(sp, 1 * kPointerSize));
+  __ Sd(a1, MemOperand(sp, 1 * kPointerSize));
   __ Daddu(a1, sp, Operand(1 * kPointerSize));
   // a1 = v8::PropertyCallbackInfo&
 
   ExternalReference thunk_ref =
       ExternalReference::invoke_accessor_getter_callback(isolate());
 
-  __ ld(scratch, FieldMemOperand(callback, AccessorInfo::kJsGetterOffset));
-  __ ld(api_function_address,
+  __ Ld(scratch, FieldMemOperand(callback, AccessorInfo::kJsGetterOffset));
+  __ Ld(api_function_address,
         FieldMemOperand(scratch, Foreign::kForeignAddressOffset));
 
   // +3 is to skip prolog, return address and name handle.
   MemOperand return_value_operand(
       fp, (PropertyCallbackArguments::kReturnValueOffset + 3) * kPointerSize);
   CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
                            kStackUnwindSpace, kInvalidStackOffset,
                            return_value_operand, NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64