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

src/crankshaft/mips64/lithium-codegen-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.
 
 #include "src/crankshaft/mips64/lithium-codegen-mips64.h"
 
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/crankshaft/hydrogen-osr.h"
@@ skipping 73 matching lines @@
 
 
 void LCodeGen::SaveCallerDoubles() {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Save clobbered callee double registers");
   int count = 0;
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator save_iterator(doubles);
   while (!save_iterator.Done()) {
-    __ sdc1(DoubleRegister::from_code(save_iterator.Current()),
+    __ Sdc1(DoubleRegister::from_code(save_iterator.Current()),
             MemOperand(sp, count * kDoubleSize));
     save_iterator.Advance();
     count++;
   }
 }
 
 
 void LCodeGen::RestoreCallerDoubles() {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Restore clobbered callee double registers");
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator save_iterator(doubles);
   int count = 0;
   while (!save_iterator.Done()) {
-    __ ldc1(DoubleRegister::from_code(save_iterator.Current()),
+    __ Ldc1(DoubleRegister::from_code(save_iterator.Current()),
             MemOperand(sp, count * kDoubleSize));
     save_iterator.Advance();
     count++;
   }
 }
 
 
 bool LCodeGen::GeneratePrologue() {
   DCHECK(is_generating());
 
@@ skipping 20 matching lines @@
   int slots = GetStackSlotCount();
   if (slots > 0) {
     if (FLAG_debug_code) {
       __ Dsubu(sp,  sp, Operand(slots * kPointerSize));
       __ Push(a0, a1);
       __ Daddu(a0, sp, Operand(slots *  kPointerSize));
       __ li(a1, Operand(kSlotsZapValue));
       Label loop;
       __ bind(&loop);
       __ Dsubu(a0, a0, Operand(kPointerSize));
-      __ sd(a1, MemOperand(a0, 2 * kPointerSize));
+      __ Sd(a1, MemOperand(a0, 2 * kPointerSize));
       __ Branch(&loop, ne, a0, Operand(sp));
       __ Pop(a0, a1);
     } else {
       __ Dsubu(sp, sp, Operand(slots * kPointerSize));
     }
   }
 
   if (info()->saves_caller_doubles()) {
     SaveCallerDoubles();
   }
@@ skipping 29 matching lines @@
         __ push(a1);
         __ Push(Smi::FromInt(info()->scope()->scope_type()));
         __ CallRuntime(Runtime::kNewFunctionContext);
       }
     }
     RecordSafepoint(deopt_mode);
 
     // Context is returned in both v0. It replaces the context passed to us.
     // It's saved in the stack and kept live in cp.
     __ mov(cp, v0);
-    __ sd(v0, MemOperand(fp, StandardFrameConstants::kContextOffset));
+    __ Sd(v0, MemOperand(fp, StandardFrameConstants::kContextOffset));
     // Copy any necessary parameters into the context.
     int num_parameters = info()->scope()->num_parameters();
     int first_parameter = info()->scope()->has_this_declaration() ? -1 : 0;
     for (int i = first_parameter; i < num_parameters; i++) {
       Variable* var = (i == -1) ? info()->scope()->receiver()
                                 : info()->scope()->parameter(i);
       if (var->IsContextSlot()) {
         int parameter_offset = StandardFrameConstants::kCallerSPOffset +
             (num_parameters - 1 - i) * kPointerSize;
         // Load parameter from stack.
-        __ ld(a0, MemOperand(fp, parameter_offset));
+        __ Ld(a0, MemOperand(fp, parameter_offset));
         // Store it in the context.
         MemOperand target = ContextMemOperand(cp, var->index());
-        __ sd(a0, target);
+        __ Sd(a0, target);
         // Update the write barrier. This clobbers a3 and a0.
         if (need_write_barrier) {
           __ RecordWriteContextSlot(
               cp, target.offset(), a0, a3, GetRAState(), kSaveFPRegs);
         } else if (FLAG_debug_code) {
           Label done;
           __ JumpIfInNewSpace(cp, a0, &done);
           __ Abort(kExpectedNewSpaceObject);
           __ bind(&done);
         }
@@ skipping 184 matching lines @@
       DCHECK(constant->HasSmiValue());
       __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));
     } else if (r.IsDouble()) {
       Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);
     } else {
       DCHECK(r.IsSmiOrTagged());
       __ li(scratch, literal);
     }
     return scratch;
   } else if (op->IsStackSlot()) {
-    __ ld(scratch, ToMemOperand(op));
+    __ Ld(scratch, ToMemOperand(op));
     return scratch;
   }
   UNREACHABLE();
   return scratch;
 }
 
 
 DoubleRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
   DCHECK(op->IsDoubleRegister());
   return ToDoubleRegister(op->index());
@@ skipping 16 matching lines @@
       __ mtc1(at, flt_scratch);
       __ cvt_d_w(dbl_scratch, flt_scratch);
       return dbl_scratch;
     } else if (r.IsDouble()) {
       Abort(kUnsupportedDoubleImmediate);
     } else if (r.IsTagged()) {
       Abort(kUnsupportedTaggedImmediate);
     }
   } else if (op->IsStackSlot()) {
     MemOperand mem_op = ToMemOperand(op);
-    __ ldc1(dbl_scratch, mem_op);
+    __ Ldc1(dbl_scratch, mem_op);
     return dbl_scratch;
   }
   UNREACHABLE();
   return dbl_scratch;
 }
 
 
 Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   DCHECK(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
@@ skipping 222 matching lines @@
   __ CallRuntime(function, num_arguments, save_doubles);
 
   RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
 }
 
 
 void LCodeGen::LoadContextFromDeferred(LOperand* context) {
   if (context->IsRegister()) {
     __ Move(cp, ToRegister(context));
   } else if (context->IsStackSlot()) {
-    __ ld(cp, ToMemOperand(context));
+    __ Ld(cp, ToMemOperand(context));
   } else if (context->IsConstantOperand()) {
     HConstant* constant =
         chunk_->LookupConstant(LConstantOperand::cast(context));
     __ li(cp, Handle<Object>::cast(constant->handle(isolate())));
   } else {
     UNREACHABLE();
   }
 }
 
 
@@ skipping 58 matching lines @@
     Abort(kBailoutWasNotPrepared);
     return;
   }
 
   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
     Register scratch = scratch0();
     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
     Label no_deopt;
     __ Push(a1, scratch);
     __ li(scratch, Operand(count));
-    __ lw(a1, MemOperand(scratch));
+    __ Lw(a1, MemOperand(scratch));
     __ Subu(a1, a1, Operand(1));
     __ Branch(&no_deopt, ne, a1, Operand(zero_reg));
     __ li(a1, Operand(FLAG_deopt_every_n_times));
