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

src/builtins/mips64/builtins-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/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 14 matching lines @@
   //  -- ...
   //  -- sp[8 * (argc - 1)] : first argument
   //  -- sp[8 * agrc]       : receiver
   // -----------------------------------
   __ AssertFunction(a1);
 
   // Make sure we operate in the context of the called function (for example
   // ConstructStubs implemented in C++ will be run in the context of the caller
   // instead of the callee, due to the way that [[Construct]] is defined for
   // ordinary functions).
-  __ ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
+  __ Ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
 
   // JumpToExternalReference expects a0 to contain the number of arguments
   // including the receiver and the extra arguments.
   const int num_extra_args = 3;
   __ Daddu(a0, a0, num_extra_args + 1);
 
   // Insert extra arguments.
   __ SmiTag(a0);
   __ Push(a0, a1, a3);
   __ SmiUntag(a0);
@@ skipping 21 matching lines @@
   //  -- ra     : return address
   //  -- sp[...]: constructor arguments
   // -----------------------------------
   Label generic_array_code, one_or_more_arguments, two_or_more_arguments;
 
   // Get the InternalArray function.
   GenerateLoadInternalArrayFunction(masm, a1);
 
   if (FLAG_debug_code) {
     // Initial map for the builtin InternalArray functions should be maps.
-    __ ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
+    __ Ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
     __ SmiTst(a2, a4);
     __ Assert(ne, kUnexpectedInitialMapForInternalArrayFunction, a4,
               Operand(zero_reg));
     __ GetObjectType(a2, a3, a4);
     __ Assert(eq, kUnexpectedInitialMapForInternalArrayFunction, a4,
               Operand(MAP_TYPE));
   }
 
   // Run the native code for the InternalArray function called as a normal
   // function.
   // Tail call a stub.
   InternalArrayConstructorStub stub(masm->isolate());
   __ TailCallStub(&stub);
 }
 
 void Builtins::Generate_ArrayCode(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0     : number of arguments
   //  -- ra     : return address
   //  -- sp[...]: constructor arguments
   // -----------------------------------
   Label generic_array_code;
 
   // Get the Array function.
   GenerateLoadArrayFunction(masm, a1);
 
   if (FLAG_debug_code) {
     // Initial map for the builtin Array functions should be maps.
-    __ ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
+    __ Ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
     __ SmiTst(a2, a4);
     __ Assert(ne, kUnexpectedInitialMapForArrayFunction1, a4,
               Operand(zero_reg));
     __ GetObjectType(a2, a3, a4);
     __ Assert(eq, kUnexpectedInitialMapForArrayFunction2, a4,
               Operand(MAP_TYPE));
   }
 
   // Run the native code for the Array function called as a normal function.
   // Tail call a stub.
@@ skipping 15 matching lines @@
   // -----------------------------------
 
   // 1. Load the first argument into a0 and get rid of the rest (including the
   // receiver).
   Label no_arguments;
   {
     __ Branch(USE_DELAY_SLOT, &no_arguments, eq, a0, Operand(zero_reg));
     __ Dsubu(t1, a0, Operand(1));  // In delay slot.
     __ mov(t0, a0);                // Store argc in t0.
     __ Dlsa(at, sp, t1, kPointerSizeLog2);
-    __ ld(a0, MemOperand(at));
+    __ Ld(a0, MemOperand(at));
   }
 
   // 2a. Convert first argument to number.
   {
     FrameScope scope(masm, StackFrame::MANUAL);
     __ SmiTag(t0);
     __ EnterBuiltinFrame(cp, a1, t0);
     __ Call(masm->isolate()->builtins()->ToNumber(), RelocInfo::CODE_TARGET);
     __ LeaveBuiltinFrame(cp, a1, t0);
     __ SmiUntag(t0);
@@ skipping 16 matching lines @@
   //  -- a0                     : number of arguments
   //  -- a1                     : constructor function
   //  -- a3                     : new target
   //  -- cp                     : context
   //  -- ra                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero based)
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // 1. Make sure we operate in the context of the called function.
-  __ ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
+  __ Ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
 
   // 2. Load the first argument into a0 and get rid of the rest (including the
   // receiver).
   {
     Label no_arguments, done;
     __ mov(t0, a0);  // Store argc in t0.
     __ Branch(USE_DELAY_SLOT, &no_arguments, eq, a0, Operand(zero_reg));
     __ Dsubu(a0, a0, Operand(1));  // In delay slot.
     __ Dlsa(at, sp, a0, kPointerSizeLog2);
-    __ ld(a0, MemOperand(at));
+    __ Ld(a0, MemOperand(at));
     __ jmp(&done);
     __ bind(&no_arguments);
     __ Move(a0, Smi::kZero);
     __ bind(&done);
   }
 
   // 3. Make sure a0 is a number.
   {
     Label done_convert;
     __ JumpIfSmi(a0, &done_convert);
@@ skipping 27 matching lines @@
     FrameScope scope(masm, StackFrame::MANUAL);
     __ SmiTag(t0);
     __ EnterBuiltinFrame(cp, a1, t0);
     __ Push(a0);
     __ Call(CodeFactory::FastNewObject(masm->isolate()).code(),
             RelocInfo::CODE_TARGET);
     __ Pop(a0);
     __ LeaveBuiltinFrame(cp, a1, t0);
     __ SmiUntag(t0);
   }
-  __ sd(a0, FieldMemOperand(v0, JSValue::kValueOffset));
+  __ Sd(a0, FieldMemOperand(v0, JSValue::kValueOffset));
 
   __ bind(&drop_frame_and_ret);
   {
     __ Dlsa(sp, sp, t0, kPointerSizeLog2);
     __ DropAndRet(1);
   }
 }
 
 // static
 void Builtins::Generate_StringConstructor(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0                     : number of arguments
   //  -- a1                     : constructor function
   //  -- cp                     : context
   //  -- ra                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero based)
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // 1. Load the first argument into a0 and get rid of the rest (including the
   // receiver).
   Label no_arguments;
   {
     __ Branch(USE_DELAY_SLOT, &no_arguments, eq, a0, Operand(zero_reg));
     __ Dsubu(t1, a0, Operand(1));  // In delay slot.
     __ mov(t0, a0);                // Store argc in t0.
     __ Dlsa(at, sp, t1, kPointerSizeLog2);
-    __ ld(a0, MemOperand(at));
+    __ Ld(a0, MemOperand(at));
   }
 
   // 2a. At least one argument, return a0 if it's a string, otherwise
   // dispatch to appropriate conversion.
   Label drop_frame_and_ret, to_string, symbol_descriptive_string;
   {
     __ JumpIfSmi(a0, &to_string);
     __ GetObjectType(a0, t1, t1);
     STATIC_ASSERT(FIRST_NONSTRING_TYPE == SYMBOL_TYPE);
     __ Subu(t1, t1, Operand(FIRST_NONSTRING_TYPE));
@@ skipping 43 matching lines @@
   //  -- a0                     : number of arguments
   //  -- a1                     : constructor function
   //  -- a3                     : new target
   //  -- cp                     : context
   //  -- ra                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero based)
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // 1. Make sure we operate in the context of the called function.
-  __ ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
+  __ Ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
 
   // 2. Load the first argument into a0 and get rid of the rest (including the
   // receiver).
   {
     Label no_arguments, done;
     __ mov(t0, a0);  // Store argc in t0.
     __ Branch(USE_DELAY_SLOT, &no_arguments, eq, a0, Operand(zero_reg));
     __ Dsubu(a0, a0, Operand(1));
     __ Dlsa(at, sp, a0, kPointerSizeLog2);
-    __ ld(a0, MemOperand(at));
+    __ Ld(a0, MemOperand(at));
     __ jmp(&done);
     __ bind(&no_arguments);
     __ LoadRoot(a0, Heap::kempty_stringRootIndex);
     __ bind(&done);
   }
 
   // 3. Make sure a0 is a string.
   {
     Label convert, done_convert;
     __ JumpIfSmi(a0, &convert);
@@ skipping 29 matching lines @@
     FrameScope scope(masm, StackFrame::MANUAL);
     __ SmiTag(t0);
     __ EnterBuiltinFrame(cp, a1, t0);
     __ Push(a0);
     __ Call(CodeFactory::FastNewObject(masm->isolate()).code(),
             RelocInfo::CODE_TARGET);
     __ Pop(a0);
     __ LeaveBuiltinFrame(cp, a1, t0);
     __ SmiUntag(t0);
   }
-  __ sd(a0, FieldMemOperand(v0, JSValue::kValueOffset));
+  __ Sd(a0, FieldMemOperand(v0, JSValue::kValueOffset));
 
   __ bind(&drop_frame_and_ret);
   {
     __ Dlsa(sp, sp, t0, kPointerSizeLog2);
     __ DropAndRet(1);
   }
 }
 
 static void GenerateTailCallToSharedCode(MacroAssembler* masm) {
-  __ ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
-  __ ld(a2, FieldMemOperand(a2, SharedFunctionInfo::kCodeOffset));
+  __ Ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(a2, FieldMemOperand(a2, SharedFunctionInfo::kCodeOffset));
   __ Daddu(at, a2, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Jump(at);
 }
 
 static void GenerateTailCallToReturnedCode(MacroAssembler* masm,
                                            Runtime::FunctionId function_id) {
   // ----------- S t a t e -------------
   //  -- a0 : argument count (preserved for callee)
   //  -- a1 : target function (preserved for callee)
   //  -- a3 : new target (preserved for callee)
@@ skipping 62 matching lines @@
       __ Call(CodeFactory::FastNewObject(masm->isolate()).code(),
               RelocInfo::CODE_TARGET);
       __ mov(t0, v0);
       __ Pop(a1, a3);
 
       // ----------- S t a t e -------------
       // -- a1: constructor function
       // -- a3: new target
       // -- t0: newly allocated object
       // -----------------------------------
-      __ ld(a0, MemOperand(sp));
+      __ Ld(a0, MemOperand(sp));
     }
     __ SmiUntag(a0);
 
     if (create_implicit_receiver) {
       // Push the allocated receiver to the stack. We need two copies
       // because we may have to return the original one and the calling
       // conventions dictate that the called function pops the receiver.
       __ Push(t0, t0);
     } else {
       __ PushRoot(Heap::kTheHoleValueRootIndex);
@@ skipping 12 matching lines @@
     // a3: new target
     // t0: number of arguments (smi-tagged)
     // sp[0]: receiver
     // sp[1]: receiver
     // sp[2]: number of arguments (smi-tagged)
     Label loop, entry;
     __ mov(t0, a0);
     __ jmp(&entry);
     __ bind(&loop);
     __ Dlsa(a4, a2, t0, kPointerSizeLog2);
-    __ ld(a5, MemOperand(a4));
+    __ Ld(a5, MemOperand(a4));
     __ push(a5);
     __ bind(&entry);
     __ Daddu(t0, t0, Operand(-1));
     __ Branch(&loop, greater_equal, t0, Operand(zero_reg));
 
     // Call the function.
     // a0: number of arguments
     // a1: constructor function
     // a3: new target
     ParameterCount actual(a0);
     __ InvokeFunction(a1, a3, actual, CALL_FUNCTION,
                       CheckDebugStepCallWrapper());
 
     // Store offset of return address for deoptimizer.
     if (create_implicit_receiver && !disallow_non_object_return &&
         !is_api_function) {
       masm->isolate()->heap()->SetConstructStubInvokeDeoptPCOffset(
           masm->pc_offset());
     }
 
     // Restore context from the frame.
-    __ ld(cp, MemOperand(fp, ConstructFrameConstants::kContextOffset));
+    __ Ld(cp, MemOperand(fp, ConstructFrameConstants::kContextOffset));
 
     if (create_implicit_receiver) {
       // If the result is an object (in the ECMA sense), we should get rid
       // of the receiver and use the result; see ECMA-262 section 13.2.2-7
       // on page 74.
       Label use_receiver, return_value, do_throw;
 
       // If the result is a smi, it is *not* an object in the ECMA sense.
       // v0: result
       // sp[0]: receiver (newly allocated object)
@@ skipping 15 matching lines @@
                 Operand(FIRST_JS_RECEIVER_TYPE));
 
       if (disallow_non_object_return) {
         __ bind(&do_throw);
         __ CallRuntime(Runtime::kThrowConstructorReturnedNonObject);
       }
 
       // Throw away the result of the constructor invocation and use the
       // on-stack receiver as the result.
       __ bind(&use_receiver);
-      __ ld(v0, MemOperand(sp));
+      __ Ld(v0, MemOperand(sp));
 
       // Remove receiver from the stack, remove caller arguments, and
       // return.
       __ bind(&return_value);
       // v0: result
       // sp[0]: receiver (newly allocated object)
       // sp[1]: number of arguments (smi-tagged)
-      __ ld(a1, MemOperand(sp, 1 * kPointerSize));
+      __ Ld(a1, MemOperand(sp, 1 * kPointerSize));
     } else {
-      __ ld(a1, MemOperand(sp));
+      __ Ld(a1, MemOperand(sp));
     }
 
     // Leave construct frame.
   }
 
   // ES6 9.2.2. Step 13+
   // For derived class constructors, throw a TypeError here if the result
   // is not a JSReceiver. For the base constructor, we've already checked
   // the result, so we omit the check.
   if (disallow_non_object_return && !create_implicit_receiver) {
@@ skipping 28 matching lines @@
 
     // ----------- S t a t e -------------
     //  -- a0    : newly allocated object
     //  -- sp[0] : constructor function
     // -----------------------------------
 
     __ Pop(a1);
     __ Push(a0, a0);
 
     // Retrieve smi-tagged arguments count from the stack.
-    __ ld(a0, MemOperand(fp, ConstructFrameConstants::kLengthOffset));
+    __ Ld(a0, MemOperand(fp, ConstructFrameConstants::kLengthOffset));
     __ SmiUntag(a0);
 
     // Retrieve the new target value from the stack. This was placed into the
     // frame description in place of the receiver by the optimizing compiler.
     __ Daddu(a3, fp, Operand(StandardFrameConstants::kCallerSPOffset));
     __ Dlsa(a3, a3, a0, kPointerSizeLog2);
-    __ ld(a3, MemOperand(a3));
+    __ Ld(a3, MemOperand(a3));
 
     // Continue with constructor function invocation.
     __ jmp(&post_instantiation_deopt_entry);
   }
 }
 
 }  // namespace
 
 void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
   Generate_JSConstructStubHelper(masm, false, true, false);