-    __ sw(a1, MemOperand(scratch));
+    __ Sw(a1, MemOperand(scratch));
     __ Pop(a1, scratch);
 
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     __ bind(&no_deopt);
-    __ sw(a1, MemOperand(scratch));
+    __ Sw(a1, MemOperand(scratch));
     __ Pop(a1, scratch);
   }
 
   if (info()->ShouldTrapOnDeopt()) {
     Label skip;
     if (condition != al) {
       __ Branch(&skip, NegateCondition(condition), src1, src2);
     }
     __ stop("trap_on_deopt");
     __ bind(&skip);
@@ skipping 959 matching lines @@
 }
 
 
 void LCodeGen::DoSeqStringGetChar(LSeqStringGetChar* instr) {
   String::Encoding encoding = instr->hydrogen()->encoding();
   Register string = ToRegister(instr->string());
   Register result = ToRegister(instr->result());
 
   if (FLAG_debug_code) {
     Register scratch = scratch0();
-    __ ld(scratch, FieldMemOperand(string, HeapObject::kMapOffset));
-    __ lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
+    __ Ld(scratch, FieldMemOperand(string, HeapObject::kMapOffset));
+    __ Lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
 
     __ And(scratch, scratch,
            Operand(kStringRepresentationMask | kStringEncodingMask));
     static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
     static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
     __ Dsubu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
                                 ? one_byte_seq_type : two_byte_seq_type));
     __ Check(eq, kUnexpectedStringType, at, Operand(zero_reg));
   }
 
   MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
   if (encoding == String::ONE_BYTE_ENCODING) {
-    __ lbu(result, operand);
+    __ Lbu(result, operand);
   } else {
-    __ lhu(result, operand);
+    __ Lhu(result, operand);
   }
 }
 
 
 void LCodeGen::DoSeqStringSetChar(LSeqStringSetChar* instr) {
   String::Encoding encoding = instr->hydrogen()->encoding();
   Register string = ToRegister(instr->string());
   Register value = ToRegister(instr->value());
 
   if (FLAG_debug_code) {
     Register scratch = scratch0();
     Register index = ToRegister(instr->index());
     static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
     static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
     int encoding_mask =
         instr->hydrogen()->encoding() == String::ONE_BYTE_ENCODING
         ? one_byte_seq_type : two_byte_seq_type;
     __ EmitSeqStringSetCharCheck(string, index, value, scratch, encoding_mask);
   }
 
   MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
   if (encoding == String::ONE_BYTE_ENCODING) {
-    __ sb(value, operand);
+    __ Sb(value, operand);
   } else {
-    __ sh(value, operand);
+    __ Sh(value, operand);
   }
 }
 
 
 void LCodeGen::DoAddE(LAddE* instr) {
   LOperand* result = instr->result();
   LOperand* left = instr->left();
   LOperand* right = instr->right();
 
   DCHECK(!instr->hydrogen()->CheckFlag(HValue::kCanOverflow));
@@ skipping 242 matching lines @@
       EmitBranch(instr, eq, reg, Operand(at));
     } else if (type.IsSmi()) {
       DCHECK(!info()->IsStub());
       EmitBranch(instr, ne, reg, Operand(zero_reg));
     } else if (type.IsJSArray()) {
       DCHECK(!info()->IsStub());
       EmitBranch(instr, al, zero_reg, Operand(zero_reg));
     } else if (type.IsHeapNumber()) {
       DCHECK(!info()->IsStub());
       DoubleRegister dbl_scratch = double_scratch0();
-      __ ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
+      __ Ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
       // Test the double value. Zero and NaN are false.
       EmitBranchF(instr, ogl, dbl_scratch, kDoubleRegZero);
     } else if (type.IsString()) {
       DCHECK(!info()->IsStub());
-      __ ld(at, FieldMemOperand(reg, String::kLengthOffset));
+      __ Ld(at, FieldMemOperand(reg, String::kLengthOffset));
       EmitBranch(instr, ne, at, Operand(zero_reg));
     } else {
       ToBooleanHints expected = instr->hydrogen()->expected_input_types();
       // Avoid deopts in the case where we've never executed this path before.
       if (expected == ToBooleanHint::kNone) expected = ToBooleanHint::kAny;
 
       if (expected & ToBooleanHint::kUndefined) {
         // undefined -> false.
         __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
         __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
@@ skipping 16 matching lines @@
         __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(zero_reg));
         __ JumpIfSmi(reg, instr->TrueLabel(chunk_));
       } else if (expected & ToBooleanHint::kNeedsMap) {
         // If we need a map later and have a Smi -> deopt.
         __ SmiTst(reg, at);
         DeoptimizeIf(eq, instr, DeoptimizeReason::kSmi, at, Operand(zero_reg));
       }
 
       const Register map = scratch0();
       if (expected & ToBooleanHint::kNeedsMap) {
-        __ ld(map, FieldMemOperand(reg, HeapObject::kMapOffset));
+        __ Ld(map, FieldMemOperand(reg, HeapObject::kMapOffset));
         if (expected & ToBooleanHint::kCanBeUndetectable) {
           // Undetectable -> false.
-          __ lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
+          __ Lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
           __ And(at, at, Operand(1 << Map::kIsUndetectable));
           __ Branch(instr->FalseLabel(chunk_), ne, at, Operand(zero_reg));
         }
       }
 
       if (expected & ToBooleanHint::kReceiver) {
         // spec object -> true.
-        __ lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
+        __ Lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
         __ Branch(instr->TrueLabel(chunk_),
                   ge, at, Operand(FIRST_JS_RECEIVER_TYPE));
       }
 
       if (expected & ToBooleanHint::kString) {
         // String value -> false iff empty.
         Label not_string;
-        __ lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
+        __ Lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
         __ Branch(&not_string, ge , at, Operand(FIRST_NONSTRING_TYPE));
-        __ ld(at, FieldMemOperand(reg, String::kLengthOffset));
+        __ Ld(at, FieldMemOperand(reg, String::kLengthOffset));
         __ Branch(instr->TrueLabel(chunk_), ne, at, Operand(zero_reg));
         __ Branch(instr->FalseLabel(chunk_));
         __ bind(&not_string);
       }
 
       if (expected & ToBooleanHint::kSymbol) {
         // Symbol value -> true.
         const Register scratch = scratch1();
-        __ lbu(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
+        __ Lbu(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
         __ Branch(instr->TrueLabel(chunk_), eq, scratch, Operand(SYMBOL_TYPE));
       }
 
       if (expected & ToBooleanHint::kHeapNumber) {
         // heap number -> false iff +0, -0, or NaN.
         DoubleRegister dbl_scratch = double_scratch0();
         Label not_heap_number;
         __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
         __ Branch(&not_heap_number, ne, map, Operand(at));
-        __ ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
+        __ Ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
         __ BranchF(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_),
                    ne, dbl_scratch, kDoubleRegZero);
         // Falls through if dbl_scratch == 0.
         __ Branch(instr->FalseLabel(chunk_));
         __ bind(&not_heap_number);
       }
 
       if (expected != ToBooleanHint::kAny) {
         // We've seen something for the first time -> deopt.
         // This can only happen if we are not generic already.
@@ skipping 173 matching lines @@
 }
 
 
 void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {
   Register input = ToRegister(instr->value());
   Register temp = ToRegister(instr->temp());
 
   if (!instr->hydrogen()->value()->type().IsHeapObject()) {
     __ JumpIfSmi(input, instr->FalseLabel(chunk_));
   }
-  __ ld(temp, FieldMemOperand(input, HeapObject::kMapOffset));
-  __ lbu(temp, FieldMemOperand(temp, Map::kBitFieldOffset));
+  __ Ld(temp, FieldMemOperand(input, HeapObject::kMapOffset));
+  __ Lbu(temp, FieldMemOperand(temp, Map::kBitFieldOffset));
   __ And(at, temp, Operand(1 << Map::kIsUndetectable));
   EmitBranch(instr, ne, at, Operand(zero_reg));
 }
 
 
 static Condition ComputeCompareCondition(Token::Value op) {
   switch (op) {
     case Token::EQ_STRICT:
     case Token::EQ:
       return eq;
@@ skipping 86 matching lines @@
 
   // Objects with a non-function constructor have class 'Object'.
   if (String::Equals(class_name, isolate()->factory()->Object_string())) {
     __ Branch(is_true, ne, instance_type, Operand(JS_FUNCTION_TYPE));
   } else {
     __ Branch(is_false, ne, instance_type, Operand(JS_FUNCTION_TYPE));
   }
 
   // temp now contains the constructor function. Grab the
   // instance class name from there.
-  __ ld(temp, FieldMemOperand(temp, JSFunction::kSharedFunctionInfoOffset));
-  __ ld(temp,
+  __ Ld(temp, FieldMemOperand(temp, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(temp,
         FieldMemOperand(temp, SharedFunctionInfo::kInstanceClassNameOffset));
   // The class name we are testing against is internalized since it's a literal.
   // The name in the constructor is internalized because of the way the context
   // is booted.  This routine isn't expected to work for random API-created
   // classes and it doesn't have to because you can't access it with natives
   // syntax.  Since both sides are internalized it is sufficient to use an
   // identity comparison.
 
   // End with the address of this class_name instance in temp register.
   // On MIPS, the caller must do the comparison with Handle<String>class_name.
 }
 
 void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {
   Register input = ToRegister(instr->value());
   Register temp = scratch0();
   Register temp2 = ToRegister(instr->temp());
   Handle<String> class_name = instr->hydrogen()->class_name();
 
   EmitClassOfTest(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_),
                   class_name, input, temp, temp2);
 
   EmitBranch(instr, eq, temp, Operand(class_name));
 }
 
 void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {
   Register reg = ToRegister(instr->value());
   Register temp = ToRegister(instr->temp());
 
-  __ ld(temp, FieldMemOperand(reg, HeapObject::kMapOffset));
+  __ Ld(temp, FieldMemOperand(reg, HeapObject::kMapOffset));
   EmitBranch(instr, eq, temp, Operand(instr->map()));
 }
 
 
 void LCodeGen::DoHasInPrototypeChainAndBranch(
     LHasInPrototypeChainAndBranch* instr) {
   Register const object = ToRegister(instr->object());
   Register const object_map = scratch0();
   Register const object_instance_type = scratch1();
   Register const object_prototype = object_map;
   Register const prototype = ToRegister(instr->prototype());
 
   // The {object} must be a spec object.  It's sufficient to know that {object}
   // is not a smi, since all other non-spec objects have {null} prototypes and
   // will be ruled out below.
   if (instr->hydrogen()->ObjectNeedsSmiCheck()) {
     __ SmiTst(object, at);
     EmitFalseBranch(instr, eq, at, Operand(zero_reg));
   }
 
   // Loop through the {object}s prototype chain looking for the {prototype}.
-  __ ld(object_map, FieldMemOperand(object, HeapObject::kMapOffset));
+  __ Ld(object_map, FieldMemOperand(object, HeapObject::kMapOffset));
   Label loop;
   __ bind(&loop);
 
   // Deoptimize if the object needs to be access checked.
-  __ lbu(object_instance_type,
+  __ Lbu(object_instance_type,
          FieldMemOperand(object_map, Map::kBitFieldOffset));
   __ And(object_instance_type, object_instance_type,
          Operand(1 << Map::kIsAccessCheckNeeded));
   DeoptimizeIf(ne, instr, DeoptimizeReason::kAccessCheck, object_instance_type,
                Operand(zero_reg));
-  __ lbu(object_instance_type,
+  __ Lbu(object_instance_type,
          FieldMemOperand(object_map, Map::kInstanceTypeOffset));
   DeoptimizeIf(eq, instr, DeoptimizeReason::kProxy, object_instance_type,
                Operand(JS_PROXY_TYPE));
 
-  __ ld(object_prototype, FieldMemOperand(object_map, Map::kPrototypeOffset));
+  __ Ld(object_prototype, FieldMemOperand(object_map, Map::kPrototypeOffset));
   __ LoadRoot(at, Heap::kNullValueRootIndex);
   EmitFalseBranch(instr, eq, object_prototype, Operand(at));
   EmitTrueBranch(instr, eq, object_prototype, Operand(prototype));
   __ Branch(&loop, USE_DELAY_SLOT);
-  __ ld(object_map, FieldMemOperand(object_prototype,
+  __ Ld(object_map, FieldMemOperand(object_prototype,
                                     HeapObject::kMapOffset));  // In delay slot.
 }
 
 
 void LCodeGen::DoCmpT(LCmpT* instr) {
   DCHECK(ToRegister(instr->context()).is(cp));
   Token::Value op = instr->op();
 
   Handle<Code> ic = CodeFactory::CompareIC(isolate(), op).code();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
@@ skipping 13 matching lines @@
 }
 
 
 void LCodeGen::DoReturn(LReturn* instr) {
   if (FLAG_trace && info()->IsOptimizing()) {
     // Push the return value on the stack as the parameter.
     // Runtime::TraceExit returns its parameter in v0. We're leaving the code
     // managed by the register allocator and tearing down the frame, it's
     // safe to write to the context register.
     __ push(v0);
-    __ ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+    __ Ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
     __ CallRuntime(Runtime::kTraceExit);
   }
   if (info()->saves_caller_doubles()) {
     RestoreCallerDoubles();
   }
   if (NeedsEagerFrame()) {
     __ mov(sp, fp);
     __ Pop(ra, fp);
   }
   if (instr->has_constant_parameter_count()) {
@@ skipping 11 matching lines @@
   }
 
   __ Jump(ra);
 }
 
 
 void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
   Register context = ToRegister(instr->context());
   Register result = ToRegister(instr->result());
 
-  __ ld(result, ContextMemOperand(context, instr->slot_index()));
+  __ Ld(result, ContextMemOperand(context, instr->slot_index()));
   if (instr->hydrogen()->RequiresHoleCheck()) {
     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
 
     if (instr->hydrogen()->DeoptimizesOnHole()) {
       DeoptimizeIf(eq, instr, DeoptimizeReason::kHole, result, Operand(at));
     } else {
       Label is_not_hole;
       __ Branch(&is_not_hole, ne, result, Operand(at));
       __ LoadRoot(result, Heap::kUndefinedValueRootIndex);
       __ bind(&is_not_hole);
     }
   }
 }
 
 
 void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {
   Register context = ToRegister(instr->context());
   Register value = ToRegister(instr->value());
   Register scratch = scratch0();
   MemOperand target = ContextMemOperand(context, instr->slot_index());
 
   Label skip_assignment;
 
   if (instr->hydrogen()->RequiresHoleCheck()) {
-    __ ld(scratch, target);
+    __ Ld(scratch, target);
     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
 
     if (instr->hydrogen()->DeoptimizesOnHole()) {
       DeoptimizeIf(eq, instr, DeoptimizeReason::kHole, scratch, Operand(at));
     } else {
       __ Branch(&skip_assignment, ne, scratch, Operand(at));
     }
   }
 
-  __ sd(value, target);
+  __ Sd(value, target);
   if (instr->hydrogen()->NeedsWriteBarrier()) {
     SmiCheck check_needed =
         instr->hydrogen()->value()->type().IsHeapObject()
             ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
     __ RecordWriteContextSlot(context,
                               target.offset(),
                               value,
                               scratch0(),
                               GetRAState(),
                               kSaveFPRegs,
@@ skipping 11 matching lines @@
   Register object = ToRegister(instr->object());
   if (access.IsExternalMemory()) {
     Register result = ToRegister(instr->result());
     MemOperand operand = MemOperand(object, offset);
     __ Load(result, operand, access.representation());
     return;
   }
 
   if (instr->hydrogen()->representation().IsDouble()) {
     DoubleRegister result = ToDoubleRegister(instr->result());
-    __ ldc1(result, FieldMemOperand(object, offset));
+    __ Ldc1(result, FieldMemOperand(object, offset));
     return;
   }
 
   Register result = ToRegister(instr->result());
   if (!access.IsInobject()) {
-    __ ld(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
+    __ Ld(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
     object = result;
   }
 
   Representation representation = access.representation();
   if (representation.IsSmi() && SmiValuesAre32Bits() &&
       instr->hydrogen()->representation().IsInteger32()) {
     if (FLAG_debug_code) {
       // Verify this is really an Smi.
       Register scratch = scratch0();
       __ Load(scratch, FieldMemOperand(object, offset), representation);
       __ AssertSmi(scratch);
     }
 
     // Read int value directly from upper half of the smi.
     STATIC_ASSERT(kSmiTag == 0);
     STATIC_ASSERT(kSmiTagSize + kSmiShiftSize == 32);
     offset = SmiWordOffset(offset);
     representation = Representation::Integer32();
   }
   __ Load(result, FieldMemOperand(object, offset), representation);
 }
 
 
 void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {
   Register scratch = scratch0();
   Register function = ToRegister(instr->function());
   Register result = ToRegister(instr->result());
 
   // Get the prototype or initial map from the function.
-  __ ld(result,
-         FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
+  __ Ld(result,
+        FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
 
   // Check that the function has a prototype or an initial map.
   __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
   DeoptimizeIf(eq, instr, DeoptimizeReason::kHole, result, Operand(at));
 
   // If the function does not have an initial map, we're done.
   Label done;
   __ GetObjectType(result, scratch, scratch);
   __ Branch(&done, ne, scratch, Operand(MAP_TYPE));
 
   // Get the prototype from the initial map.
-  __ ld(result, FieldMemOperand(result, Map::kPrototypeOffset));
+  __ Ld(result, FieldMemOperand(result, Map::kPrototypeOffset));
 
   // All done.
   __ bind(&done);
 }
 
 
 void LCodeGen::DoLoadRoot(LLoadRoot* instr) {
   Register result = ToRegister(instr->result());
   __ LoadRoot(result, instr->index());
 }
 
 
 void LCodeGen::DoAccessArgumentsAt(LAccessArgumentsAt* instr) {
   Register arguments = ToRegister(instr->arguments());
   Register result = ToRegister(instr->result());
   // There are two words between the frame pointer and the last argument.
   // Subtracting from length accounts for one of them add one more.
   if (instr->length()->IsConstantOperand()) {
     int const_length = ToInteger32(LConstantOperand::cast(instr->length()));
     if (instr->index()->IsConstantOperand()) {
       int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
       int index = (const_length - const_index) + 1;
-      __ ld(result, MemOperand(arguments, index * kPointerSize));
+      __ Ld(result, MemOperand(arguments, index * kPointerSize));
     } else {
       Register index = ToRegister(instr->index());
       __ li(at, Operand(const_length + 1));
       __ Dsubu(result, at, index);
       __ Dlsa(at, arguments, result, kPointerSizeLog2);
-      __ ld(result, MemOperand(at));
+      __ Ld(result, MemOperand(at));
     }
   } else if (instr->index()->IsConstantOperand()) {
     Register length = ToRegister(instr->length());
     int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
     int loc = const_index - 1;
     if (loc != 0) {
       __ Dsubu(result, length, Operand(loc));
       __ Dlsa(at, arguments, result, kPointerSizeLog2);
-      __ ld(result, MemOperand(at));
+      __ Ld(result, MemOperand(at));
     } else {
       __ Dlsa(at, arguments, length, kPointerSizeLog2);
-      __ ld(result, MemOperand(at));
+      __ Ld(result, MemOperand(at));
     }
   } else {
     Register length = ToRegister(instr->length());
     Register index = ToRegister(instr->index());
     __ Dsubu(result, length, index);
     __ Daddu(result, result, 1);
     __ Dlsa(at, arguments, result, kPointerSizeLog2);
-    __ ld(result, MemOperand(at));
+    __ Ld(result, MemOperand(at));
   }
 }
 
 
 void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
   Register external_pointer = ToRegister(instr->elements());
   Register key = no_reg;
   ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
@@ skipping 22 matching lines @@
            __ dsra32(scratch0(), key, 0);
          } else {
            __ dsra(scratch0(), key, -shift_size);
          }
       } else {
         __ dsll(scratch0(), key, shift_size);
       }
       __ Daddu(scratch0(), scratch0(), external_pointer);
     }
     if (elements_kind == FLOAT32_ELEMENTS) {
-      __ lwc1(result, MemOperand(scratch0(), base_offset));
+      __ Lwc1(result, MemOperand(scratch0(), base_offset));
       __ cvt_d_s(result, result);
     } else  {  // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
-      __ ldc1(result, MemOperand(scratch0(), base_offset));
+      __ Ldc1(result, MemOperand(scratch0(), base_offset));
     }
   } else {
     Register result = ToRegister(instr->result());
     MemOperand mem_operand = PrepareKeyedOperand(
         key, external_pointer, key_is_constant, constant_key,
         element_size_shift, shift_size, base_offset);
     switch (elements_kind) {
       case INT8_ELEMENTS:
-        __ lb(result, mem_operand);
+        __ Lb(result, mem_operand);
         break;
       case UINT8_ELEMENTS:
       case UINT8_CLAMPED_ELEMENTS:
-        __ lbu(result, mem_operand);
+        __ Lbu(result, mem_operand);
         break;
       case INT16_ELEMENTS:
-        __ lh(result, mem_operand);
+        __ Lh(result, mem_operand);
         break;
       case UINT16_ELEMENTS:
-        __ lhu(result, mem_operand);
+        __ Lhu(result, mem_operand);
         break;
       case INT32_ELEMENTS:
-        __ lw(result, mem_operand);
+        __ Lw(result, mem_operand);
         break;
       case UINT32_ELEMENTS:
-        __ lw(result, mem_operand);
+        __ Lw(result, mem_operand);
         if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
           DeoptimizeIf(Ugreater_equal, instr, DeoptimizeReason::kNegativeValue,
                        result, Operand(0x80000000));
         }
         break;
       case FLOAT32_ELEMENTS:
       case FLOAT64_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_SMI_ELEMENTS:
@@ skipping 40 matching lines @@
     if (shift_size > 0) {
       __ dsll(at, key, shift_size);
     } else if (shift_size == -32) {
       __ dsra32(at, key, 0);
     } else {
       __ dsra(at, key, -shift_size);
     }
     __ Daddu(scratch, scratch, at);
   }
 
-  __ ldc1(result, MemOperand(scratch));
+  __ Ldc1(result, MemOperand(scratch));
 
   if (instr->hydrogen()->RequiresHoleCheck()) {
     __ FmoveHigh(scratch, result);
     DeoptimizeIf(eq, instr, DeoptimizeReason::kHole, scratch,
                  Operand(static_cast<int32_t>(kHoleNanUpper32)));
   }
 }
 
 
 void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
@@ skipping 55 matching lines @@
     DCHECK(instr->hydrogen()->elements_kind() == FAST_HOLEY_ELEMENTS);
     Label done;
     __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
     __ Branch(&done, ne, result, Operand(scratch));
     if (info()->IsStub()) {
       // A stub can safely convert the hole to undefined only if the array
       // protector cell contains (Smi) Isolate::kProtectorValid. Otherwise
       // it needs to bail out.
       __ LoadRoot(result, Heap::kArrayProtectorRootIndex);
       // The comparison only needs LS bits of value, which is a smi.
-      __ ld(result, FieldMemOperand(result, PropertyCell::kValueOffset));
+      __ Ld(result, FieldMemOperand(result, PropertyCell::kValueOffset));
       DeoptimizeIf(ne, instr, DeoptimizeReason::kHole, result,
                    Operand(Smi::FromInt(Isolate::kProtectorValid)));
     }
     __ LoadRoot(result, Heap::kUndefinedValueRootIndex);
     __ bind(&done);
   }
 }
 
 
 void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
@@ skipping 53 matching lines @@
 void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
   Register scratch = scratch0();
   Register temp = scratch1();
   Register result = ToRegister(instr->result());
 
   if (instr->hydrogen()->from_inlined()) {
     __ Dsubu(result, sp, 2 * kPointerSize);
   } else if (instr->hydrogen()->arguments_adaptor()) {
     // Check if the calling frame is an arguments adaptor frame.
     Label done, adapted;
-    __ ld(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-    __ ld(result,
+    __ Ld(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+    __ Ld(result,
           MemOperand(scratch, CommonFrameConstants::kContextOrFrameTypeOffset));
     __ Xor(temp, result,
            Operand(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)));
 
     // Result is the frame pointer for the frame if not adapted and for the real
     // frame below the adaptor frame if adapted.
     __ Movn(result, fp, temp);  // Move only if temp is not equal to zero (ne).
     __ Movz(result, scratch, temp);  // Move only if temp is equal to zero (eq).
   } else {
     __ mov(result, fp);
   }
 }
 
 
 void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
   Register elem = ToRegister(instr->elements());
   Register result = ToRegister(instr->result());
 
   Label done;
 
   // If no arguments adaptor frame the number of arguments is fixed.
   __ Daddu(result, zero_reg, Operand(scope()->num_parameters()));
   __ Branch(&done, eq, fp, Operand(elem));
 
   // Arguments adaptor frame present. Get argument length from there.
-  __ ld(result, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-  __ ld(result,
+  __ Ld(result, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  __ Ld(result,
         MemOperand(result, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ SmiUntag(result);
 
   // Argument length is in result register.
   __ bind(&done);
 }
 
 
 void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
   Register receiver = ToRegister(instr->receiver());
   Register function = ToRegister(instr->function());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
 
   // If the receiver is null or undefined, we have to pass the global
   // object as a receiver to normal functions. Values have to be
   // passed unchanged to builtins and strict-mode functions.
   Label global_object, result_in_receiver;
 
   if (!instr->hydrogen()->known_function()) {
     // Do not transform the receiver to object for strict mode functions.
-    __ ld(scratch,
-           FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
+    __ Ld(scratch,
+          FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
 
     // Do not transform the receiver to object for builtins.
     int32_t strict_mode_function_mask =
         1 <<  SharedFunctionInfo::kStrictModeBitWithinByte;
     int32_t native_mask = 1 << SharedFunctionInfo::kNativeBitWithinByte;
 
-    __ lbu(at,
+    __ Lbu(at,
            FieldMemOperand(scratch, SharedFunctionInfo::kStrictModeByteOffset));
     __ And(at, at, Operand(strict_mode_function_mask));
     __ Branch(&result_in_receiver, ne, at, Operand(zero_reg));
-    __ lbu(at,
-           FieldMemOperand(scratch, SharedFunctionInfo::kNativeByteOffset));
+    __ Lbu(at, FieldMemOperand(scratch, SharedFunctionInfo::kNativeByteOffset));
     __ And(at, at, Operand(native_mask));
     __ Branch(&result_in_receiver, ne, at, Operand(zero_reg));
   }
 
   // Normal function. Replace undefined or null with global receiver.
   __ LoadRoot(scratch, Heap::kNullValueRootIndex);
   __ Branch(&global_object, eq, receiver, Operand(scratch));
   __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
   __ Branch(&global_object, eq, receiver, Operand(scratch));
 
   // Deoptimize if the receiver is not a JS object.
   __ SmiTst(receiver, scratch);
   DeoptimizeIf(eq, instr, DeoptimizeReason::kSmi, scratch, Operand(zero_reg));
 
   __ GetObjectType(receiver, scratch, scratch);
   DeoptimizeIf(lt, instr, DeoptimizeReason::kNotAJavaScriptObject, scratch,
                Operand(FIRST_JS_RECEIVER_TYPE));
   __ Branch(&result_in_receiver);
 
   __ bind(&global_object);
-  __ ld(result, FieldMemOperand(function, JSFunction::kContextOffset));
-  __ ld(result, ContextMemOperand(result, Context::NATIVE_CONTEXT_INDEX));
-  __ ld(result, ContextMemOperand(result, Context::GLOBAL_PROXY_INDEX));
+  __ Ld(result, FieldMemOperand(function, JSFunction::kContextOffset));
+  __ Ld(result, ContextMemOperand(result, Context::NATIVE_CONTEXT_INDEX));
+  __ Ld(result, ContextMemOperand(result, Context::GLOBAL_PROXY_INDEX));
 
   if (result.is(receiver)) {
     __ bind(&result_in_receiver);
   } else {
     Label result_ok;
     __ Branch(&result_ok);
     __ bind(&result_in_receiver);
     __ mov(result, receiver);
     __ bind(&result_ok);
   }
@@ skipping 24 matching lines @@
   __ Daddu(elements, elements, Operand(1 * kPointerSize));
 
   // Loop through the arguments pushing them onto the execution
   // stack.
   Label invoke, loop;
   // length is a small non-negative integer, due to the test above.
   __ Branch(USE_DELAY_SLOT, &invoke, eq, length, Operand(zero_reg));
   __ dsll(scratch, length, kPointerSizeLog2);
   __ bind(&loop);
   __ Daddu(scratch, elements, scratch);
-  __ ld(scratch, MemOperand(scratch));
+  __ Ld(scratch, MemOperand(scratch));
   __ push(scratch);
   __ Dsubu(length, length, Operand(1));
   __ Branch(USE_DELAY_SLOT, &loop, ne, length, Operand(zero_reg));
   __ dsll(scratch, length, kPointerSizeLog2);
 
   __ bind(&invoke);
 
   InvokeFlag flag = CALL_FUNCTION;
   if (instr->hydrogen()->tail_call_mode() == TailCallMode::kAllow) {
     DCHECK(!info()->saves_caller_doubles());
@@ skipping 26 matching lines @@
 }
 
 
 void LCodeGen::DoDrop(LDrop* instr) {
   __ Drop(instr->count());
 }
 
 
 void LCodeGen::DoThisFunction(LThisFunction* instr) {
   Register result = ToRegister(instr->result());
-  __ ld(result, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+  __ Ld(result, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
 }
 
 
 void LCodeGen::DoContext(LContext* instr) {
   // If there is a non-return use, the context must be moved to a register.
   Register result = ToRegister(instr->result());
   if (info()->IsOptimizing()) {
-    __ ld(result, MemOperand(fp, StandardFrameConstants::kContextOffset));
+    __ Ld(result, MemOperand(fp, StandardFrameConstants::kContextOffset));
   } else {
     // If there is no frame, the context must be in cp.
     DCHECK(result.is(cp));
   }
 }
 
 
 void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
   DCHECK(ToRegister(instr->context()).is(cp));
   __ li(scratch0(), instr->hydrogen()->declarations());
@@ skipping 10 matching lines @@
   bool dont_adapt_arguments =
       formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
   bool can_invoke_directly =
       dont_adapt_arguments || formal_parameter_count == arity;
 
   Register function_reg = a1;
   LPointerMap* pointers = instr->pointer_map();
 
   if (can_invoke_directly) {
     // Change context.
-    __ ld(cp, FieldMemOperand(function_reg, JSFunction::kContextOffset));
+    __ Ld(cp, FieldMemOperand(function_reg, JSFunction::kContextOffset));
 
     // Always initialize new target and number of actual arguments.
     __ LoadRoot(a3, Heap::kUndefinedValueRootIndex);
     __ li(a0, Operand(arity));
 
     bool is_self_call = function.is_identical_to(info()->closure());
 
     // Invoke function.
     if (is_self_call) {
       Handle<Code> self(reinterpret_cast<Code**>(__ CodeObject().location()));
       if (is_tail_call) {
         __ Jump(self, RelocInfo::CODE_TARGET);
       } else {
         __ Call(self, RelocInfo::CODE_TARGET);
       }
     } else {
-      __ ld(at, FieldMemOperand(function_reg, JSFunction::kCodeEntryOffset));
+      __ Ld(at, FieldMemOperand(function_reg, JSFunction::kCodeEntryOffset));
       if (is_tail_call) {
         __ Jump(at);
       } else {
         __ Call(at);
       }
     }
 
     if (!is_tail_call) {
       // Set up deoptimization.
       RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
     }
   } else {
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount actual(arity);
     ParameterCount expected(formal_parameter_count);
     InvokeFlag flag = is_tail_call ? JUMP_FUNCTION : CALL_FUNCTION;
     __ InvokeFunction(function_reg, expected, actual, flag, generator);
   }
 }
 
 
 void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr) {
   DCHECK(instr->context() != NULL);
   DCHECK(ToRegister(instr->context()).is(cp));
   Register input = ToRegister(instr->value());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
 
   // Deoptimize if not a heap number.
-  __ ld(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
+  __ Ld(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
   __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
   DeoptimizeIf(ne, instr, DeoptimizeReason::kNotAHeapNumber, scratch,
                Operand(at));
 
   Label done;
   Register exponent = scratch0();
   scratch = no_reg;
-  __ lwu(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
+  __ Lwu(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
   // Check the sign of the argument. If the argument is positive, just
   // return it.
   __ Move(result, input);
   __ And(at, exponent, Operand(HeapNumber::kSignMask));
   __ Branch(&done, eq, at, Operand(zero_reg));
 
   // Input is negative. Reverse its sign.
   // Preserve the value of all registers.
   {
     PushSafepointRegistersScope scope(this);
@@ skipping 15 matching lines @@
     // Slow case: Call the runtime system to do the number allocation.
     __ bind(&slow);
 
     CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr,
                             instr->context());
     // Set the pointer to the new heap number in tmp.
     if (!tmp1.is(v0))
       __ mov(tmp1, v0);
     // Restore input_reg after call to runtime.
     __ LoadFromSafepointRegisterSlot(input, input);
-    __ lwu(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
+    __ Lwu(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
 
     __ bind(&allocated);
     // exponent: floating point exponent value.
     // tmp1: allocated heap number.
     __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
-    __ sw(exponent, FieldMemOperand(tmp1, HeapNumber::kExponentOffset));
-    __ lwu(tmp2, FieldMemOperand(input, HeapNumber::kMantissaOffset));
-    __ sw(tmp2, FieldMemOperand(tmp1, HeapNumber::kMantissaOffset));
+    __ Sw(exponent, FieldMemOperand(tmp1, HeapNumber::kExponentOffset));
+    __ Lwu(tmp2, FieldMemOperand(input, HeapNumber::kMantissaOffset));
+    __ Sw(tmp2, FieldMemOperand(tmp1, HeapNumber::kMantissaOffset));
 
     __ StoreToSafepointRegisterSlot(tmp1, result);
   }
 
   __ bind(&done);
 }
 
 
 void LCodeGen::EmitIntegerMathAbs(LMathAbs* instr) {
   Register input = ToRegister(instr->value());
@@ skipping 225 matching lines @@
   DCHECK(ToDoubleRegister(instr->left()).is(f2));
   DCHECK(ToDoubleRegister(instr->result()).is(f0));
 
   if (exponent_type.IsSmi()) {
     MathPowStub stub(isolate(), MathPowStub::TAGGED);
     __ CallStub(&stub);
   } else if (exponent_type.IsTagged()) {
     Label no_deopt;
     __ JumpIfSmi(tagged_exponent, &no_deopt);
     DCHECK(!a7.is(tagged_exponent));
-    __ lw(a7, FieldMemOperand(tagged_exponent, HeapObject::kMapOffset));
+    __ Lw(a7, FieldMemOperand(tagged_exponent, HeapObject::kMapOffset));
     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
     DeoptimizeIf(ne, instr, DeoptimizeReason::kNotAHeapNumber, a7, Operand(at));
     __ bind(&no_deopt);
     MathPowStub stub(isolate(), MathPowStub::TAGGED);
     __ CallStub(&stub);
   } else if (exponent_type.IsInteger32()) {
     MathPowStub stub(isolate(), MathPowStub::INTEGER);
     __ CallStub(&stub);
   } else {
     DCHECK(exponent_type.IsDouble());
@@ skipping 54 matching lines @@
               RegisterConfiguration::Crankshaft()->GetGeneralRegisterName(
                   actual.reg().code()));
     } else {
       Comment(";;; PrepareForTailCall, actual: %d {", actual.immediate());
     }
   }
 
   // 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, MemOperand(scratch2, StandardFrameConstants::kContextOffset));
+  __ Ld(scratch2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  __ Ld(scratch3, MemOperand(scratch2, StandardFrameConstants::kContextOffset));
   __ 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);
-  __ ld(caller_args_count_reg,
+  __ Ld(caller_args_count_reg,
         MemOperand(fp, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ SmiUntag(caller_args_count_reg);
   __ Branch(&formal_parameter_count_loaded);
 
   __ bind(&no_arguments_adaptor);
   // Load caller's formal parameter count
   __ li(caller_args_count_reg, Operand(info()->literal()->parameter_count()));
 
   __ bind(&formal_parameter_count_loaded);
   __ PrepareForTailCall(actual, caller_args_count_reg, scratch2, scratch3);
@@ skipping 84 matching lines @@
 
   if (instr->arity() == 0) {
     ArrayNoArgumentConstructorStub stub(isolate(), kind, override_mode);
     CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
   } else if (instr->arity() == 1) {
     Label done;
     if (IsFastPackedElementsKind(kind)) {
       Label packed_case;
       // We might need a change here,
       // look at the first argument.
-      __ ld(a5, MemOperand(sp, 0));
+      __ Ld(a5, MemOperand(sp, 0));
       __ Branch(&packed_case, eq, a5, Operand(zero_reg));
 
       ElementsKind holey_kind = GetHoleyElementsKind(kind);
       ArraySingleArgumentConstructorStub stub(isolate(),
                                               holey_kind,
                                               override_mode);
       CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
       __ jmp(&done);
       __ bind(&packed_case);
     }
@@ skipping 11 matching lines @@
 void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
   CallRuntime(instr->function(), instr->arity(), instr);
 }
 
 
 void LCodeGen::DoStoreCodeEntry(LStoreCodeEntry* instr) {
   Register function = ToRegister(instr->function());
   Register code_object = ToRegister(instr->code_object());
   __ Daddu(code_object, code_object,
           Operand(Code::kHeaderSize - kHeapObjectTag));
-  __ sd(code_object,
-        FieldMemOperand(function, JSFunction::kCodeEntryOffset));
+  __ Sd(code_object, FieldMemOperand(function, JSFunction::kCodeEntryOffset));
 }
 
 
 void LCodeGen::DoInnerAllocatedObject(LInnerAllocatedObject* instr) {
   Register result = ToRegister(instr->result());
   Register base = ToRegister(instr->base_object());
   if (instr->offset()->IsConstantOperand()) {
     LConstantOperand* offset = LConstantOperand::cast(instr->offset());
     __ Daddu(result, base, Operand(ToInteger32(offset)));
   } else {
@@ skipping 22 matching lines @@
   __ AssertNotSmi(object);
 
   DCHECK(!representation.IsSmi() ||
          !instr->value()->IsConstantOperand() ||
          IsSmi(LConstantOperand::cast(instr->value())));
   if (!FLAG_unbox_double_fields && representation.IsDouble()) {
     DCHECK(access.IsInobject());
     DCHECK(!instr->hydrogen()->has_transition());
     DCHECK(!instr->hydrogen()->NeedsWriteBarrier());
     DoubleRegister value = ToDoubleRegister(instr->value());
-    __ sdc1(value, FieldMemOperand(object, offset));
+    __ Sdc1(value, FieldMemOperand(object, offset));
     return;
   }
 
   if (instr->hydrogen()->has_transition()) {
     Handle<Map> transition = instr->hydrogen()->transition_map();
     AddDeprecationDependency(transition);
     __ li(scratch1, Operand(transition));
-    __ sd(scratch1, FieldMemOperand(object, HeapObject::kMapOffset));
+    __ Sd(scratch1, FieldMemOperand(object, HeapObject::kMapOffset));
     if (instr->hydrogen()->NeedsWriteBarrierForMap()) {
       Register temp = ToRegister(instr->temp());
       // Update the write barrier for the map field.
       __ RecordWriteForMap(object,
                            scratch1,
                            temp,
                            GetRAState(),
                            kSaveFPRegs);
     }
   }
 
   // Do the store.
   Register destination = object;
   if (!access.IsInobject()) {
        destination = scratch1;
-    __ ld(destination, FieldMemOperand(object, JSObject::kPropertiesOffset));
+       __ Ld(destination, FieldMemOperand(object, JSObject::kPropertiesOffset));
   }
 
   if (representation.IsSmi() && SmiValuesAre32Bits() &&
       instr->hydrogen()->value()->representation().IsInteger32()) {
     DCHECK(instr->hydrogen()->store_mode() == STORE_TO_INITIALIZED_ENTRY);
     if (FLAG_debug_code) {
       __ Load(scratch2, FieldMemOperand(destination, offset), representation);
       __ AssertSmi(scratch2);
     }
     // Store int value directly to upper half of the smi.
     offset = SmiWordOffset(offset);
     representation = Representation::Integer32();
   }
   MemOperand operand = FieldMemOperand(destination, offset);
 
   if (FLAG_unbox_double_fields && representation.IsDouble()) {
     DCHECK(access.IsInobject());
     DoubleRegister value = ToDoubleRegister(instr->value());
-    __ sdc1(value, operand);
+    __ Sdc1(value, operand);
   } else {
     DCHECK(instr->value()->IsRegister());
     Register value = ToRegister(instr->value());
     __ Store(value, operand, representation);
   }
 
   if (instr->hydrogen()->NeedsWriteBarrier()) {
     // Update the write barrier for the object for in-object properties.
     Register value = ToRegister(instr->value());
     __ RecordWriteField(destination,
@@ skipping 70 matching lines @@
           __ dsra(address, key, -shift_size);
         }
       } else {
         __ dsll(address, key, shift_size);
       }
       __ Daddu(address, external_pointer, address);
     }
 
     if (elements_kind == FLOAT32_ELEMENTS) {
       __ cvt_s_d(double_scratch0(), value);
-      __ swc1(double_scratch0(), MemOperand(address, base_offset));
+      __ Swc1(double_scratch0(), MemOperand(address, base_offset));
     } else {  // Storing doubles, not floats.
-      __ sdc1(value, MemOperand(address, base_offset));
+      __ Sdc1(value, MemOperand(address, base_offset));
     }
   } else {
     Register value(ToRegister(instr->value()));
     MemOperand mem_operand = PrepareKeyedOperand(
         key, external_pointer, key_is_constant, constant_key,
         element_size_shift, shift_size,
         base_offset);
     switch (elements_kind) {
       case UINT8_ELEMENTS:
       case UINT8_CLAMPED_ELEMENTS:
       case INT8_ELEMENTS:
-        __ sb(value, mem_operand);
+        __ Sb(value, mem_operand);
         break;
       case INT16_ELEMENTS:
       case UINT16_ELEMENTS:
-        __ sh(value, mem_operand);
+        __ Sh(value, mem_operand);
         break;
       case INT32_ELEMENTS:
       case UINT32_ELEMENTS:
-        __ sw(value, mem_operand);
+        __ Sw(value, mem_operand);
         break;
       case FLOAT32_ELEMENTS:
       case FLOAT64_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_SMI_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case DICTIONARY_ELEMENTS:
@@ skipping 37 matching lines @@
     if (shift_size == 3) {
       __ dsll(at, ToRegister(instr->key()), 3);
     } else if (shift_size == -29) {
       __ dsra(at, ToRegister(instr->key()), 29);
     }
     __ Daddu(scratch, scratch, at);
   }
 
   if (instr->NeedsCanonicalization()) {
     __ FPUCanonicalizeNaN(double_scratch, value);
-    __ sdc1(double_scratch, MemOperand(scratch, 0));
+    __ Sdc1(double_scratch, MemOperand(scratch, 0));
   } else {
-    __ sdc1(value, MemOperand(scratch, 0));
+    __ Sdc1(value, MemOperand(scratch, 0));
   }
 }
 
 
 void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
   Register value = ToRegister(instr->value());
   Register elements = ToRegister(instr->elements());
   Register key = instr->key()->IsRegister() ? ToRegister(instr->key())
       : no_reg;
   Register scratch = scratch0();
@@ skipping 110 matching lines @@
     __ Branch(deferred->entry(), ge, ToRegister(key),
               Operand(constant_capacity));
   } else {
     __ Branch(deferred->entry(), ge, ToRegister(key),
               Operand(ToRegister(current_capacity)));
   }
 
   if (instr->elements()->IsRegister()) {
     __ mov(result, ToRegister(instr->elements()));
   } else {
-    __ ld(result, ToMemOperand(instr->elements()));
+    __ Ld(result, ToMemOperand(instr->elements()));
   }
 
   __ bind(deferred->exit());
 }
 
 
 void LCodeGen::DoDeferredMaybeGrowElements(LMaybeGrowElements* instr) {
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   Register result = v0;
   __ mov(result, zero_reg);
 
   // We have to call a stub.
   {
     PushSafepointRegistersScope scope(this);
     if (instr->object()->IsRegister()) {
       __ mov(result, ToRegister(instr->object()));
     } else {
-      __ ld(result, ToMemOperand(instr->object()));
+      __ Ld(result, ToMemOperand(instr->object()));
     }
 
     LOperand* key = instr->key();
     if (key->IsConstantOperand()) {
       __ li(a3, Operand(ToSmi(LConstantOperand::cast(key))));
     } else {
       __ mov(a3, ToRegister(key));
       __ SmiTag(a3);
     }
 
@@ skipping 14 matching lines @@
 void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
   Register object_reg = ToRegister(instr->object());
   Register scratch = scratch0();
 
   Handle<Map> from_map = instr->original_map();
   Handle<Map> to_map = instr->transitioned_map();
   ElementsKind from_kind = instr->from_kind();
   ElementsKind to_kind = instr->to_kind();
 
   Label not_applicable;
-  __ ld(scratch, FieldMemOperand(object_reg, HeapObject::kMapOffset));
+  __ Ld(scratch, FieldMemOperand(object_reg, HeapObject::kMapOffset));
   __ Branch(&not_applicable, ne, scratch, Operand(from_map));
 
   if (IsSimpleMapChangeTransition(from_kind, to_kind)) {
     Register new_map_reg = ToRegister(instr->new_map_temp());
     __ li(new_map_reg, Operand(to_map));
-    __ sd(new_map_reg, FieldMemOperand(object_reg, HeapObject::kMapOffset));
+    __ Sd(new_map_reg, FieldMemOperand(object_reg, HeapObject::kMapOffset));
     // Write barrier.
     __ RecordWriteForMap(object_reg,
                          new_map_reg,
                          scratch,
                          GetRAState(),
                          kDontSaveFPRegs);
   } else {
     DCHECK(object_reg.is(a0));
     DCHECK(ToRegister(instr->context()).is(cp));
     PushSafepointRegistersScope scope(this);
@@ skipping 102 matching lines @@
   DCHECK(instr->hydrogen()->value()->representation().IsInteger32());
   Register char_code = ToRegister(instr->char_code());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
   DCHECK(!char_code.is(result));
 
   __ Branch(deferred->entry(), hi,
             char_code, Operand(String::kMaxOneByteCharCode));
   __ LoadRoot(result, Heap::kSingleCharacterStringCacheRootIndex);
   __ Dlsa(result, result, char_code, kPointerSizeLog2);
-  __ ld(result, FieldMemOperand(result, FixedArray::kHeaderSize));
+  __ Ld(result, FieldMemOperand(result, FixedArray::kHeaderSize));
   __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
   __ Branch(deferred->entry(), eq, result, Operand(scratch));
   __ bind(deferred->exit());
 }
 
 
 void LCodeGen::DoDeferredStringCharFromCode(LStringCharFromCode* instr) {
   Register char_code = ToRegister(instr->char_code());
   Register result = ToRegister(instr->result());
 
@@ skipping 12 matching lines @@
 
 
 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
   LOperand* input = instr->value();
   DCHECK(input->IsRegister() || input->IsStackSlot());
   LOperand* output = instr->result();
   DCHECK(output->IsDoubleRegister());
   FPURegister single_scratch = double_scratch0().low();
   if (input->IsStackSlot()) {
     Register scratch = scratch0();
-    __ ld(scratch, ToMemOperand(input));
+    __ Ld(scratch, ToMemOperand(input));
     __ mtc1(scratch, single_scratch);
   } else {
     __ mtc1(ToRegister(input), single_scratch);
   }
   __ cvt_d_w(ToDoubleRegister(output), single_scratch);
 }
 
 
 void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
   LOperand* input = instr->value();
@@ skipping 82 matching lines @@
     }
     __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
     __ StoreToSafepointRegisterSlot(v0, dst);
   }
 
   // Done. Put the value in dbl_scratch into the value of the allocated heap
   // number.
   __ bind(&done);
-  __ sdc1(dbl_scratch, FieldMemOperand(dst, HeapNumber::kValueOffset));
+  __ Sdc1(dbl_scratch, FieldMemOperand(dst, HeapNumber::kValueOffset));
 }
 
 
 void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
   class DeferredNumberTagD final : public LDeferredCode {
    public:
     DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
     LInstruction* instr() override { return instr_; }
@@ skipping 10 matching lines @@
 
   DeferredNumberTagD* deferred = new(zone()) DeferredNumberTagD(this, instr);
   if (FLAG_inline_new) {
     __ LoadRoot(scratch, Heap::kHeapNumberMapRootIndex);
     // We want the untagged address first for performance
     __ AllocateHeapNumber(reg, temp1, temp2, scratch, deferred->entry());
   } else {
     __ Branch(deferred->entry());
   }
   __ bind(deferred->exit());
-  __ sdc1(input_reg, FieldMemOperand(reg, HeapNumber::kValueOffset));
+  __ Sdc1(input_reg, FieldMemOperand(reg, HeapNumber::kValueOffset));
 }
 
 
 void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   Register reg = ToRegister(instr->result());
   __ mov(reg, zero_reg);
 
@@ skipping 50 matching lines @@
                                 NumberUntagDMode mode) {
   bool can_convert_undefined_to_nan = instr->truncating();
   bool deoptimize_on_minus_zero = instr->hydrogen()->deoptimize_on_minus_zero();
 
   Register scratch = scratch0();
   Label convert, load_smi, done;
   if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
     // Smi check.
     __ UntagAndJumpIfSmi(scratch, input_reg, &load_smi);
     // Heap number map check.
-    __ ld(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+    __ Ld(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
     if (can_convert_undefined_to_nan) {
       __ Branch(&convert, ne, scratch, Operand(at));
     } else {
       DeoptimizeIf(ne, instr, DeoptimizeReason::kNotAHeapNumber, scratch,
                    Operand(at));
     }
     // Load heap number.
-    __ ldc1(result_reg, FieldMemOperand(input_reg, HeapNumber::kValueOffset));
+    __ Ldc1(result_reg, FieldMemOperand(input_reg, HeapNumber::kValueOffset));
     if (deoptimize_on_minus_zero) {
       __ mfc1(at, result_reg);
       __ Branch(&done, ne, at, Operand(zero_reg));
       __ mfhc1(scratch, result_reg);  // Get exponent/sign bits.
       DeoptimizeIf(eq, instr, DeoptimizeReason::kMinusZero, scratch,
                    Operand(HeapNumber::kSignMask));
     }
     __ Branch(&done);
     if (can_convert_undefined_to_nan) {
       __ bind(&convert);
       // Convert undefined (and hole) to NaN.
       __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
       DeoptimizeIf(ne, instr, DeoptimizeReason::kNotAHeapNumberUndefined,
                    input_reg, Operand(at));
       __ LoadRoot(scratch, Heap::kNanValueRootIndex);
-      __ ldc1(result_reg, FieldMemOperand(scratch, HeapNumber::kValueOffset));
+      __ Ldc1(result_reg, FieldMemOperand(scratch, HeapNumber::kValueOffset));
       __ Branch(&done);
     }
   } else {
     __ SmiUntag(scratch, input_reg);
     DCHECK(mode == NUMBER_CANDIDATE_IS_SMI);
   }
   // Smi to double register conversion
   __ bind(&load_smi);
   // scratch: untagged value of input_reg
   __ mtc1(scratch, result_reg);
   __ cvt_d_w(result_reg, result_reg);
   __ bind(&done);
 }
 
 
 void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
   Register input_reg = ToRegister(instr->value());
   Register scratch1 = scratch0();
   Register scratch2 = ToRegister(instr->temp());
   DoubleRegister double_scratch = double_scratch0();
   DoubleRegister double_scratch2 = ToDoubleRegister(instr->temp2());
 
   DCHECK(!scratch1.is(input_reg) && !scratch1.is(scratch2));
   DCHECK(!scratch2.is(input_reg) && !scratch2.is(scratch1));
 
   Label done;
 
   // The input is a tagged HeapObject.
   // Heap number map check.
-  __ ld(scratch1, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+  __ Ld(scratch1, FieldMemOperand(input_reg, HeapObject::kMapOffset));
   __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
   // This 'at' value and scratch1 map value are used for tests in both clauses
   // of the if.
 
   if (instr->truncating()) {
     Label truncate;
     __ Branch(USE_DELAY_SLOT, &truncate, eq, scratch1, Operand(at));
     __ mov(scratch2, input_reg);  // In delay slot.
-    __ lbu(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
+    __ Lbu(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
     DeoptimizeIf(ne, instr, DeoptimizeReason::kNotANumberOrOddball, scratch1,
                  Operand(ODDBALL_TYPE));
     __ bind(&truncate);
     __ TruncateHeapNumberToI(input_reg, scratch2);
   } else {
     DeoptimizeIf(ne, instr, DeoptimizeReason::kNotAHeapNumber, scratch1,
                  Operand(at));
 
     // Load the double value.
-    __ ldc1(double_scratch,
+    __ Ldc1(double_scratch,
             FieldMemOperand(input_reg, HeapNumber::kValueOffset));
 
     Register except_flag = scratch2;
     __ EmitFPUTruncate(kRoundToZero,
                        input_reg,
                        double_scratch,
                        scratch1,
                        double_scratch2,
                        except_flag,
                        kCheckForInexactConversion);
@@ skipping 149 matching lines @@
     DeoptimizeIf(eq, instr, DeoptimizeReason::kSmi, at, Operand(zero_reg));
   }
 }
 
 
 void LCodeGen::DoCheckArrayBufferNotNeutered(
     LCheckArrayBufferNotNeutered* instr) {
   Register view = ToRegister(instr->view());
   Register scratch = scratch0();
 
-  __ ld(scratch, FieldMemOperand(view, JSArrayBufferView::kBufferOffset));
-  __ lw(scratch, FieldMemOperand(scratch, JSArrayBuffer::kBitFieldOffset));
+  __ Ld(scratch, FieldMemOperand(view, JSArrayBufferView::kBufferOffset));
+  __ Lw(scratch, FieldMemOperand(scratch, JSArrayBuffer::kBitFieldOffset));
   __ And(at, scratch, 1 << JSArrayBuffer::WasNeutered::kShift);
   DeoptimizeIf(ne, instr, DeoptimizeReason::kOutOfBounds, at,
                Operand(zero_reg));
 }
 
 
 void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
   Register input = ToRegister(instr->value());
   Register scratch = scratch0();
 
@@ skipping 37 matching lines @@
 
 
 void LCodeGen::DoCheckValue(LCheckValue* instr) {
   Register reg = ToRegister(instr->value());
   Handle<HeapObject> object = instr->hydrogen()->object().handle();
   AllowDeferredHandleDereference smi_check;
   if (isolate()->heap()->InNewSpace(*object)) {
     Register reg = ToRegister(instr->value());
     Handle<Cell> cell = isolate()->factory()->NewCell(object);
     __ li(at, Operand(cell));
-    __ ld(at, FieldMemOperand(at, Cell::kValueOffset));
+    __ Ld(at, FieldMemOperand(at, Cell::kValueOffset));
     DeoptimizeIf(ne, instr, DeoptimizeReason::kValueMismatch, reg, Operand(at));
   } else {
     DeoptimizeIf(ne, instr, DeoptimizeReason::kValueMismatch, reg,
                  Operand(object));
   }
 }
 
 
 void LCodeGen::DoDeferredInstanceMigration(LCheckMaps* instr, Register object) {
   Label deopt, done;
   // If the map is not deprecated the migration attempt does not make sense.
-  __ ld(scratch0(), FieldMemOperand(object, HeapObject::kMapOffset));
-  __ lwu(scratch0(), FieldMemOperand(scratch0(), Map::kBitField3Offset));
+  __ Ld(scratch0(), FieldMemOperand(object, HeapObject::kMapOffset));
+  __ Lwu(scratch0(), FieldMemOperand(scratch0(), Map::kBitField3Offset));
   __ And(at, scratch0(), Operand(Map::Deprecated::kMask));
   __ Branch(&deopt, eq, at, Operand(zero_reg));
 
   {
     PushSafepointRegistersScope scope(this);
     __ push(object);
     __ mov(cp, zero_reg);
     __ CallRuntimeSaveDoubles(Runtime::kTryMigrateInstance);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 1, Safepoint::kNoLazyDeopt);
@@ skipping 36 matching lines @@
     for (int i = 0; i < maps->size(); ++i) {
       AddStabilityDependency(maps->at(i).handle());
     }
     return;
   }
 
   Register map_reg = scratch0();
   LOperand* input = instr->value();
   DCHECK(input->IsRegister());
   Register reg = ToRegister(input);
-  __ ld(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));
+  __ Ld(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));
 
   DeferredCheckMaps* deferred = NULL;
   if (instr->hydrogen()->HasMigrationTarget()) {
     deferred = new(zone()) DeferredCheckMaps(this, instr, reg);
     __ bind(deferred->check_maps());
   }
 
   const UniqueSet<Map>* maps = instr->hydrogen()->maps();
   Label success;
   for (int i = 0; i < maps->size() - 1; i++) {
@@ skipping 31 matching lines @@
   Register scratch = scratch0();
   Register input_reg = ToRegister(instr->unclamped());
   Register result_reg = ToRegister(instr->result());
   DoubleRegister temp_reg = ToDoubleRegister(instr->temp());
   Label is_smi, done, heap_number;
 
   // Both smi and heap number cases are handled.
   __ UntagAndJumpIfSmi(scratch, input_reg, &is_smi);
 
   // Check for heap number
-  __ ld(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+  __ Ld(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
   __ Branch(&heap_number, eq, scratch, Operand(factory()->heap_number_map()));
 
   // Check for undefined. Undefined is converted to zero for clamping
   // conversions.
   DeoptimizeIf(ne, instr, DeoptimizeReason::kNotAHeapNumberUndefined, input_reg,
                Operand(factory()->undefined_value()));
   __ mov(result_reg, zero_reg);
   __ jmp(&done);
 
   // Heap number
   __ bind(&heap_number);
-  __ ldc1(double_scratch0(), FieldMemOperand(input_reg,
-                                             HeapNumber::kValueOffset));
+  __ Ldc1(double_scratch0(),
+          FieldMemOperand(input_reg, HeapNumber::kValueOffset));
   __ ClampDoubleToUint8(result_reg, double_scratch0(), temp_reg);
   __ jmp(&done);
 
   __ bind(&is_smi);
   __ ClampUint8(result_reg, scratch);
 
   __ bind(&done);
 }
 
 
@@ skipping 48 matching lines @@
       int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
       __ li(scratch, Operand(size - kHeapObjectTag));
     } else {
       __ Dsubu(scratch, ToRegister(instr->size()), Operand(kHeapObjectTag));
     }
     __ li(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
     Label loop;
     __ bind(&loop);
     __ Dsubu(scratch, scratch, Operand(kPointerSize));
     __ Daddu(at, result, Operand(scratch));
-    __ sd(scratch2, MemOperand(at));
+    __ Sd(scratch2, MemOperand(at));
     __ Branch(&loop, ge, scratch, Operand(zero_reg));
   }
 }
 
 
 void LCodeGen::DoDeferredAllocate(LAllocate* instr) {
   Register result = ToRegister(instr->result());
 
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
@@ skipping 40 matching lines @@
       allocation_flags = static_cast<AllocationFlags>(flags | PRETENURE);
     }
     // If the allocation folding dominator allocate triggered a GC, allocation
     // happend in the runtime. We have to reset the top pointer to virtually
     // undo the allocation.
     ExternalReference allocation_top =
         AllocationUtils::GetAllocationTopReference(isolate(), allocation_flags);
     Register top_address = scratch0();
     __ Dsubu(v0, v0, Operand(kHeapObjectTag));
     __ li(top_address, Operand(allocation_top));
-    __ sd(v0, MemOperand(top_address));
+    __ Sd(v0, MemOperand(top_address));
     __ Daddu(v0, v0, Operand(kHeapObjectTag));
   }
 }
 
 void LCodeGen::DoFastAllocate(LFastAllocate* instr) {
   DCHECK(instr->hydrogen()->IsAllocationFolded());
   DCHECK(!instr->hydrogen()->IsAllocationFoldingDominator());
   Register result = ToRegister(instr->result());
   Register scratch1 = ToRegister(instr->temp1());
   Register scratch2 = ToRegister(instr->temp2());
@@ skipping 61 matching lines @@
                                  Register* cmp1,
                                  Operand* cmp2) {
   // This function utilizes the delay slot heavily. This is used to load
   // values that are always usable without depending on the type of the input
   // register.
   Condition final_branch_condition = kNoCondition;
   Register scratch = scratch0();
   Factory* factory = isolate()->factory();
   if (String::Equals(type_name, factory->number_string())) {
     __ JumpIfSmi(input, true_label);
-    __ ld(input, FieldMemOperand(input, HeapObject::kMapOffset));
+    __ Ld(input, FieldMemOperand(input, HeapObject::kMapOffset));
     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
     *cmp1 = input;
     *cmp2 = Operand(at);
     final_branch_condition = eq;
 
   } else if (String::Equals(type_name, factory->string_string())) {
     __ JumpIfSmi(input, false_label);
     __ GetObjectType(input, input, scratch);
     *cmp1 = scratch;
     *cmp2 = Operand(FIRST_NONSTRING_TYPE);
@@ skipping 14 matching lines @@
     *cmp2 = Operand(input);
     final_branch_condition = eq;
 
   } else if (String::Equals(type_name, factory->undefined_string())) {
     __ LoadRoot(at, Heap::kNullValueRootIndex);
     __ Branch(USE_DELAY_SLOT, false_label, eq, at, Operand(input));
     // The first instruction of JumpIfSmi is an And - it is safe in the delay
     // slot.
     __ JumpIfSmi(input, false_label);
     // Check for undetectable objects => true.
-    __ ld(input, FieldMemOperand(input, HeapObject::kMapOffset));
-    __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
+    __ Ld(input, FieldMemOperand(input, HeapObject::kMapOffset));
+    __ Lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
     __ And(at, at, 1 << Map::kIsUndetectable);
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);
     final_branch_condition = ne;
 
   } else if (String::Equals(type_name, factory->function_string())) {
     __ JumpIfSmi(input, false_label);
-    __ ld(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
-    __ lbu(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
+    __ Ld(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
+    __ Lbu(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
     __ And(scratch, scratch,
            Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
     *cmp1 = scratch;
     *cmp2 = Operand(1 << Map::kIsCallable);
     final_branch_condition = eq;
 
   } else if (String::Equals(type_name, factory->object_string())) {
     __ JumpIfSmi(input, false_label);
     __ LoadRoot(at, Heap::kNullValueRootIndex);
     __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
     STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
     __ GetObjectType(input, scratch, scratch1());
     __ Branch(false_label, lt, scratch1(), Operand(FIRST_JS_RECEIVER_TYPE));
     // Check for callable or undetectable objects => false.
-    __ lbu(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
+    __ Lbu(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
     __ And(at, scratch,
            Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);
     final_branch_condition = eq;
 
   } else {
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);  // Set to valid regs, to avoid caller assertion.
     __ Branch(false_label);
@@ skipping 128 matching lines @@
 
 
 void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {
   Register result = ToRegister(instr->result());
   Register object = ToRegister(instr->object());
 
   Label use_cache, call_runtime;
   DCHECK(object.is(a0));
   __ CheckEnumCache(&call_runtime);
 
-  __ ld(result, FieldMemOperand(object, HeapObject::kMapOffset));
+  __ Ld(result, FieldMemOperand(object, HeapObject::kMapOffset));
   __ Branch(&use_cache);
 
   // Get the set of properties to enumerate.
   __ bind(&call_runtime);
   __ push(object);
   CallRuntime(Runtime::kForInEnumerate, instr);
   __ bind(&use_cache);
 }
 
 
 void LCodeGen::DoForInCacheArray(LForInCacheArray* instr) {
   Register map = ToRegister(instr->map());
   Register result = ToRegister(instr->result());
   Label load_cache, done;
   __ EnumLength(result, map);
   __ Branch(&load_cache, ne, result, Operand(Smi::kZero));
   __ li(result, Operand(isolate()->factory()->empty_fixed_array()));
   __ jmp(&done);
 
   __ bind(&load_cache);
   __ LoadInstanceDescriptors(map, result);
-  __ ld(result,
-        FieldMemOperand(result, DescriptorArray::kEnumCacheOffset));
-  __ ld(result,
-        FieldMemOperand(result, FixedArray::SizeFor(instr->idx())));
+  __ Ld(result, FieldMemOperand(result, DescriptorArray::kEnumCacheOffset));
+  __ Ld(result, FieldMemOperand(result, FixedArray::SizeFor(instr->idx())));
   DeoptimizeIf(eq, instr, DeoptimizeReason::kNoCache, result,
                Operand(zero_reg));
 
   __ bind(&done);
 }
 
 
 void LCodeGen::DoCheckMapValue(LCheckMapValue* instr) {
   Register object = ToRegister(instr->value());
   Register map = ToRegister(instr->map());
-  __ ld(scratch0(), FieldMemOperand(object, HeapObject::kMapOffset));
+  __ Ld(scratch0(), FieldMemOperand(object, HeapObject::kMapOffset));
   DeoptimizeIf(ne, instr, DeoptimizeReason::kWrongMap, map,
                Operand(scratch0()));
 }
 
 
 void LCodeGen::DoDeferredLoadMutableDouble(LLoadFieldByIndex* instr,
                                            Register result,
                                            Register object,
                                            Register index) {
   PushSafepointRegistersScope scope(this);
@@ skipping 43 matching lines @@
 
   Label out_of_object, done;
 
   __ And(scratch, index, Operand(Smi::FromInt(1)));
   __ Branch(deferred->entry(), ne, scratch, Operand(zero_reg));
   __ dsra(index, index, 1);
 
   __ Branch(USE_DELAY_SLOT, &out_of_object, lt, index, Operand(zero_reg));
   __ SmiScale(scratch, index, kPointerSizeLog2);  // In delay slot.
   __ Daddu(scratch, object, scratch);
-  __ ld(result, FieldMemOperand(scratch, JSObject::kHeaderSize));
+  __ Ld(result, FieldMemOperand(scratch, JSObject::kHeaderSize));
 
   __ Branch(&done);
 
   __ bind(&out_of_object);
-  __ ld(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
+  __ Ld(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Dsubu(scratch, result, scratch);
-  __ ld(result, FieldMemOperand(scratch,
-                                FixedArray::kHeaderSize - kPointerSize));
+  __ Ld(result,
+        FieldMemOperand(scratch, FixedArray::kHeaderSize - kPointerSize));
   __ bind(deferred->exit());
   __ bind(&done);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8