@@ skipping 28 matching lines @@
   __ SmiUntag(a3);
   __ AssertGeneratorObject(a1, a3);
 
   // Store input value into generator object.
   Label async_await, done_store_input;
 
   __ And(t8, a3, Operand(static_cast<int>(SuspendFlags::kAsyncGeneratorAwait)));
   __ Branch(&async_await, equal, t8,
             Operand(static_cast<int>(SuspendFlags::kAsyncGeneratorAwait)));
 
-  __ sd(v0, FieldMemOperand(a1, JSGeneratorObject::kInputOrDebugPosOffset));
+  __ Sd(v0, FieldMemOperand(a1, JSGeneratorObject::kInputOrDebugPosOffset));
   __ RecordWriteField(a1, JSGeneratorObject::kInputOrDebugPosOffset, v0, a3,
                       kRAHasNotBeenSaved, kDontSaveFPRegs);
   __ jmp(&done_store_input);
 
   __ bind(&async_await);
-  __ sd(v0, FieldMemOperand(
+  __ Sd(v0, FieldMemOperand(
                 a1, JSAsyncGeneratorObject::kAwaitInputOrDebugPosOffset));
   __ RecordWriteField(a1, JSAsyncGeneratorObject::kAwaitInputOrDebugPosOffset,
                       v0, a3, kRAHasNotBeenSaved, kDontSaveFPRegs);
 
   __ bind(&done_store_input);
   // `a3` no longer holds SuspendFlags
 
   // Store resume mode into generator object.
-  __ sd(a2, FieldMemOperand(a1, JSGeneratorObject::kResumeModeOffset));
+  __ Sd(a2, FieldMemOperand(a1, JSGeneratorObject::kResumeModeOffset));
 
   // Load suspended function and context.
-  __ ld(a4, FieldMemOperand(a1, JSGeneratorObject::kFunctionOffset));
-  __ ld(cp, FieldMemOperand(a4, JSFunction::kContextOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSGeneratorObject::kFunctionOffset));
+  __ Ld(cp, FieldMemOperand(a4, JSFunction::kContextOffset));
 
   // Flood function if we are stepping.
   Label prepare_step_in_if_stepping, prepare_step_in_suspended_generator;
   Label stepping_prepared;
   ExternalReference debug_hook =
       ExternalReference::debug_hook_on_function_call_address(masm->isolate());
   __ li(a5, Operand(debug_hook));
-  __ lb(a5, MemOperand(a5));
+  __ Lb(a5, MemOperand(a5));
   __ Branch(&prepare_step_in_if_stepping, ne, a5, Operand(zero_reg));
 
   // Flood function if we need to continue stepping in the suspended generator.
   ExternalReference debug_suspended_generator =
       ExternalReference::debug_suspended_generator_address(masm->isolate());
   __ li(a5, Operand(debug_suspended_generator));
-  __ ld(a5, MemOperand(a5));
+  __ Ld(a5, MemOperand(a5));
   __ Branch(&prepare_step_in_suspended_generator, eq, a1, Operand(a5));
   __ bind(&stepping_prepared);
 
   // Push receiver.
-  __ ld(a5, FieldMemOperand(a1, JSGeneratorObject::kReceiverOffset));
+  __ Ld(a5, FieldMemOperand(a1, JSGeneratorObject::kReceiverOffset));
   __ Push(a5);
 
   // ----------- S t a t e -------------
   //  -- a1    : the JSGeneratorObject to resume
   //  -- a2    : the resume mode (tagged)
   //  -- a4    : generator function
   //  -- cp    : generator context
   //  -- ra    : return address
   //  -- sp[0] : generator receiver
   // -----------------------------------
 
   // Push holes for arguments to generator function. Since the parser forced
   // context allocation for any variables in generators, the actual argument
   // values have already been copied into the context and these dummy values
   // will never be used.
-  __ ld(a3, FieldMemOperand(a4, JSFunction::kSharedFunctionInfoOffset));
-  __ lw(a3,
+  __ Ld(a3, FieldMemOperand(a4, JSFunction::kSharedFunctionInfoOffset));
+  __ Lw(a3,
         FieldMemOperand(a3, SharedFunctionInfo::kFormalParameterCountOffset));
   {
     Label done_loop, loop;
     __ bind(&loop);
     __ Dsubu(a3, a3, Operand(1));
     __ Branch(&done_loop, lt, a3, Operand(zero_reg));
     __ PushRoot(Heap::kTheHoleValueRootIndex);
     __ Branch(&loop);
     __ bind(&done_loop);
   }
 
   // Underlying function needs to have bytecode available.
   if (FLAG_debug_code) {
-    __ ld(a3, FieldMemOperand(a4, JSFunction::kSharedFunctionInfoOffset));
-    __ ld(a3, FieldMemOperand(a3, SharedFunctionInfo::kFunctionDataOffset));
+    __ Ld(a3, FieldMemOperand(a4, JSFunction::kSharedFunctionInfoOffset));
+    __ Ld(a3, FieldMemOperand(a3, SharedFunctionInfo::kFunctionDataOffset));
     __ GetObjectType(a3, a3, a3);
     __ Assert(eq, kMissingBytecodeArray, a3, Operand(BYTECODE_ARRAY_TYPE));
   }
 
   // Resume (Ignition/TurboFan) generator object.
   {
-    __ ld(a0, FieldMemOperand(a4, JSFunction::kSharedFunctionInfoOffset));
-    __ lw(a0,
+    __ Ld(a0, FieldMemOperand(a4, JSFunction::kSharedFunctionInfoOffset));
+    __ Lw(a0,
           FieldMemOperand(a0, SharedFunctionInfo::kFormalParameterCountOffset));
     // We abuse new.target both to indicate that this is a resume call and to
     // pass in the generator object.  In ordinary calls, new.target is always
     // undefined because generator functions are non-constructable.
     __ Move(a3, a1);
     __ Move(a1, a4);
-    __ ld(a2, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
+    __ Ld(a2, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
     __ Jump(a2);
   }
 
   __ bind(&prepare_step_in_if_stepping);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(a1, a2, a4);
     __ CallRuntime(Runtime::kDebugOnFunctionCall);
     __ Pop(a1, a2);
   }
   __ Branch(USE_DELAY_SLOT, &stepping_prepared);
-  __ ld(a4, FieldMemOperand(a1, JSGeneratorObject::kFunctionOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSGeneratorObject::kFunctionOffset));
 
   __ bind(&prepare_step_in_suspended_generator);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(a1, a2);
     __ CallRuntime(Runtime::kDebugPrepareStepInSuspendedGenerator);
     __ Pop(a1, a2);
   }
   __ Branch(USE_DELAY_SLOT, &stepping_prepared);
-  __ ld(a4, FieldMemOperand(a1, JSGeneratorObject::kFunctionOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSGeneratorObject::kFunctionOffset));
 }
 
 void Builtins::Generate_ConstructedNonConstructable(MacroAssembler* masm) {
   FrameScope scope(masm, StackFrame::INTERNAL);
   __ Push(a1);
   __ CallRuntime(Runtime::kThrowConstructedNonConstructable);
 }
 
 enum IsTagged { kArgcIsSmiTagged, kArgcIsUntaggedInt };
 
@@ skipping 37 matching lines @@
   ProfileEntryHookStub::MaybeCallEntryHook(masm);
 
   // Enter an internal frame.
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
 
     // Setup the context (we need to use the caller context from the isolate).
     ExternalReference context_address(Isolate::kContextAddress,
                                       masm->isolate());
     __ li(cp, Operand(context_address));
-    __ ld(cp, MemOperand(cp));
+    __ Ld(cp, MemOperand(cp));
 
     // Push the function and the receiver onto the stack.
     __ Push(a1, a2);
 
     // Check if we have enough stack space to push all arguments.
     // Clobbers a2.
     Generate_CheckStackOverflow(masm, a3, kArgcIsUntaggedInt);
 
     // Remember new.target.
     __ mov(a5, a0);
 
     // Copy arguments to the stack in a loop.
     // a3: argc
     // s0: argv, i.e. points to first arg
     Label loop, entry;
     __ Dlsa(a6, s0, a3, kPointerSizeLog2);
     __ b(&entry);
     __ nop();  // Branch delay slot nop.
     // a6 points past last arg.
     __ bind(&loop);
-    __ ld(a4, MemOperand(s0));  // Read next parameter.
+    __ Ld(a4, MemOperand(s0));  // Read next parameter.
     __ daddiu(s0, s0, kPointerSize);
-    __ ld(a4, MemOperand(a4));  // Dereference handle.
+    __ Ld(a4, MemOperand(a4));  // Dereference handle.
     __ push(a4);                // Push parameter.
     __ bind(&entry);
     __ Branch(&loop, ne, s0, Operand(a6));
 
     // Setup new.target and argc.
     __ mov(a0, a3);
     __ mov(a3, a5);
 
     // Initialize all JavaScript callee-saved registers, since they will be seen
     // by the garbage collector as part of handlers.
@@ skipping 22 matching lines @@
 }
 
 void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
 static void LeaveInterpreterFrame(MacroAssembler* masm, Register scratch) {
   Register args_count = scratch;
 
   // Get the arguments + receiver count.
-  __ ld(args_count,
+  __ Ld(args_count,
         MemOperand(fp, InterpreterFrameConstants::kBytecodeArrayFromFp));
-  __ lw(t0, FieldMemOperand(args_count, BytecodeArray::kParameterSizeOffset));
+  __ Lw(t0, FieldMemOperand(args_count, BytecodeArray::kParameterSizeOffset));
 
   // Leave the frame (also dropping the register file).
   __ LeaveFrame(StackFrame::JAVA_SCRIPT);
 
   // Drop receiver + arguments.
   __ Daddu(sp, sp, args_count);
 }
 
 // Generate code for entering a JS function with the interpreter.
 // On entry to the function the receiver and arguments have been pushed on the
@@ skipping 14 matching lines @@
   ProfileEntryHookStub::MaybeCallEntryHook(masm);
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // MANUAL indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done below).
   FrameScope frame_scope(masm, StackFrame::MANUAL);
   __ PushStandardFrame(a1);
 
   // Get the bytecode array from the function object (or from the DebugInfo if
   // it is present) and load it into kInterpreterBytecodeArrayRegister.
-  __ ld(a0, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(a0, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
   Label load_debug_bytecode_array, bytecode_array_loaded;
   Register debug_info = kInterpreterBytecodeArrayRegister;
   DCHECK(!debug_info.is(a0));
-  __ ld(debug_info, FieldMemOperand(a0, SharedFunctionInfo::kDebugInfoOffset));
+  __ Ld(debug_info, FieldMemOperand(a0, SharedFunctionInfo::kDebugInfoOffset));
   __ JumpIfNotSmi(debug_info, &load_debug_bytecode_array);
-  __ ld(kInterpreterBytecodeArrayRegister,
+  __ Ld(kInterpreterBytecodeArrayRegister,
         FieldMemOperand(a0, SharedFunctionInfo::kFunctionDataOffset));
   __ bind(&bytecode_array_loaded);
 
   // Check whether we should continue to use the interpreter.
   // TODO(rmcilroy) Remove self healing once liveedit only has to deal with
   // Ignition bytecode.
   Label switch_to_different_code_kind;
-  __ ld(a0, FieldMemOperand(a0, SharedFunctionInfo::kCodeOffset));
+  __ Ld(a0, FieldMemOperand(a0, SharedFunctionInfo::kCodeOffset));
   __ Branch(&switch_to_different_code_kind, ne, a0,
             Operand(masm->CodeObject()));  // Self-reference to this code.
 
   // Increment invocation count for the function.
-  __ ld(a0, FieldMemOperand(a1, JSFunction::kFeedbackVectorOffset));
-  __ ld(a0, FieldMemOperand(a0, Cell::kValueOffset));
-  __ ld(a4, FieldMemOperand(
+  __ Ld(a0, FieldMemOperand(a1, JSFunction::kFeedbackVectorOffset));
+  __ Ld(a0, FieldMemOperand(a0, Cell::kValueOffset));
+  __ Ld(a4, FieldMemOperand(
                 a0, FeedbackVector::kInvocationCountIndex * kPointerSize +
                         FeedbackVector::kHeaderSize));
   __ Daddu(a4, a4, Operand(Smi::FromInt(1)));
-  __ sd(a4, FieldMemOperand(
+  __ Sd(a4, FieldMemOperand(
                 a0, FeedbackVector::kInvocationCountIndex * kPointerSize +
                         FeedbackVector::kHeaderSize));
 
   // Check function data field is actually a BytecodeArray object.
   if (FLAG_debug_code) {
     __ SmiTst(kInterpreterBytecodeArrayRegister, a4);
     __ Assert(ne, kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry, a4,
               Operand(zero_reg));
     __ GetObjectType(kInterpreterBytecodeArrayRegister, a4, a4);
     __ Assert(eq, kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry, a4,
               Operand(BYTECODE_ARRAY_TYPE));
   }
 
   // Reset code age.
   DCHECK_EQ(0, BytecodeArray::kNoAgeBytecodeAge);
   __ sb(zero_reg, FieldMemOperand(kInterpreterBytecodeArrayRegister,
                                   BytecodeArray::kBytecodeAgeOffset));
 
   // Load initial bytecode offset.
   __ li(kInterpreterBytecodeOffsetRegister,
         Operand(BytecodeArray::kHeaderSize - kHeapObjectTag));
 
   // Push new.target, bytecode array and Smi tagged bytecode array offset.
   __ SmiTag(a4, kInterpreterBytecodeOffsetRegister);
   __ Push(a3, kInterpreterBytecodeArrayRegister, a4);
 
   // Allocate the local and temporary register file on the stack.
   {
     // Load frame size (word) from the BytecodeArray object.
-    __ lw(a4, FieldMemOperand(kInterpreterBytecodeArrayRegister,
+    __ Lw(a4, FieldMemOperand(kInterpreterBytecodeArrayRegister,
                               BytecodeArray::kFrameSizeOffset));
 
     // Do a stack check to ensure we don't go over the limit.
     Label ok;
     __ Dsubu(a5, sp, Operand(a4));
     __ LoadRoot(a2, Heap::kRealStackLimitRootIndex);
     __ Branch(&ok, hs, a5, Operand(a2));
     __ CallRuntime(Runtime::kThrowStackOverflow);
     __ bind(&ok);
 
@@ skipping 13 matching lines @@
 
   // Load accumulator and dispatch table into registers.
   __ LoadRoot(kInterpreterAccumulatorRegister, Heap::kUndefinedValueRootIndex);
   __ li(kInterpreterDispatchTableRegister,
         Operand(ExternalReference::interpreter_dispatch_table_address(
             masm->isolate())));
 
   // Dispatch to the first bytecode handler for the function.
   __ Daddu(a0, kInterpreterBytecodeArrayRegister,
            kInterpreterBytecodeOffsetRegister);
-  __ lbu(a0, MemOperand(a0));
+  __ Lbu(a0, MemOperand(a0));
   __ Dlsa(at, kInterpreterDispatchTableRegister, a0, kPointerSizeLog2);
-  __ ld(at, MemOperand(at));
+  __ Ld(at, MemOperand(at));
   __ Call(at);
   masm->isolate()->heap()->SetInterpreterEntryReturnPCOffset(masm->pc_offset());
 
   // The return value is in v0.
   LeaveInterpreterFrame(masm, t0);
   __ Jump(ra);
 
   // Load debug copy of the bytecode array.
   __ bind(&load_debug_bytecode_array);
-  __ ld(kInterpreterBytecodeArrayRegister,
+  __ Ld(kInterpreterBytecodeArrayRegister,
         FieldMemOperand(debug_info, DebugInfo::kDebugBytecodeArrayIndex));
   __ Branch(&bytecode_array_loaded);
 
   // If the shared code is no longer this entry trampoline, then the underlying
   // function has been switched to a different kind of code and we heal the
   // closure by switching the code entry field over to the new code as well.
   __ bind(&switch_to_different_code_kind);
   __ LeaveFrame(StackFrame::JAVA_SCRIPT);
-  __ ld(a4, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
-  __ ld(a4, FieldMemOperand(a4, SharedFunctionInfo::kCodeOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(a4, FieldMemOperand(a4, SharedFunctionInfo::kCodeOffset));
   __ Daddu(a4, a4, Operand(Code::kHeaderSize - kHeapObjectTag));
-  __ sd(a4, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
+  __ Sd(a4, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
   __ RecordWriteCodeEntryField(a1, a4, a5);
   __ Jump(a4);
 }
 
 static void Generate_StackOverflowCheck(MacroAssembler* masm, Register num_args,
                                         Register scratch1, Register scratch2,
                                         Label* stack_overflow) {
   // Check the stack for overflow. We are not trying to catch
   // interruptions (e.g. debug break and preemption) here, so the "real stack
   // limit" is checked.
@@ skipping 12 matching lines @@
                                          Register scratch, Register scratch2) {
   // Find the address of the last argument.
   __ mov(scratch2, num_args);
   __ dsll(scratch2, scratch2, kPointerSizeLog2);
   __ Dsubu(scratch2, index, Operand(scratch2));
 
   // Push the arguments.
   Label loop_header, loop_check;
   __ Branch(&loop_check);
   __ bind(&loop_header);
-  __ ld(scratch, MemOperand(index));
+  __ Ld(scratch, MemOperand(index));
   __ Daddu(index, index, Operand(-kPointerSize));
   __ push(scratch);
   __ bind(&loop_check);
   __ Branch(&loop_header, gt, index, Operand(scratch2));
 }
 
 // static
 void Builtins::Generate_InterpreterPushArgsThenCallImpl(
     MacroAssembler* masm, ConvertReceiverMode receiver_mode,
     TailCallMode tail_call_mode, InterpreterPushArgsMode mode) {
@@ skipping 60 matching lines @@
 
   // This function modifies t0, a4 and a5.
   Generate_InterpreterPushArgs(masm, a0, a4, a5, t0);
 
   __ AssertUndefinedOrAllocationSite(a2, t0);
   if (mode == InterpreterPushArgsMode::kJSFunction) {
     __ AssertFunction(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);
   } else if (mode == InterpreterPushArgsMode::kWithFinalSpread) {
     // Call the constructor with a0, a1, and a3 unmodified.
     __ Jump(masm->isolate()->builtins()->ConstructWithSpread(),
             RelocInfo::CODE_TARGET);
   } else {
     DCHECK_EQ(InterpreterPushArgsMode::kOther, mode);
     // Call the constructor with a0, a1, and a3 unmodified.
     __ Jump(masm->isolate()->builtins()->Construct(), RelocInfo::CODE_TARGET);
@@ skipping 51 matching lines @@
   __ li(t0, Operand(masm->isolate()->builtins()->InterpreterEntryTrampoline()));
   __ Daddu(ra, t0, Operand(interpreter_entry_return_pc_offset->value() +
                            Code::kHeaderSize - kHeapObjectTag));
 
   // Initialize the dispatch table register.
   __ li(kInterpreterDispatchTableRegister,
         Operand(ExternalReference::interpreter_dispatch_table_address(
             masm->isolate())));
 
   // Get the bytecode array pointer from the frame.
-  __ ld(kInterpreterBytecodeArrayRegister,
+  __ Ld(kInterpreterBytecodeArrayRegister,
         MemOperand(fp, InterpreterFrameConstants::kBytecodeArrayFromFp));
 
   if (FLAG_debug_code) {
     // Check function data field is actually a BytecodeArray object.
     __ SmiTst(kInterpreterBytecodeArrayRegister, at);
     __ Assert(ne, kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry, at,
               Operand(zero_reg));
     __ GetObjectType(kInterpreterBytecodeArrayRegister, a1, a1);
     __ Assert(eq, kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry, a1,
               Operand(BYTECODE_ARRAY_TYPE));
   }
 
   // Get the target bytecode offset from the frame.
-  __ lw(
+  __ Lw(
       kInterpreterBytecodeOffsetRegister,
       UntagSmiMemOperand(fp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
 
   // Dispatch to the target bytecode.
   __ Daddu(a1, kInterpreterBytecodeArrayRegister,
            kInterpreterBytecodeOffsetRegister);
-  __ lbu(a1, MemOperand(a1));
+  __ Lbu(a1, MemOperand(a1));
   __ Dlsa(a1, kInterpreterDispatchTableRegister, a1, kPointerSizeLog2);
-  __ ld(a1, MemOperand(a1));
+  __ Ld(a1, MemOperand(a1));
   __ Jump(a1);
 }
 
 void Builtins::Generate_InterpreterEnterBytecodeAdvance(MacroAssembler* masm) {
   // Advance the current bytecode offset stored within the given interpreter
   // stack frame. This simulates what all bytecode handlers do upon completion
   // of the underlying operation.
-  __ ld(a1, MemOperand(fp, InterpreterFrameConstants::kBytecodeArrayFromFp));
-  __ ld(a2, MemOperand(fp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
-  __ ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  __ Ld(a1, MemOperand(fp, InterpreterFrameConstants::kBytecodeArrayFromFp));
+  __ Ld(a2, MemOperand(fp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
+  __ Ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(kInterpreterAccumulatorRegister, a1, a2);
     __ CallRuntime(Runtime::kInterpreterAdvanceBytecodeOffset);
     __ mov(a2, v0);  // Result is the new bytecode offset.
     __ Pop(kInterpreterAccumulatorRegister);
   }
-  __ sd(a2, MemOperand(fp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
+  __ Sd(a2, MemOperand(fp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
 
   Generate_InterpreterEnterBytecode(masm);
 }
 
 void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler* masm) {
   Generate_InterpreterEnterBytecode(masm);
 }
 
 void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0 : argument count (preserved for callee)
   //  -- a3 : new target (preserved for callee)
   //  -- a1 : target function (preserved for callee)
   // -----------------------------------
   // First lookup code, maybe we don't need to compile!
   Label gotta_call_runtime, gotta_call_runtime_no_stack;
   Label try_shared;
   Label loop_top, loop_bottom;
 
   Register argument_count = a0;
   Register closure = a1;
   Register new_target = a3;
   Register map = a0;
   Register index = a2;
 
   // Do we have a valid feedback vector?
-  __ ld(index, FieldMemOperand(closure, JSFunction::kFeedbackVectorOffset));
-  __ ld(index, FieldMemOperand(index, Cell::kValueOffset));
+  __ Ld(index, FieldMemOperand(closure, JSFunction::kFeedbackVectorOffset));
+  __ Ld(index, FieldMemOperand(index, Cell::kValueOffset));
   __ JumpIfRoot(index, Heap::kUndefinedValueRootIndex,
                 &gotta_call_runtime_no_stack);
 
   __ push(argument_count);
   __ push(new_target);
   __ push(closure);
 
-  __ ld(map, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
-  __ ld(map, FieldMemOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
-  __ ld(index, FieldMemOperand(map, FixedArray::kLengthOffset));
+  __ Ld(map, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(map, FieldMemOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
+  __ Ld(index, FieldMemOperand(map, FixedArray::kLengthOffset));
   __ Branch(&try_shared, lt, index, Operand(Smi::FromInt(2)));
 
   // a3  : native context
   // a2  : length / index
   // a0  : optimized code map
   // stack[0] : new target
   // stack[4] : closure
   Register native_context = a3;
-  __ ld(native_context, NativeContextMemOperand());
+  __ Ld(native_context, NativeContextMemOperand());
 
   __ bind(&loop_top);
   Register temp = a1;
   Register array_pointer = a5;
 
   // Does the native context match?
   __ SmiScale(at, index, kPointerSizeLog2);
   __ Daddu(array_pointer, map, Operand(at));
-  __ ld(temp, FieldMemOperand(array_pointer,
+  __ Ld(temp, FieldMemOperand(array_pointer,
                               SharedFunctionInfo::kOffsetToPreviousContext));
-  __ ld(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
+  __ Ld(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
   __ Branch(&loop_bottom, ne, temp, Operand(native_context));
 
   // Code available?
   Register entry = a4;
-  __ ld(entry,
+  __ Ld(entry,
         FieldMemOperand(array_pointer,
                         SharedFunctionInfo::kOffsetToPreviousCachedCode));
-  __ ld(entry, FieldMemOperand(entry, WeakCell::kValueOffset));
+  __ Ld(entry, FieldMemOperand(entry, WeakCell::kValueOffset));
   __ JumpIfSmi(entry, &try_shared);
 
   // Found code. Get it into the closure and return.
   __ pop(closure);
   // Store code entry in the closure.
   __ Daddu(entry, entry, Operand(Code::kHeaderSize - kHeapObjectTag));
-  __ sd(entry, FieldMemOperand(closure, JSFunction::kCodeEntryOffset));
+  __ Sd(entry, FieldMemOperand(closure, JSFunction::kCodeEntryOffset));
   __ RecordWriteCodeEntryField(closure, entry, a5);
 
   // Link the closure into the optimized function list.
   // a4 : code entry
   // a3 : native context
   // a1 : closure
-  __ ld(a5,
+  __ Ld(a5,
         ContextMemOperand(native_context, Context::OPTIMIZED_FUNCTIONS_LIST));
-  __ sd(a5, FieldMemOperand(closure, JSFunction::kNextFunctionLinkOffset));
+  __ Sd(a5, FieldMemOperand(closure, JSFunction::kNextFunctionLinkOffset));
   __ RecordWriteField(closure, JSFunction::kNextFunctionLinkOffset, a5, a0,
                       kRAHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
                       OMIT_SMI_CHECK);
   const int function_list_offset =
       Context::SlotOffset(Context::OPTIMIZED_FUNCTIONS_LIST);
-  __ sd(closure,
+  __ Sd(closure,
         ContextMemOperand(native_context, Context::OPTIMIZED_FUNCTIONS_LIST));
   // Save closure before the write barrier.
   __ mov(a5, closure);
   __ RecordWriteContextSlot(native_context, function_list_offset, closure, a0,
                             kRAHasNotBeenSaved, kDontSaveFPRegs);
   __ mov(closure, a5);
   __ pop(new_target);
   __ pop(argument_count);
   __ Jump(entry);
 
   __ bind(&loop_bottom);
   __ Dsubu(index, index,
            Operand(Smi::FromInt(SharedFunctionInfo::kEntryLength)));
   __ Branch(&loop_top, gt, index, Operand(Smi::FromInt(1)));
 
   // We found no code.
   __ bind(&try_shared);
   __ pop(closure);
   __ pop(new_target);
   __ pop(argument_count);
-  __ ld(entry, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(entry, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
   // Is the shared function marked for tier up?
-  __ lbu(a5, FieldMemOperand(entry,
+  __ Lbu(a5, FieldMemOperand(entry,
                              SharedFunctionInfo::kMarkedForTierUpByteOffset));
   __ And(a5, a5,
          Operand(1 << SharedFunctionInfo::kMarkedForTierUpBitWithinByte));
   __ Branch(&gotta_call_runtime_no_stack, ne, a5, Operand(zero_reg));
 
   // If SFI points to anything other than CompileLazy, install that.
-  __ ld(entry, FieldMemOperand(entry, SharedFunctionInfo::kCodeOffset));
+  __ Ld(entry, FieldMemOperand(entry, SharedFunctionInfo::kCodeOffset));
   __ Move(t1, masm->CodeObject());
   __ Branch(&gotta_call_runtime_no_stack, eq, entry, Operand(t1));
 
   // Install the SFI's code entry.
   __ Daddu(entry, entry, Operand(Code::kHeaderSize - kHeapObjectTag));
-  __ sd(entry, FieldMemOperand(closure, JSFunction::kCodeEntryOffset));
+  __ Sd(entry, FieldMemOperand(closure, JSFunction::kCodeEntryOffset));
   __ RecordWriteCodeEntryField(closure, entry, a5);
   __ Jump(entry);
 
   __ bind(&gotta_call_runtime);
   __ pop(closure);
   __ pop(new_target);
   __ pop(argument_count);
   __ bind(&gotta_call_runtime_no_stack);
   GenerateTailCallToReturnedCode(masm, Runtime::kCompileLazy);
 }
@@ skipping 23 matching lines @@
     __ Push(a0, a1, a3, a1);
 
     // Copy arguments from caller (stdlib, foreign, heap).
     Label args_done;
     for (int j = 0; j < 4; ++j) {
       Label over;
       if (j < 3) {
         __ Branch(&over, ne, t2, Operand(j));
       }
       for (int i = j - 1; i >= 0; --i) {
-        __ ld(t2, MemOperand(fp, StandardFrameConstants::kCallerSPOffset +
+        __ Ld(t2, MemOperand(fp, StandardFrameConstants::kCallerSPOffset +
                                      i * kPointerSize));
         __ push(t2);
       }
       for (int i = 0; i < 3 - j; ++i) {
         __ PushRoot(Heap::kUndefinedValueRootIndex);
       }
       if (j < 3) {
         __ jmp(&args_done);
         __ bind(&over);
       }
@@ skipping 128 matching lines @@
                                              Deoptimizer::BailoutType type) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     // Pass the function and deoptimization type to the runtime system.
     __ li(a0, Operand(Smi::FromInt(static_cast<int>(type))));
     __ push(a0);
     __ CallRuntime(Runtime::kNotifyDeoptimized);
   }
 
   // Get the full codegen state from the stack and untag it -> a6.
-  __ lw(a6, UntagSmiMemOperand(sp, 0 * kPointerSize));
+  __ Lw(a6, UntagSmiMemOperand(sp, 0 * kPointerSize));
   // Switch on the state.
   Label with_tos_register, unknown_state;
   __ Branch(
       &with_tos_register, ne, a6,
       Operand(static_cast<int64_t>(Deoptimizer::BailoutState::NO_REGISTERS)));
   __ Ret(USE_DELAY_SLOT);
   // Safe to fill delay slot Addu will emit one instruction.
   __ Daddu(sp, sp, Operand(1 * kPointerSize));  // Remove state.
 
   __ bind(&with_tos_register);
   DCHECK_EQ(kInterpreterAccumulatorRegister.code(), v0.code());
-  __ ld(v0, MemOperand(sp, 1 * kPointerSize));
+  __ Ld(v0, MemOperand(sp, 1 * kPointerSize));
   __ Branch(
       &unknown_state, ne, a6,
       Operand(static_cast<int64_t>(Deoptimizer::BailoutState::TOS_REGISTER)));
 
   __ Ret(USE_DELAY_SLOT);
   // Safe to fill delay slot Addu will emit one instruction.
   __ Daddu(sp, sp, Operand(2 * kPointerSize));  // Remove state.
 
   __ bind(&unknown_state);
   __ stop("no cases left");
 }
 
 void Builtins::Generate_NotifyDeoptimized(MacroAssembler* masm) {
   Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::EAGER);
 }
 
 void Builtins::Generate_NotifySoftDeoptimized(MacroAssembler* masm) {
   Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::SOFT);
 }
 
 void Builtins::Generate_NotifyLazyDeoptimized(MacroAssembler* masm) {
   Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::LAZY);
 }
 
 static void Generate_OnStackReplacementHelper(MacroAssembler* masm,
                                               bool has_handler_frame) {
   // Lookup the function in the JavaScript frame.
   if (has_handler_frame) {
-    __ ld(a0, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-    __ ld(a0, MemOperand(a0, JavaScriptFrameConstants::kFunctionOffset));
+    __ Ld(a0, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+    __ Ld(a0, MemOperand(a0, JavaScriptFrameConstants::kFunctionOffset));
   } else {
-    __ ld(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+    __ Ld(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   }
 
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     // Pass function as argument.
     __ push(a0);
     __ CallRuntime(Runtime::kCompileForOnStackReplacement);
   }
 
   // If the code object is null, just return to the caller.
   __ Ret(eq, v0, Operand(Smi::kZero));
 
   // Drop any potential handler frame that is be sitting on top of the actual
   // JavaScript frame. This is the case then OSR is triggered from bytecode.
   if (has_handler_frame) {
     __ LeaveFrame(StackFrame::STUB);
   }
 
   // Load deoptimization data from the code object.
   // <deopt_data> = <code>[#deoptimization_data_offset]
-  __ ld(a1, MemOperand(v0, Code::kDeoptimizationDataOffset - kHeapObjectTag));
+  __ Ld(a1, MemOperand(v0, Code::kDeoptimizationDataOffset - kHeapObjectTag));
 
   // Load the OSR entrypoint offset from the deoptimization data.
   // <osr_offset> = <deopt_data>[#header_size + #osr_pc_offset]
-  __ lw(a1,
+  __ Lw(a1,
         UntagSmiMemOperand(a1, FixedArray::OffsetOfElementAt(
                                    DeoptimizationInputData::kOsrPcOffsetIndex) -
                                    kHeapObjectTag));
 
   // Compute the target address = code_obj + header_size + osr_offset
   // <entry_addr> = <code_obj> + #header_size + <osr_offset>
   __ daddu(v0, v0, a1);
   __ daddiu(ra, v0, Code::kHeaderSize - kHeapObjectTag);
 
   // And "return" to the OSR entry point of the function.
@@ skipping 33 matching lines @@
     // consistent state for a simple pop operation.
 
     __ Dsubu(sp, sp, Operand(2 * kPointerSize));
     __ Dlsa(sp, sp, argc, kPointerSizeLog2);
     __ mov(scratch, argc);
     __ Pop(this_arg, arg_array);                   // Overwrite argc
     __ Movz(arg_array, undefined_value, scratch);  // if argc == 0
     __ Movz(this_arg, undefined_value, scratch);   // if argc == 0
     __ Dsubu(scratch, scratch, Operand(1));
     __ Movz(arg_array, undefined_value, scratch);  // if argc == 1
-    __ ld(receiver, MemOperand(sp));
-    __ sd(this_arg, MemOperand(sp));
+    __ Ld(receiver, MemOperand(sp));
+    __ Sd(this_arg, MemOperand(sp));
   }
 
   // ----------- S t a t e -------------
   //  -- a0    : argArray
   //  -- a1    : receiver
   //  -- a3    : undefined root value
   //  -- sp[0] : thisArg
   // -----------------------------------
 
   // 2. Make sure the receiver is actually callable.
   Label receiver_not_callable;
   __ JumpIfSmi(receiver, &receiver_not_callable);
-  __ ld(a4, FieldMemOperand(receiver, HeapObject::kMapOffset));
-  __ lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
+  __ Ld(a4, FieldMemOperand(receiver, HeapObject::kMapOffset));
+  __ Lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
   __ And(a4, a4, Operand(1 << Map::kIsCallable));
   __ Branch(&receiver_not_callable, eq, a4, Operand(zero_reg));
 
   // 3. Tail call with no arguments if argArray is null or undefined.
   Label no_arguments;
   __ JumpIfRoot(arg_array, Heap::kNullValueRootIndex, &no_arguments);
   __ Branch(&no_arguments, eq, arg_array, Operand(undefined_value));
 
   // 4a. Apply the receiver to the given argArray (passing undefined for
   // new.target).
   DCHECK(undefined_value.is(a3));
   __ Jump(masm->isolate()->builtins()->Apply(), RelocInfo::CODE_TARGET);
 
   // 4b. The argArray is either null or undefined, so we tail call without any
   // arguments to the receiver.
   __ bind(&no_arguments);
   {
     __ mov(a0, zero_reg);
     DCHECK(receiver.is(a1));
     __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
   }
 
   // 4c. The receiver is not callable, throw an appropriate TypeError.
   __ bind(&receiver_not_callable);
   {
-    __ sd(receiver, MemOperand(sp));
+    __ Sd(receiver, MemOperand(sp));
     __ TailCallRuntime(Runtime::kThrowApplyNonFunction);
   }
 }
 
 // static
 void Builtins::Generate_FunctionPrototypeCall(MacroAssembler* masm) {
   // 1. Make sure we have at least one argument.
   // a0: actual number of arguments
   {
     Label done;
     __ Branch(&done, ne, a0, Operand(zero_reg));
     __ PushRoot(Heap::kUndefinedValueRootIndex);
     __ Daddu(a0, a0, Operand(1));
     __ bind(&done);
   }
 
   // 2. Get the function to call (passed as receiver) from the stack.
   // a0: actual number of arguments
   __ Dlsa(at, sp, a0, kPointerSizeLog2);
-  __ ld(a1, MemOperand(at));
+  __ Ld(a1, MemOperand(at));
 
   // 3. Shift arguments and return address one slot down on the stack
   //    (overwriting the original receiver).  Adjust argument count to make
   //    the original first argument the new receiver.
   // a0: actual number of arguments
   // a1: function
   {
     Label loop;
     // Calculate the copy start address (destination). Copy end address is sp.
     __ Dlsa(a2, sp, a0, kPointerSizeLog2);
 
     __ bind(&loop);
-    __ ld(at, MemOperand(a2, -kPointerSize));
-    __ sd(at, MemOperand(a2));
+    __ Ld(at, MemOperand(a2, -kPointerSize));
+    __ Sd(at, MemOperand(a2));
     __ Dsubu(a2, a2, Operand(kPointerSize));
     __ Branch(&loop, ne, a2, Operand(sp));
     // Adjust the actual number of arguments and remove the top element
     // (which is a copy of the last argument).
     __ Dsubu(a0, a0, Operand(1));
     __ Pop();
   }
 
   // 4. Call the callable.
   __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
@@ skipping 29 matching lines @@
     __ Pop(target, this_argument, arguments_list);
     __ Movz(arguments_list, undefined_value, scratch);  // if argc == 0
     __ Movz(this_argument, undefined_value, scratch);   // if argc == 0
     __ Movz(target, undefined_value, scratch);          // if argc == 0
     __ Dsubu(scratch, scratch, Operand(1));
     __ Movz(arguments_list, undefined_value, scratch);  // if argc == 1
     __ Movz(this_argument, undefined_value, scratch);   // if argc == 1
     __ Dsubu(scratch, scratch, Operand(1));
     __ Movz(arguments_list, undefined_value, scratch);  // if argc == 2
 
-    __ sd(this_argument, MemOperand(sp, 0));  // Overwrite receiver
+    __ Sd(this_argument, MemOperand(sp, 0));  // Overwrite receiver
   }
 
   // ----------- S t a t e -------------
   //  -- a0    : argumentsList
   //  -- a1    : target
   //  -- a3    : undefined root value
   //  -- sp[0] : thisArgument
   // -----------------------------------
 
   // 2. Make sure the target is actually callable.
   Label target_not_callable;
   __ JumpIfSmi(target, &target_not_callable);
-  __ ld(a4, FieldMemOperand(target, HeapObject::kMapOffset));
-  __ lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
+  __ Ld(a4, FieldMemOperand(target, HeapObject::kMapOffset));
+  __ Lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
   __ And(a4, a4, Operand(1 << Map::kIsCallable));
   __ Branch(&target_not_callable, eq, a4, Operand(zero_reg));
 
   // 3a. Apply the target to the given argumentsList (passing undefined for
   // new.target).
   DCHECK(undefined_value.is(a3));
   __ Jump(masm->isolate()->builtins()->Apply(), RelocInfo::CODE_TARGET);
 
   // 3b. The target is not callable, throw an appropriate TypeError.
   __ bind(&target_not_callable);
   {
-    __ sd(target, MemOperand(sp));
+    __ Sd(target, MemOperand(sp));
     __ TailCallRuntime(Runtime::kThrowApplyNonFunction);
   }
 }
 
 void Builtins::Generate_ReflectConstruct(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0     : argc
   //  -- sp[0]  : new.target (optional) (dummy value if argc <= 2)
   //  -- sp[4]  : argumentsList         (dummy value if argc <= 1)
   //  -- sp[8]  : target                (dummy value if argc == 0)
@@ skipping 20 matching lines @@
     __ Pop(target, arguments_list, new_target);
     __ Movz(arguments_list, undefined_value, scratch);  // if argc == 0
     __ Movz(new_target, undefined_value, scratch);      // if argc == 0
     __ Movz(target, undefined_value, scratch);          // if argc == 0
     __ Dsubu(scratch, scratch, Operand(1));
     __ Movz(arguments_list, undefined_value, scratch);  // if argc == 1
     __ Movz(new_target, target, scratch);               // if argc == 1
     __ Dsubu(scratch, scratch, Operand(1));
     __ Movz(new_target, target, scratch);  // if argc == 2
 
-    __ sd(undefined_value, MemOperand(sp, 0));  // Overwrite receiver
+    __ Sd(undefined_value, MemOperand(sp, 0));  // Overwrite receiver
   }
 
   // ----------- S t a t e -------------
   //  -- a0    : argumentsList
   //  -- a1    : target
   //  -- a3    : new.target
   //  -- sp[0] : receiver (undefined)
   // -----------------------------------
 
   // 2. Make sure the target is actually a constructor.
   Label target_not_constructor;
   __ JumpIfSmi(target, &target_not_constructor);
-  __ ld(a4, FieldMemOperand(target, HeapObject::kMapOffset));
-  __ lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
+  __ Ld(a4, FieldMemOperand(target, HeapObject::kMapOffset));
+  __ Lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
   __ And(a4, a4, Operand(1 << Map::kIsConstructor));
   __ Branch(&target_not_constructor, eq, a4, Operand(zero_reg));
 
   // 3. Make sure the target is actually a constructor.
   Label new_target_not_constructor;
   __ JumpIfSmi(new_target, &new_target_not_constructor);
-  __ ld(a4, FieldMemOperand(new_target, HeapObject::kMapOffset));
-  __ lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
+  __ Ld(a4, FieldMemOperand(new_target, HeapObject::kMapOffset));
+  __ Lbu(a4, FieldMemOperand(a4, Map::kBitFieldOffset));
   __ And(a4, a4, Operand(1 << Map::kIsConstructor));
   __ Branch(&new_target_not_constructor, eq, a4, Operand(zero_reg));
 
   // 4a. Construct the target with the given new.target and argumentsList.
   __ Jump(masm->isolate()->builtins()->Apply(), RelocInfo::CODE_TARGET);
 
   // 4b. The target is not a constructor, throw an appropriate TypeError.
   __ bind(&target_not_constructor);
   {
-    __ sd(target, MemOperand(sp));
+    __ Sd(target, MemOperand(sp));
     __ TailCallRuntime(Runtime::kThrowNotConstructor);
   }
 
   // 4c. The new.target is not a constructor, throw an appropriate TypeError.
   __ bind(&new_target_not_constructor);
   {
-    __ sd(new_target, MemOperand(sp));
+    __ Sd(new_target, MemOperand(sp));
     __ TailCallRuntime(Runtime::kThrowNotConstructor);
   }
 }
 
 static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) {
   // __ sll(a0, a0, kSmiTagSize);
   __ dsll32(a0, a0, 0);
   __ li(a4, Operand(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)));
   __ MultiPush(a0.bit() | a1.bit() | a4.bit() | fp.bit() | ra.bit());
   __ Daddu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
                            kPointerSize));
 }
 
 static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- v0 : result being passed through
   // -----------------------------------
   // Get the number of arguments passed (as a smi), tear down the frame and
   // then tear down the parameters.
-  __ ld(a1, MemOperand(fp, -(StandardFrameConstants::kFixedFrameSizeFromFp +
+  __ Ld(a1, MemOperand(fp, -(StandardFrameConstants::kFixedFrameSizeFromFp +
                              kPointerSize)));
   __ mov(sp, fp);
   __ MultiPop(fp.bit() | ra.bit());
   __ SmiScale(a4, a1, kPointerSizeLog2);
   __ Daddu(sp, sp, a4);
   // Adjust for the receiver.
   __ Daddu(sp, sp, Operand(kPointerSize));
 }
 
 // static
@@ skipping 13 matching lines @@
   Register len = a2;
 
   // Create the list of arguments from the array-like argumentsList.
   {
     Label create_arguments, create_array, create_holey_array, create_runtime,
         done_create;
     __ JumpIfSmi(arguments_list, &create_runtime);
 
     // Load the map of argumentsList into a2.
     Register arguments_list_map = a2;
-    __ ld(arguments_list_map,
+    __ Ld(arguments_list_map,
           FieldMemOperand(arguments_list, HeapObject::kMapOffset));
 
     // Load native context into a4.
     Register native_context = a4;
-    __ ld(native_context, NativeContextMemOperand());
+    __ Ld(native_context, NativeContextMemOperand());
 
     // Check if argumentsList is an (unmodified) arguments object.
-    __ ld(at, ContextMemOperand(native_context,
+    __ Ld(at, ContextMemOperand(native_context,
                                 Context::SLOPPY_ARGUMENTS_MAP_INDEX));
     __ Branch(&create_arguments, eq, arguments_list_map, Operand(at));
-    __ ld(at, ContextMemOperand(native_context,
+    __ Ld(at, ContextMemOperand(native_context,
                                 Context::STRICT_ARGUMENTS_MAP_INDEX));
     __ Branch(&create_arguments, eq, arguments_list_map, Operand(at));
 
     // Check if argumentsList is a fast JSArray.
-    __ lbu(v0, FieldMemOperand(a2, Map::kInstanceTypeOffset));
+    __ Lbu(v0, FieldMemOperand(a2, Map::kInstanceTypeOffset));
     __ Branch(&create_array, eq, v0, Operand(JS_ARRAY_TYPE));
 
     // Ask the runtime to create the list (actually a FixedArray).
     __ bind(&create_runtime);
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ Push(target, new_target, arguments_list);
       __ CallRuntime(Runtime::kCreateListFromArrayLike);
       __ mov(arguments_list, v0);
       __ Pop(target, new_target);
-      __ lw(len, UntagSmiFieldMemOperand(v0, FixedArray::kLengthOffset));
+      __ Lw(len, UntagSmiFieldMemOperand(v0, FixedArray::kLengthOffset));
     }
     __ Branch(&done_create);
 
     // Try to create the list from an arguments object.
     __ bind(&create_arguments);
-    __ lw(len, UntagSmiFieldMemOperand(arguments_list,
+    __ Lw(len, UntagSmiFieldMemOperand(arguments_list,
                                        JSArgumentsObject::kLengthOffset));
-    __ ld(a4, FieldMemOperand(arguments_list, JSObject::kElementsOffset));
-    __ lw(at, UntagSmiFieldMemOperand(a4, FixedArray::kLengthOffset));
+    __ Ld(a4, FieldMemOperand(arguments_list, JSObject::kElementsOffset));
+    __ Lw(at, UntagSmiFieldMemOperand(a4, FixedArray::kLengthOffset));
     __ Branch(&create_runtime, ne, len, Operand(at));
     __ mov(args, a4);
 
     __ Branch(&done_create);
 
     // For holey JSArrays we need to check that the array prototype chain
     // protector is intact and our prototype is the Array.prototype actually.
     __ bind(&create_holey_array);
-    __ ld(a2, FieldMemOperand(a2, Map::kPrototypeOffset));
-    __ ld(at, ContextMemOperand(native_context,
+    __ Ld(a2, FieldMemOperand(a2, Map::kPrototypeOffset));
+    __ Ld(at, ContextMemOperand(native_context,
                                 Context::INITIAL_ARRAY_PROTOTYPE_INDEX));
     __ Branch(&create_runtime, ne, a2, Operand(at));
     __ LoadRoot(at, Heap::kArrayProtectorRootIndex);
-    __ lw(a2, FieldMemOperand(at, PropertyCell::kValueOffset));
+    __ Lw(a2, FieldMemOperand(at, PropertyCell::kValueOffset));
     __ Branch(&create_runtime, ne, a2,
               Operand(Smi::FromInt(Isolate::kProtectorValid)));
-    __ lw(a2, UntagSmiFieldMemOperand(a0, JSArray::kLengthOffset));
-    __ ld(a0, FieldMemOperand(a0, JSArray::kElementsOffset));
+    __ Lw(a2, UntagSmiFieldMemOperand(a0, JSArray::kLengthOffset));
+    __ Ld(a0, FieldMemOperand(a0, JSArray::kElementsOffset));
     __ Branch(&done_create);
 
     // Try to create the list from a JSArray object.
     __ bind(&create_array);
-    __ lbu(t1, FieldMemOperand(a2, Map::kBitField2Offset));
+    __ Lbu(t1, FieldMemOperand(a2, Map::kBitField2Offset));
     __ DecodeField<Map::ElementsKindBits>(t1);
     STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
     STATIC_ASSERT(FAST_ELEMENTS == 2);
     STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
     __ Branch(&create_holey_array, eq, t1, Operand(FAST_HOLEY_SMI_ELEMENTS));
     __ Branch(&create_holey_array, eq, t1, Operand(FAST_HOLEY_ELEMENTS));
     __ Branch(&create_runtime, hi, t1, Operand(FAST_ELEMENTS));
-    __ lw(a2, UntagSmiFieldMemOperand(arguments_list, JSArray::kLengthOffset));
-    __ ld(a0, FieldMemOperand(arguments_list, JSArray::kElementsOffset));
+    __ Lw(a2, UntagSmiFieldMemOperand(arguments_list, JSArray::kLengthOffset));
+    __ Ld(a0, FieldMemOperand(arguments_list, JSArray::kElementsOffset));
 
     __ bind(&done_create);
   }
 
   // Check for stack overflow.
   {
     // Check the stack for overflow. We are not trying to catch interruptions
     // (i.e. debug break and preemption) here, so check the "real stack limit".
     Label done;
     __ LoadRoot(a4, Heap::kRealStackLimitRootIndex);
@@ skipping 21 matching lines @@
     Register src = a4;
     Register scratch = len;
 
     __ daddiu(src, args, FixedArray::kHeaderSize - kHeapObjectTag);
     __ Branch(&done, eq, len, Operand(zero_reg), i::USE_DELAY_SLOT);
     __ mov(a0, len);  // The 'len' argument for Call() or Construct().
     __ dsll(scratch, len, kPointerSizeLog2);
     __ Dsubu(scratch, sp, Operand(scratch));
     __ LoadRoot(t1, Heap::kTheHoleValueRootIndex);
     __ bind(&loop);
-    __ ld(a5, MemOperand(src));
+    __ Ld(a5, MemOperand(src));
     __ Branch(&push, ne, a5, Operand(t1));
     __ LoadRoot(a5, Heap::kUndefinedValueRootIndex);
     __ bind(&push);
     __ daddiu(src, src, kPointerSize);
     __ Push(a5);
     __ Branch(&loop, ne, scratch, Operand(sp));
     __ bind(&done);
   }
 
   // ----------- S t a t e -------------
@@ skipping 23 matching lines @@
                                            Handle<Code> code) {
   // ----------- S t a t e -------------
   //  -- a1    : the target to call (can be any Object)
   //  -- a2    : start index (to support rest parameters)
   //  -- ra    : return address.
   //  -- sp[0] : thisArgument
   // -----------------------------------
 
   // Check if we have an arguments adaptor frame below the function frame.
   Label arguments_adaptor, arguments_done;
-  __ ld(a3, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-  __ ld(a0, MemOperand(a3, CommonFrameConstants::kContextOrFrameTypeOffset));
+  __ Ld(a3, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  __ Ld(a0, MemOperand(a3, CommonFrameConstants::kContextOrFrameTypeOffset));
   __ Branch(&arguments_adaptor, eq, a0,
             Operand(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)));
   {
-    __ ld(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
-    __ ld(a0, FieldMemOperand(a0, JSFunction::kSharedFunctionInfoOffset));
-    __ lw(a0,
+    __ Ld(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+    __ Ld(a0, FieldMemOperand(a0, JSFunction::kSharedFunctionInfoOffset));
+    __ Lw(a0,
           FieldMemOperand(a0, SharedFunctionInfo::kFormalParameterCountOffset));
     __ mov(a3, fp);
   }
   __ Branch(&arguments_done);
   __ bind(&arguments_adaptor);
   {
     // Just get the length from the ArgumentsAdaptorFrame.
-    __ lw(a0, UntagSmiMemOperand(
+    __ Lw(a0, UntagSmiMemOperand(
                   a3, ArgumentsAdaptorFrameConstants::kLengthOffset));
   }
   __ bind(&arguments_done);
 
   Label stack_empty, stack_done, stack_overflow;
   __ Subu(a0, a0, a2);
   __ Branch(&stack_empty, le, a0, Operand(zero_reg));
   {
     // Check for stack overflow.
     Generate_StackOverflowCheck(masm, a0, a4, a5, &stack_overflow);
 
     // Forward the arguments from the caller frame.
     {
       Label loop;
       __ mov(a2, a0);
       __ bind(&loop);
       {
         __ Dlsa(at, a3, a2, kPointerSizeLog2);
-        __ ld(at, MemOperand(at, 1 * kPointerSize));
+        __ Ld(at, MemOperand(at, 1 * kPointerSize));
         __ push(at);
         __ Subu(a2, a2, Operand(1));
         __ Branch(&loop, ne, a2, Operand(zero_reg));
       }
     }
   }
   __ Branch(&stack_done);
   __ bind(&stack_overflow);
   __ TailCallRuntime(Runtime::kThrowStackOverflow);
   __ bind(&stack_empty);
@@ skipping 40 matching lines @@
                         Register scratch3) {
   DCHECK(!AreAliased(args_reg, scratch1, scratch2, scratch3));
   Comment cmnt(masm, "[ PrepareForTailCall");
 
   // Prepare for tail call only if ES2015 tail call elimination is enabled.
   Label done;
   ExternalReference is_tail_call_elimination_enabled =
       ExternalReference::is_tail_call_elimination_enabled_address(
           masm->isolate());
   __ li(at, Operand(is_tail_call_elimination_enabled));
-  __ lb(scratch1, MemOperand(at));
+  __ Lb(scratch1, MemOperand(at));
   __ Branch(&done, eq, scratch1, Operand(zero_reg));
 
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
-    __ ld(scratch3,
+    __ Ld(scratch3,
           MemOperand(fp, CommonFrameConstants::kContextOrFrameTypeOffset));
     __ Branch(&no_interpreter_frame, ne, scratch3,
               Operand(StackFrame::TypeToMarker(StackFrame::STUB)));
-    __ ld(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+    __ Ld(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
     __ bind(&no_interpreter_frame);
   }
 
   // Check if next frame is an arguments adaptor frame.
   Register caller_args_count_reg = scratch1;
   Label no_arguments_adaptor, formal_parameter_count_loaded;
-  __ ld(scratch2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-  __ ld(scratch3,
+  __ Ld(scratch2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  __ Ld(scratch3,
         MemOperand(scratch2, CommonFrameConstants::kContextOrFrameTypeOffset));
   __ Branch(&no_arguments_adaptor, ne, scratch3,
             Operand(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)));
 
   // Drop current frame and load arguments count from arguments adaptor frame.
   __ mov(fp, scratch2);
-  __ lw(caller_args_count_reg,
+  __ Lw(caller_args_count_reg,
         UntagSmiMemOperand(fp, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ Branch(&formal_parameter_count_loaded);
 
   __ bind(&no_arguments_adaptor);
   // Load caller's formal parameter count
-  __ ld(scratch1,
+  __ Ld(scratch1,
         MemOperand(fp, ArgumentsAdaptorFrameConstants::kFunctionOffset));
-  __ ld(scratch1,
+  __ Ld(scratch1,
         FieldMemOperand(scratch1, JSFunction::kSharedFunctionInfoOffset));
-  __ lw(caller_args_count_reg,
+  __ Lw(caller_args_count_reg,
         FieldMemOperand(scratch1,
                         SharedFunctionInfo::kFormalParameterCountOffset));
 
   __ bind(&formal_parameter_count_loaded);
 
   ParameterCount callee_args_count(args_reg);
   __ PrepareForTailCall(callee_args_count, caller_args_count_reg, scratch2,
                         scratch3);
   __ bind(&done);
 }
 }  // namespace
 
 // static
 void Builtins::Generate_CallFunction(MacroAssembler* masm,
                                      ConvertReceiverMode mode,
                                      TailCallMode tail_call_mode) {
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the function to call (checked to be a JSFunction)
   // -----------------------------------
   __ AssertFunction(a1);
 
   // See ES6 section 9.2.1 [[Call]] ( thisArgument, argumentsList)
   // Check that function is not a "classConstructor".
   Label class_constructor;
-  __ ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
-  __ lbu(a3, FieldMemOperand(a2, SharedFunctionInfo::kFunctionKindByteOffset));
+  __ Ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
+  __ Lbu(a3, FieldMemOperand(a2, SharedFunctionInfo::kFunctionKindByteOffset));
   __ And(at, a3, Operand(SharedFunctionInfo::kClassConstructorBitsWithinByte));
   __ Branch(&class_constructor, ne, at, Operand(zero_reg));
 
   // Enter the context of the function; ToObject has to run in the function
   // context, and we also need to take the global proxy from the function
   // context in case of conversion.
   STATIC_ASSERT(SharedFunctionInfo::kNativeByteOffset ==
                 SharedFunctionInfo::kStrictModeByteOffset);
-  __ ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
+  __ Ld(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
   // We need to convert the receiver for non-native sloppy mode functions.
   Label done_convert;
-  __ lbu(a3, FieldMemOperand(a2, SharedFunctionInfo::kNativeByteOffset));
+  __ Lbu(a3, FieldMemOperand(a2, SharedFunctionInfo::kNativeByteOffset));
   __ And(at, a3, Operand((1 << SharedFunctionInfo::kNativeBitWithinByte) |
                          (1 << SharedFunctionInfo::kStrictModeBitWithinByte)));
   __ Branch(&done_convert, ne, at, Operand(zero_reg));
   {
     // ----------- S t a t e -------------
     //  -- a0 : the number of arguments (not including the receiver)
     //  -- a1 : the function to call (checked to be a JSFunction)
     //  -- a2 : the shared function info.
     //  -- cp : the function context.
     // -----------------------------------
 
     if (mode == ConvertReceiverMode::kNullOrUndefined) {
       // Patch receiver to global proxy.
       __ LoadGlobalProxy(a3);
     } else {
       Label convert_to_object, convert_receiver;
       __ Dlsa(at, sp, a0, kPointerSizeLog2);
-      __ ld(a3, MemOperand(at));
+      __ Ld(a3, MemOperand(at));
       __ JumpIfSmi(a3, &convert_to_object);
       STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
       __ GetObjectType(a3, a4, a4);
       __ Branch(&done_convert, hs, a4, Operand(FIRST_JS_RECEIVER_TYPE));
       if (mode != ConvertReceiverMode::kNotNullOrUndefined) {
         Label convert_global_proxy;
         __ JumpIfRoot(a3, Heap::kUndefinedValueRootIndex,
                       &convert_global_proxy);
         __ JumpIfNotRoot(a3, Heap::kNullValueRootIndex, &convert_to_object);
         __ bind(&convert_global_proxy);
@@ skipping 13 matching lines @@
         __ Push(a0, a1);
         __ mov(a0, a3);
         __ Push(cp);
         __ Call(masm->isolate()->builtins()->ToObject(),
                 RelocInfo::CODE_TARGET);
         __ Pop(cp);
         __ mov(a3, v0);
         __ Pop(a0, a1);
         __ SmiUntag(a0);
       }
-      __ ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
+      __ Ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
       __ bind(&convert_receiver);
     }
     __ Dlsa(at, sp, a0, kPointerSizeLog2);
-    __ sd(a3, MemOperand(at));
+    __ Sd(a3, MemOperand(at));
   }
   __ bind(&done_convert);
 
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the function to call (checked to be a JSFunction)
   //  -- a2 : the shared function info.
   //  -- cp : the function context.
   // -----------------------------------
 
   if (tail_call_mode == TailCallMode::kAllow) {
     PrepareForTailCall(masm, a0, t0, t1, t2);
   }
 
-  __ lw(a2,
+  __ Lw(a2,
         FieldMemOperand(a2, SharedFunctionInfo::kFormalParameterCountOffset));
   ParameterCount actual(a0);
   ParameterCount expected(a2);
   __ InvokeFunctionCode(a1, no_reg, expected, actual, JUMP_FUNCTION,
                         CheckDebugStepCallWrapper());
 
   // The function is a "classConstructor", need to raise an exception.
   __ bind(&class_constructor);
   {
     FrameScope frame(masm, StackFrame::INTERNAL);
@@ skipping 10 matching lines @@
   //  -- a1 : the function to call (checked to be a JSBoundFunction)
   // -----------------------------------
   __ AssertBoundFunction(a1);
 
   if (tail_call_mode == TailCallMode::kAllow) {
     PrepareForTailCall(masm, a0, t0, t1, t2);
   }
 
   // Patch the receiver to [[BoundThis]].
   {
-    __ ld(at, FieldMemOperand(a1, JSBoundFunction::kBoundThisOffset));
+    __ Ld(at, FieldMemOperand(a1, JSBoundFunction::kBoundThisOffset));
     __ Dlsa(a4, sp, a0, kPointerSizeLog2);
-    __ sd(at, MemOperand(a4));
+    __ Sd(at, MemOperand(a4));
   }
 
   // Load [[BoundArguments]] into a2 and length of that into a4.
-  __ ld(a2, FieldMemOperand(a1, JSBoundFunction::kBoundArgumentsOffset));
-  __ lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
+  __ Ld(a2, FieldMemOperand(a1, JSBoundFunction::kBoundArgumentsOffset));
+  __ Lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
 
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the function to call (checked to be a JSBoundFunction)
   //  -- a2 : the [[BoundArguments]] (implemented as FixedArray)
   //  -- a4 : the number of [[BoundArguments]]
   // -----------------------------------
 
   // Reserve stack space for the [[BoundArguments]].
   {
@@ skipping 14 matching lines @@
     __ bind(&done);
   }
 
   // Relocate arguments down the stack.
   {
     Label loop, done_loop;
     __ mov(a5, zero_reg);
     __ bind(&loop);
     __ Branch(&done_loop, gt, a5, Operand(a0));
     __ Dlsa(a6, sp, a4, kPointerSizeLog2);
-    __ ld(at, MemOperand(a6));
+    __ Ld(at, MemOperand(a6));
     __ Dlsa(a6, sp, a5, kPointerSizeLog2);
-    __ sd(at, MemOperand(a6));
+    __ Sd(at, MemOperand(a6));
     __ Daddu(a4, a4, Operand(1));
     __ Daddu(a5, a5, Operand(1));
     __ Branch(&loop);
     __ bind(&done_loop);
   }
 
   // Copy [[BoundArguments]] to the stack (below the arguments).
   {
     Label loop, done_loop;
-    __ lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
+    __ Lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
     __ Daddu(a2, a2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
     __ bind(&loop);
     __ Dsubu(a4, a4, Operand(1));
     __ Branch(&done_loop, lt, a4, Operand(zero_reg));
     __ Dlsa(a5, a2, a4, kPointerSizeLog2);
-    __ ld(at, MemOperand(a5));
+    __ Ld(at, MemOperand(a5));
     __ Dlsa(a5, sp, a0, kPointerSizeLog2);
-    __ sd(at, MemOperand(a5));
+    __ Sd(at, MemOperand(a5));
     __ Daddu(a0, a0, Operand(1));
     __ Branch(&loop);
     __ bind(&done_loop);
   }
 
   // Call the [[BoundTargetFunction]] via the Call builtin.
-  __ ld(a1, FieldMemOperand(a1, JSBoundFunction::kBoundTargetFunctionOffset));
+  __ Ld(a1, FieldMemOperand(a1, JSBoundFunction::kBoundTargetFunctionOffset));
   __ li(at, Operand(ExternalReference(Builtins::kCall_ReceiverIsAny,
                                       masm->isolate())));
-  __ ld(at, MemOperand(at));
+  __ Ld(at, MemOperand(at));
   __ Daddu(at, at, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Jump(at);
 }
 
 // static
 void Builtins::Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode,
                              TailCallMode tail_call_mode) {
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the target to call (can be any Object).
   // -----------------------------------
 
   Label non_callable, non_function, non_smi;
   __ JumpIfSmi(a1, &non_callable);
   __ bind(&non_smi);
   __ GetObjectType(a1, t1, t2);
   __ Jump(masm->isolate()->builtins()->CallFunction(mode, tail_call_mode),
           RelocInfo::CODE_TARGET, eq, t2, Operand(JS_FUNCTION_TYPE));
   __ Jump(masm->isolate()->builtins()->CallBoundFunction(tail_call_mode),
           RelocInfo::CODE_TARGET, eq, t2, Operand(JS_BOUND_FUNCTION_TYPE));
 
   // Check if target has a [[Call]] internal method.
-  __ lbu(t1, FieldMemOperand(t1, Map::kBitFieldOffset));
+  __ Lbu(t1, FieldMemOperand(t1, Map::kBitFieldOffset));
   __ And(t1, t1, Operand(1 << Map::kIsCallable));
   __ Branch(&non_callable, eq, t1, Operand(zero_reg));
 
   __ Branch(&non_function, ne, t2, Operand(JS_PROXY_TYPE));
 
   // 0. Prepare for tail call if necessary.
   if (tail_call_mode == TailCallMode::kAllow) {
     PrepareForTailCall(masm, a0, t0, t1, t2);
   }
 
   // 1. Runtime fallback for Proxy [[Call]].
   __ Push(a1);
   // Increase the arguments size to include the pushed function and the
   // existing receiver on the stack.
   __ Daddu(a0, a0, 2);
   // Tail-call to the runtime.
   __ JumpToExternalReference(
       ExternalReference(Runtime::kJSProxyCall, masm->isolate()));
 
   // 2. Call to something else, which might have a [[Call]] internal method (if
   // not we raise an exception).
   __ bind(&non_function);
   // Overwrite the original receiver with the (original) target.
   __ Dlsa(at, sp, a0, kPointerSizeLog2);
-  __ sd(a1, MemOperand(at));
+  __ Sd(a1, MemOperand(at));
   // Let the "call_as_function_delegate" take care of the rest.
   __ LoadNativeContextSlot(Context::CALL_AS_FUNCTION_DELEGATE_INDEX, a1);
   __ Jump(masm->isolate()->builtins()->CallFunction(
               ConvertReceiverMode::kNotNullOrUndefined, tail_call_mode),
           RelocInfo::CODE_TARGET);
 
   // 3. Call to something that is not callable.
   __ bind(&non_callable);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
@@ skipping 11 matching lines @@
   Register scratch2 = t1;
 
   Register spread = a2;
   Register spread_map = a4;
 
   Register spread_len = a4;
 
   Register native_context = a5;
 
   Label runtime_call, push_args;
-  __ ld(spread, MemOperand(sp, 0));
+  __ Ld(spread, MemOperand(sp, 0));
   __ JumpIfSmi(spread, &runtime_call);
-  __ ld(spread_map, FieldMemOperand(spread, HeapObject::kMapOffset));
-  __ ld(native_context, NativeContextMemOperand());
+  __ Ld(spread_map, FieldMemOperand(spread, HeapObject::kMapOffset));
+  __ Ld(native_context, NativeContextMemOperand());
 
   // Check that the spread is an array.
-  __ lbu(scratch, FieldMemOperand(spread_map, Map::kInstanceTypeOffset));
+  __ Lbu(scratch, FieldMemOperand(spread_map, Map::kInstanceTypeOffset));
   __ Branch(&runtime_call, ne, scratch, Operand(JS_ARRAY_TYPE));
 
   // Check that we have the original ArrayPrototype.
-  __ ld(scratch, FieldMemOperand(spread_map, Map::kPrototypeOffset));
-  __ ld(scratch2, ContextMemOperand(native_context,
+  __ Ld(scratch, FieldMemOperand(spread_map, Map::kPrototypeOffset));
+  __ Ld(scratch2, ContextMemOperand(native_context,
                                     Context::INITIAL_ARRAY_PROTOTYPE_INDEX));
   __ Branch(&runtime_call, ne, scratch, Operand(scratch2));
 
   // Check that the ArrayPrototype hasn't been modified in a way that would
   // affect iteration.
   __ LoadRoot(scratch, Heap::kArrayIteratorProtectorRootIndex);
-  __ ld(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
+  __ Ld(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
   __ Branch(&runtime_call, ne, scratch,
             Operand(Smi::FromInt(Isolate::kProtectorValid)));
 
   // Check that the map of the initial array iterator hasn't changed.
-  __ ld(scratch,
+  __ Ld(scratch,
         ContextMemOperand(native_context,
                           Context::INITIAL_ARRAY_ITERATOR_PROTOTYPE_INDEX));
-  __ ld(scratch, FieldMemOperand(scratch, HeapObject::kMapOffset));
-  __ ld(scratch2,
+  __ Ld(scratch, FieldMemOperand(scratch, HeapObject::kMapOffset));
+  __ Ld(scratch2,
         ContextMemOperand(native_context,
                           Context::INITIAL_ARRAY_ITERATOR_PROTOTYPE_MAP_INDEX));
   __ Branch(&runtime_call, ne, scratch, Operand(scratch2));
 
   // For FastPacked kinds, iteration will have the same effect as simply
   // accessing each property in order.
   Label no_protector_check;
-  __ lbu(scratch, FieldMemOperand(spread_map, Map::kBitField2Offset));
+  __ Lbu(scratch, FieldMemOperand(spread_map, Map::kBitField2Offset));
   __ DecodeField<Map::ElementsKindBits>(scratch);
   __ Branch(&runtime_call, hi, scratch, Operand(FAST_HOLEY_ELEMENTS));
   // For non-FastHoley kinds, we can skip the protector check.
   __ Branch(&no_protector_check, eq, scratch, Operand(FAST_SMI_ELEMENTS));
   __ Branch(&no_protector_check, eq, scratch, Operand(FAST_ELEMENTS));
   // Check the ArrayProtector cell.
   __ LoadRoot(scratch, Heap::kArrayProtectorRootIndex);
-  __ ld(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
+  __ Ld(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
   __ Branch(&runtime_call, ne, scratch,
             Operand(Smi::FromInt(Isolate::kProtectorValid)));
 
   __ bind(&no_protector_check);
   // Load the FixedArray backing store, but use the length from the array.
-  __ lw(spread_len, UntagSmiFieldMemOperand(spread, JSArray::kLengthOffset));
-  __ ld(spread, FieldMemOperand(spread, JSArray::kElementsOffset));
+  __ Lw(spread_len, UntagSmiFieldMemOperand(spread, JSArray::kLengthOffset));
+  __ Ld(spread, FieldMemOperand(spread, JSArray::kElementsOffset));
   __ Branch(&push_args);
 
   __ bind(&runtime_call);
   {
     // Call the builtin for the result of the spread.
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ SmiTag(argc);
     __ Push(constructor, new_target, argc, spread);
     __ CallRuntime(Runtime::kSpreadIterableFixed);
     __ mov(spread, v0);
     __ Pop(constructor, new_target, argc);
     __ SmiUntag(argc);
   }
 
   {
     // Calculate the new nargs including the result of the spread.
-    __ lw(spread_len,
+    __ Lw(spread_len,
           UntagSmiFieldMemOperand(spread, FixedArray::kLengthOffset));
 
     __ bind(&push_args);
     // argc += spread_len - 1. Subtract 1 for the spread itself.
     __ Daddu(argc, argc, spread_len);
     __ Dsubu(argc, argc, Operand(1));
 
     // Pop the spread argument off the stack.
     __ Pop(scratch);
   }
@@ skipping 14 matching lines @@
     __ bind(&done);
   }
 
   // Put the evaluated spread onto the stack as additional arguments.
   {
     __ mov(scratch, zero_reg);
     Label done, push, loop;
     __ bind(&loop);
     __ Branch(&done, eq, scratch, Operand(spread_len));
     __ Dlsa(scratch2, spread, scratch, kPointerSizeLog2);
-    __ ld(scratch2, FieldMemOperand(scratch2, FixedArray::kHeaderSize));
+    __ Ld(scratch2, FieldMemOperand(scratch2, FixedArray::kHeaderSize));
     __ JumpIfNotRoot(scratch2, Heap::kTheHoleValueRootIndex, &push);
     __ LoadRoot(scratch2, Heap::kUndefinedValueRootIndex);
     __ bind(&push);
     __ Push(scratch2);
     __ Daddu(scratch, scratch, Operand(1));
     __ Branch(&loop);
     __ bind(&done);
   }
 }
 
@@ skipping 19 matching lines @@
   //  -- a3 : the new target (checked to be a constructor)
   // -----------------------------------
   __ AssertFunction(a1);
 
   // Calling convention for function specific ConstructStubs require
   // a2 to contain either an AllocationSite or undefined.
   __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
 
   // 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);
 }
 
 // static
 void Builtins::Generate_ConstructBoundFunction(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the function to call (checked to be a JSBoundFunction)
   //  -- a3 : the new target (checked to be a constructor)
   // -----------------------------------
   __ AssertBoundFunction(a1);
 
   // Load [[BoundArguments]] into a2 and length of that into a4.
-  __ ld(a2, FieldMemOperand(a1, JSBoundFunction::kBoundArgumentsOffset));
-  __ lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
+  __ Ld(a2, FieldMemOperand(a1, JSBoundFunction::kBoundArgumentsOffset));
+  __ Lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
 
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the function to call (checked to be a JSBoundFunction)
   //  -- a2 : the [[BoundArguments]] (implemented as FixedArray)
   //  -- a3 : the new target (checked to be a constructor)
   //  -- a4 : the number of [[BoundArguments]]
   // -----------------------------------
 
   // Reserve stack space for the [[BoundArguments]].
@@ skipping 15 matching lines @@
     __ bind(&done);
   }
 
   // Relocate arguments down the stack.
   {
     Label loop, done_loop;
     __ mov(a5, zero_reg);
     __ bind(&loop);
     __ Branch(&done_loop, ge, a5, Operand(a0));
     __ Dlsa(a6, sp, a4, kPointerSizeLog2);
-    __ ld(at, MemOperand(a6));
+    __ Ld(at, MemOperand(a6));
     __ Dlsa(a6, sp, a5, kPointerSizeLog2);
-    __ sd(at, MemOperand(a6));
+    __ Sd(at, MemOperand(a6));
     __ Daddu(a4, a4, Operand(1));
     __ Daddu(a5, a5, Operand(1));
     __ Branch(&loop);
     __ bind(&done_loop);
   }
 
   // Copy [[BoundArguments]] to the stack (below the arguments).
   {
     Label loop, done_loop;
-    __ lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
+    __ Lw(a4, UntagSmiFieldMemOperand(a2, FixedArray::kLengthOffset));
     __ Daddu(a2, a2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
     __ bind(&loop);
     __ Dsubu(a4, a4, Operand(1));
     __ Branch(&done_loop, lt, a4, Operand(zero_reg));
     __ Dlsa(a5, a2, a4, kPointerSizeLog2);
-    __ ld(at, MemOperand(a5));
+    __ Ld(at, MemOperand(a5));
     __ Dlsa(a5, sp, a0, kPointerSizeLog2);
-    __ sd(at, MemOperand(a5));
+    __ Sd(at, MemOperand(a5));
     __ Daddu(a0, a0, Operand(1));
     __ Branch(&loop);
     __ bind(&done_loop);
   }
 
   // Patch new.target to [[BoundTargetFunction]] if new.target equals target.
   {
     Label skip_load;
     __ Branch(&skip_load, ne, a1, Operand(a3));
-    __ ld(a3, FieldMemOperand(a1, JSBoundFunction::kBoundTargetFunctionOffset));
+    __ Ld(a3, FieldMemOperand(a1, JSBoundFunction::kBoundTargetFunctionOffset));
     __ bind(&skip_load);
   }
 
   // Construct the [[BoundTargetFunction]] via the Construct builtin.
-  __ ld(a1, FieldMemOperand(a1, JSBoundFunction::kBoundTargetFunctionOffset));
+  __ Ld(a1, FieldMemOperand(a1, JSBoundFunction::kBoundTargetFunctionOffset));
   __ li(at, Operand(ExternalReference(Builtins::kConstruct, masm->isolate())));
-  __ ld(at, MemOperand(at));
+  __ Ld(at, MemOperand(at));
   __ Daddu(at, at, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Jump(at);
 }
 
 // static
 void Builtins::Generate_ConstructProxy(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0 : the number of arguments (not including the receiver)
   //  -- a1 : the constructor to call (checked to be a JSProxy)
   //  -- a3 : the new target (either the same as the constructor or
@@ skipping 16 matching lines @@
   //  -- a1 : the constructor to call (can be any Object)
   //  -- a3 : the new target (either the same as the constructor or
   //          the JSFunction on which new was invoked initially)
   // -----------------------------------
 
   // Check if target is a Smi.
   Label non_constructor;
   __ JumpIfSmi(a1, &non_constructor);
 
   // Dispatch based on instance type.
-  __ ld(t1, FieldMemOperand(a1, HeapObject::kMapOffset));
-  __ lbu(t2, FieldMemOperand(t1, Map::kInstanceTypeOffset));
+  __ Ld(t1, FieldMemOperand(a1, HeapObject::kMapOffset));
+  __ Lbu(t2, FieldMemOperand(t1, Map::kInstanceTypeOffset));
   __ Jump(masm->isolate()->builtins()->ConstructFunction(),
           RelocInfo::CODE_TARGET, eq, t2, Operand(JS_FUNCTION_TYPE));
 
   // Check if target has a [[Construct]] internal method.
-  __ lbu(t3, FieldMemOperand(t1, Map::kBitFieldOffset));
+  __ Lbu(t3, FieldMemOperand(t1, Map::kBitFieldOffset));
   __ And(t3, t3, Operand(1 << Map::kIsConstructor));
   __ Branch(&non_constructor, eq, t3, Operand(zero_reg));
 
   // Only dispatch to bound functions after checking whether they are
   // constructors.
   __ Jump(masm->isolate()->builtins()->ConstructBoundFunction(),
           RelocInfo::CODE_TARGET, eq, t2, Operand(JS_BOUND_FUNCTION_TYPE));
 
   // Only dispatch to proxies after checking whether they are constructors.
   __ Jump(masm->isolate()->builtins()->ConstructProxy(), RelocInfo::CODE_TARGET,
           eq, t2, Operand(JS_PROXY_TYPE));
 
   // Called Construct on an exotic Object with a [[Construct]] internal method.
   {
     // Overwrite the original receiver with the (original) target.
     __ Dlsa(at, sp, a0, kPointerSizeLog2);
-    __ sd(a1, MemOperand(at));
+    __ Sd(a1, MemOperand(at));
     // Let the "call_as_constructor_delegate" take care of the rest.
     __ LoadNativeContextSlot(Context::CALL_AS_CONSTRUCTOR_DELEGATE_INDEX, a1);
     __ Jump(masm->isolate()->builtins()->CallFunction(),
             RelocInfo::CODE_TARGET);
   }
 
   // Called Construct on an Object that doesn't have a [[Construct]] internal
   // method.
   __ bind(&non_constructor);
   __ Jump(masm->isolate()->builtins()->ConstructedNonConstructable(),
@@ skipping 86 matching lines @@
 
     // Copy the arguments (including the receiver) to the new stack frame.
     // a0: copy start address
     // a1: function
     // a2: expected number of arguments
     // a3: new target (passed through to callee)
     // a4: copy end address
 
     Label copy;
     __ bind(&copy);
-    __ ld(a5, MemOperand(a0));
+    __ Ld(a5, MemOperand(a0));
     __ push(a5);
     __ Branch(USE_DELAY_SLOT, &copy, ne, a0, Operand(a4));
     __ daddiu(a0, a0, -kPointerSize);  // In delay slot.
 
     __ jmp(&invoke);
   }
 
   {  // Too few parameters: Actual < expected.
     __ bind(&too_few);
     EnterArgumentsAdaptorFrame(masm);
@@ skipping 12 matching lines @@
     __ Daddu(a7, fp, kPointerSize);
 
     // Copy the arguments (including the receiver) to the new stack frame.
     // a0: copy start address
     // a1: function
     // a2: expected number of arguments
     // a3: new target (passed through to callee)
     // a7: copy end address
     Label copy;
     __ bind(&copy);
-    __ ld(a4, MemOperand(a0));  // Adjusted above for return addr and receiver.
+    __ Ld(a4, MemOperand(a0));  // Adjusted above for return addr and receiver.
     __ Dsubu(sp, sp, kPointerSize);
     __ Dsubu(a0, a0, kPointerSize);
     __ Branch(USE_DELAY_SLOT, &copy, ne, a0, Operand(a7));
-    __ sd(a4, MemOperand(sp));  // In the delay slot.
+    __ Sd(a4, MemOperand(sp));  // In the delay slot.
 
     // Fill the remaining expected arguments with undefined.
     // a1: function
     // a2: expected number of arguments
     // a3: new target (passed through to callee)
     __ LoadRoot(a5, Heap::kUndefinedValueRootIndex);
     __ dsll(a6, a2, kPointerSizeLog2);
     __ Dsubu(a4, fp, Operand(a6));
     // Adjust for frame.
     __ Dsubu(a4, a4, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
                              2 * kPointerSize));
 
     Label fill;
     __ bind(&fill);
     __ Dsubu(sp, sp, kPointerSize);
     __ Branch(USE_DELAY_SLOT, &fill, ne, sp, Operand(a4));
-    __ sd(a5, MemOperand(sp));
+    __ Sd(a5, MemOperand(sp));
   }
 
   // Call the entry point.
   __ bind(&invoke);
   __ mov(a0, a2);
   // a0 : expected number of arguments
   // a1 : function (passed through to callee)
   // a3: new target (passed through to callee)
-  __ ld(a4, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
   __ Call(a4);
 
   // Store offset of return address for deoptimizer.
   masm->isolate()->heap()->SetArgumentsAdaptorDeoptPCOffset(masm->pc_offset());
 
   // Exit frame and return.
   LeaveArgumentsAdaptorFrame(masm);
   __ Ret();
 
   // -------------------------------------------
   // Don't adapt arguments.
   // -------------------------------------------
   __ bind(&dont_adapt_arguments);
-  __ ld(a4, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
+  __ Ld(a4, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
   __ Jump(a4);
 
   __ bind(&stack_overflow);
   {
     FrameScope frame(masm, StackFrame::MANUAL);
     __ CallRuntime(Runtime::kThrowStackOverflow);
     __ break_(0xCC);
   }
 }
 
@@ skipping 22 matching lines @@
   __ Daddu(at, v0, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Jump(at);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64