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

src/full-codegen/mips64/full-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.
 
 #if V8_TARGET_ARCH_MIPS64
 
 // Note on Mips implementation:
 //
 // The result_register() for mips is the 'v0' register, which is defined
 // by the ABI to contain function return values. However, the first
@@ skipping 105 matching lines @@
   CompilationInfo* info = info_;
   profiling_counter_ = isolate()->factory()->NewCell(
       Handle<Smi>(Smi::FromInt(FLAG_interrupt_budget), isolate()));
   SetFunctionPosition(literal());
   Comment cmnt(masm_, "[ function compiled by full code generator");
 
   ProfileEntryHookStub::MaybeCallEntryHook(masm_);
 
   if (FLAG_debug_code && info->ExpectsJSReceiverAsReceiver()) {
     int receiver_offset = info->scope()->num_parameters() * kPointerSize;
-    __ ld(a2, MemOperand(sp, receiver_offset));
+    __ Ld(a2, MemOperand(sp, receiver_offset));
     __ AssertNotSmi(a2);
     __ GetObjectType(a2, a2, a2);
     __ Check(ge, kSloppyFunctionExpectsJSReceiverReceiver, a2,
              Operand(FIRST_JS_RECEIVER_TYPE));
   }
 
   // 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);
   info->set_prologue_offset(masm_->pc_offset());
   __ Prologue(info->GeneratePreagedPrologue());
 
   // Increment invocation count for the function.
   {
     Comment cmnt(masm_, "[ Increment invocation count");
-    __ 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));
   }
 
   { Comment cmnt(masm_, "[ Allocate locals");
     int locals_count = info->scope()->num_stack_slots();
     OperandStackDepthIncrement(locals_count);
     if (locals_count > 0) {
       if (locals_count >= 128) {
         Label ok;
         __ Dsubu(t1, sp, Operand(locals_count * kPointerSize));
         __ LoadRoot(a2, Heap::kRealStackLimitRootIndex);
         __ Branch(&ok, hs, t1, Operand(a2));
         __ CallRuntime(Runtime::kThrowStackOverflow);
         __ bind(&ok);
       }
       __ LoadRoot(t1, Heap::kUndefinedValueRootIndex);
       int kMaxPushes = FLAG_optimize_for_size ? 4 : 32;
       if (locals_count >= kMaxPushes) {
         int loop_iterations = locals_count / kMaxPushes;
         __ li(a2, Operand(loop_iterations));
         Label loop_header;
         __ bind(&loop_header);
         // Do pushes.
         __ Dsubu(sp, sp, Operand(kMaxPushes * kPointerSize));
         for (int i = 0; i < kMaxPushes; i++) {
-          __ sd(t1, MemOperand(sp, i * kPointerSize));
+          __ Sd(t1, MemOperand(sp, i * kPointerSize));
         }
         // Continue loop if not done.
         __ Dsubu(a2, a2, Operand(1));
         __ Branch(&loop_header, ne, a2, Operand(zero_reg));
       }
       int remaining = locals_count % kMaxPushes;
       // Emit the remaining pushes.
       __ Dsubu(sp, sp, Operand(remaining * kPointerSize));
       for (int i  = 0; i < remaining; i++) {
-        __ sd(t1, MemOperand(sp, i * kPointerSize));
+        __ Sd(t1, MemOperand(sp, i * kPointerSize));
       }
     }
   }
 
   bool function_in_register_a1 = true;
 
   // Possibly allocate a local context.
   if (info->scope()->NeedsContext()) {
     Comment cmnt(masm_, "[ Allocate context");
     // Argument to NewContext is the function, which is still in a1.
@@ skipping 25 matching lines @@
         __ CallRuntime(Runtime::kNewFunctionContext);
       }
       if (info->scope()->new_target_var() != nullptr) {
         __ pop(a3);  // Restore new target.
       }
     }
     function_in_register_a1 = false;
     // Context is returned in 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.
         if (need_write_barrier) {
           __ RecordWriteContextSlot(cp, target.offset(), a0, a2,
                                     kRAHasBeenSaved, kDontSaveFPRegs);
         } else if (FLAG_debug_code) {
           Label done;
           __ JumpIfInNewSpace(cp, a0, &done);
           __ Abort(kExpectedNewSpaceObject);
           __ bind(&done);
@@ skipping 12 matching lines @@
   DCHECK_NULL(info->scope()->new_target_var());
   DCHECK_NULL(info->scope()->rest_parameter());
   DCHECK_NULL(info->scope()->this_function_var());
 
   Variable* arguments = info->scope()->arguments();
   if (arguments != NULL) {
     // Function uses arguments object.
     Comment cmnt(masm_, "[ Allocate arguments object");
     if (!function_in_register_a1) {
       // Load this again, if it's used by the local context below.
-      __ ld(a1, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+      __ Ld(a1, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
     }
     if (is_strict(language_mode()) || !has_simple_parameters()) {
       Callable callable = CodeFactory::FastNewStrictArguments(isolate());
       __ Call(callable.code(), RelocInfo::CODE_TARGET);
       RestoreContext();
     } else if (literal()->has_duplicate_parameters()) {
       __ Push(a1);
       __ CallRuntime(Runtime::kNewSloppyArguments_Generic);
     } else {
       Callable callable = CodeFactory::FastNewSloppyArguments(isolate());
@@ skipping 54 matching lines @@
 
 
 void FullCodeGenerator::ClearAccumulator() {
   DCHECK(Smi::kZero == 0);
   __ mov(v0, zero_reg);
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
   __ li(a2, Operand(profiling_counter_));
-  __ ld(a3, FieldMemOperand(a2, Cell::kValueOffset));
+  __ Ld(a3, FieldMemOperand(a2, Cell::kValueOffset));
   __ Dsubu(a3, a3, Operand(Smi::FromInt(delta)));
-  __ sd(a3, FieldMemOperand(a2, Cell::kValueOffset));
+  __ Sd(a3, FieldMemOperand(a2, Cell::kValueOffset));
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterReset() {
   int reset_value = FLAG_interrupt_budget;
   if (info_->is_debug()) {
     // Detect debug break requests as soon as possible.
     reset_value = FLAG_interrupt_budget >> 4;
   }
   __ li(a2, Operand(profiling_counter_));
   __ li(a3, Operand(Smi::FromInt(reset_value)));
-  __ sd(a3, FieldMemOperand(a2, Cell::kValueOffset));
+  __ Sd(a3, FieldMemOperand(a2, Cell::kValueOffset));
 }
 
 
 void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,
                                                 Label* back_edge_target) {
   // The generated code is used in Deoptimizer::PatchStackCheckCodeAt so we need
   // to make sure it is constant. Branch may emit a skip-or-jump sequence
   // instead of the normal Branch. It seems that the "skip" part of that
   // sequence is about as long as this Branch would be so it is safe to ignore
   // that.
@@ skipping 70 matching lines @@
       SetReturnPosition(literal());
       __ mov(sp, fp);
       __ MultiPop(static_cast<RegList>(fp.bit() | ra.bit()));
       __ Daddu(sp, sp, Operand(sp_delta));
       __ Jump(ra);
     }
   }
 }
 
 void FullCodeGenerator::RestoreContext() {
-  __ ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  __ Ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
 }
 
 void FullCodeGenerator::StackValueContext::Plug(Variable* var) const {
   DCHECK(var->IsStackAllocated() || var->IsContextSlot());
   codegen()->GetVar(result_register(), var);
   codegen()->PushOperand(result_register());
 }
 
 
 void FullCodeGenerator::EffectContext::Plug(Heap::RootListIndex index) const {
@@ skipping 75 matching lines @@
     __ li(result_register(), Operand(lit));
     codegen()->DoTest(this);
   }
 }
 
 
 void FullCodeGenerator::StackValueContext::DropAndPlug(int count,
                                                        Register reg) const {
   DCHECK(count > 0);
   if (count > 1) codegen()->DropOperands(count - 1);
-  __ sd(reg, MemOperand(sp, 0));
+  __ Sd(reg, MemOperand(sp, 0));
 }
 
 
 void FullCodeGenerator::EffectContext::Plug(Label* materialize_true,
                                             Label* materialize_false) const {
   DCHECK(materialize_true == materialize_false);
   __ bind(materialize_true);
 }
 
 
@@ skipping 113 matching lines @@
     return ContextMemOperand(scratch, var->index());
   } else {
     return StackOperand(var);
   }
 }
 
 
 void FullCodeGenerator::GetVar(Register dest, Variable* var) {
   // Use destination as scratch.
   MemOperand location = VarOperand(var, dest);
-  __ ld(dest, location);
+  __ Ld(dest, location);
 }
 
 
 void FullCodeGenerator::SetVar(Variable* var,
                                Register src,
                                Register scratch0,
                                Register scratch1) {
   DCHECK(var->IsContextSlot() || var->IsStackAllocated());
   DCHECK(!scratch0.is(src));
   DCHECK(!scratch0.is(scratch1));
   DCHECK(!scratch1.is(src));
   MemOperand location = VarOperand(var, scratch0);
-  __ sd(src, location);
+  __ Sd(src, location);
   // Emit the write barrier code if the location is in the heap.
   if (var->IsContextSlot()) {
     __ RecordWriteContextSlot(scratch0,
                               location.offset(),
                               src,
                               scratch1,
                               kRAHasBeenSaved,
                               kDontSaveFPRegs);
   }
 }
@@ skipping 18 matching lines @@
   }
 }
 
 
 void FullCodeGenerator::EmitDebugCheckDeclarationContext(Variable* variable) {
   // The variable in the declaration always resides in the current function
   // context.
   DCHECK_EQ(0, scope()->ContextChainLength(variable->scope()));
   if (FLAG_debug_code) {
     // Check that we're not inside a with or catch context.
-    __ ld(a1, FieldMemOperand(cp, HeapObject::kMapOffset));
+    __ Ld(a1, FieldMemOperand(cp, HeapObject::kMapOffset));
     __ LoadRoot(a4, Heap::kWithContextMapRootIndex);
     __ Check(ne, kDeclarationInWithContext,
         a1, Operand(a4));
     __ LoadRoot(a4, Heap::kCatchContextMapRootIndex);
     __ Check(ne, kDeclarationInCatchContext,
         a1, Operand(a4));
   }
 }
 
 
@@ skipping 10 matching lines @@
       globals_->Add(handle(Smi::FromInt(slot.ToInt()), isolate()), zone());
       globals_->Add(isolate()->factory()->undefined_value(), zone());
       globals_->Add(isolate()->factory()->undefined_value(), zone());
       break;
     }
     case VariableLocation::PARAMETER:
     case VariableLocation::LOCAL:
       if (variable->binding_needs_init()) {
         Comment cmnt(masm_, "[ VariableDeclaration");
         __ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
-        __ sd(a4, StackOperand(variable));
+        __ Sd(a4, StackOperand(variable));
       }
       break;
 
     case VariableLocation::CONTEXT:
       if (variable->binding_needs_init()) {
         Comment cmnt(masm_, "[ VariableDeclaration");
         EmitDebugCheckDeclarationContext(variable);
           __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
-          __ sd(at, ContextMemOperand(cp, variable->index()));
+          __ Sd(at, ContextMemOperand(cp, variable->index()));
           // No write barrier since the_hole_value is in old space.
           PrepareForBailoutForId(proxy->id(), BailoutState::NO_REGISTERS);
       }
       break;
 
     case VariableLocation::LOOKUP:
     case VariableLocation::MODULE:
       UNREACHABLE();
   }
 }
@@ skipping 20 matching lines @@
       // Check for stack-overflow exception.
       if (function.is_null()) return SetStackOverflow();
       globals_->Add(function, zone());
       break;
     }
 
     case VariableLocation::PARAMETER:
     case VariableLocation::LOCAL: {
       Comment cmnt(masm_, "[ FunctionDeclaration");
       VisitForAccumulatorValue(declaration->fun());
-      __ sd(result_register(), StackOperand(variable));
+      __ Sd(result_register(), StackOperand(variable));
       break;
     }
 
     case VariableLocation::CONTEXT: {
       Comment cmnt(masm_, "[ FunctionDeclaration");
       EmitDebugCheckDeclarationContext(variable);
       VisitForAccumulatorValue(declaration->fun());
-      __ sd(result_register(), ContextMemOperand(cp, variable->index()));
+      __ Sd(result_register(), ContextMemOperand(cp, variable->index()));
       int offset = Context::SlotOffset(variable->index());
       // We know that we have written a function, which is not a smi.
       __ RecordWriteContextSlot(cp,
                                 offset,
                                 result_register(),
                                 a2,
                                 kRAHasBeenSaved,
                                 kDontSaveFPRegs,
                                 EMIT_REMEMBERED_SET,
                                 OMIT_SMI_CHECK);
@@ skipping 45 matching lines @@
 
     Comment cmnt(masm_, "[ Case comparison");
     __ bind(&next_test);
     next_test.Unuse();
 
     // Compile the label expression.
     VisitForAccumulatorValue(clause->label());
     __ mov(a0, result_register());  // CompareStub requires args in a0, a1.
 
     // Perform the comparison as if via '==='.
-    __ ld(a1, MemOperand(sp, 0));  // Switch value.
+    __ Ld(a1, MemOperand(sp, 0));  // Switch value.
     bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);
     JumpPatchSite patch_site(masm_);
     if (inline_smi_code) {
       Label slow_case;
       __ or_(a2, a1, a0);
       patch_site.EmitJumpIfNotSmi(a2, &slow_case);
 
       __ Branch(&next_test, ne, a1, Operand(a0));
       __ Drop(1);  // Switch value is no longer needed.
       __ Branch(clause->body_target());
@@ skipping 85 matching lines @@
   // Check cache validity in generated code. If we cannot guarantee cache
   // validity, call the runtime system to check cache validity or get the
   // property names in a fixed array. Note: Proxies never have an enum cache,
   // so will always take the slow path.
   Label call_runtime;
   __ CheckEnumCache(&call_runtime);
 
   // The enum cache is valid.  Load the map of the object being
   // iterated over and use the cache for the iteration.
   Label use_cache;
-  __ ld(v0, FieldMemOperand(a0, HeapObject::kMapOffset));
+  __ Ld(v0, FieldMemOperand(a0, HeapObject::kMapOffset));
   __ Branch(&use_cache);
 
   // Get the set of properties to enumerate.
   __ bind(&call_runtime);
   __ push(a0);  // Duplicate the enumerable object on the stack.
   __ CallRuntime(Runtime::kForInEnumerate);
   PrepareForBailoutForId(stmt->EnumId(), BailoutState::TOS_REGISTER);
 
   // If we got a map from the runtime call, we can do a fast
   // modification check. Otherwise, we got a fixed array, and we have
   // to do a slow check.
   Label fixed_array;
-  __ ld(a2, FieldMemOperand(v0, HeapObject::kMapOffset));
+  __ Ld(a2, FieldMemOperand(v0, HeapObject::kMapOffset));
   __ LoadRoot(at, Heap::kMetaMapRootIndex);
   __ Branch(&fixed_array, ne, a2, Operand(at));
 
   // We got a map in register v0. Get the enumeration cache from it.
   Label no_descriptors;
   __ bind(&use_cache);
 
   __ EnumLength(a1, v0);
   __ Branch(&no_descriptors, eq, a1, Operand(Smi::kZero));
 
   __ LoadInstanceDescriptors(v0, a2);
-  __ ld(a2, FieldMemOperand(a2, DescriptorArray::kEnumCacheOffset));
-  __ ld(a2, FieldMemOperand(a2, DescriptorArray::kEnumCacheBridgeCacheOffset));
+  __ Ld(a2, FieldMemOperand(a2, DescriptorArray::kEnumCacheOffset));
+  __ Ld(a2, FieldMemOperand(a2, DescriptorArray::kEnumCacheBridgeCacheOffset));
 
   // Set up the four remaining stack slots.
   __ li(a0, Operand(Smi::kZero));
   // Push map, enumeration cache, enumeration cache length (as smi) and zero.
   __ Push(v0, a2, a1, a0);
   __ jmp(&loop);
 
   __ bind(&no_descriptors);
   __ Drop(1);
   __ jmp(&exit);
 
   // We got a fixed array in register v0. Iterate through that.
   __ bind(&fixed_array);
 
   __ li(a1, Operand(Smi::FromInt(1)));  // Smi(1) indicates slow check
   __ Push(a1, v0);  // Smi and array
-  __ ld(a1, FieldMemOperand(v0, FixedArray::kLengthOffset));
+  __ Ld(a1, FieldMemOperand(v0, FixedArray::kLengthOffset));
   __ Push(a1);  // Fixed array length (as smi).
   PrepareForBailoutForId(stmt->PrepareId(), BailoutState::NO_REGISTERS);
   __ li(a0, Operand(Smi::kZero));
   __ Push(a0);  // Initial index.
 
   // Generate code for doing the condition check.
   __ bind(&loop);
   SetExpressionAsStatementPosition(stmt->each());
 
   // Load the current count to a0, load the length to a1.
-  __ ld(a0, MemOperand(sp, 0 * kPointerSize));
-  __ ld(a1, MemOperand(sp, 1 * kPointerSize));
+  __ Ld(a0, MemOperand(sp, 0 * kPointerSize));
+  __ Ld(a1, MemOperand(sp, 1 * kPointerSize));
   __ Branch(loop_statement.break_label(), hs, a0, Operand(a1));
 
   // Get the current entry of the array into register a3.
-  __ ld(a2, MemOperand(sp, 2 * kPointerSize));
+  __ Ld(a2, MemOperand(sp, 2 * kPointerSize));
   __ Daddu(a2, a2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
   __ SmiScale(a4, a0, kPointerSizeLog2);
   __ daddu(a4, a2, a4);  // Array base + scaled (smi) index.
-  __ ld(result_register(), MemOperand(a4));  // Current entry.
+  __ Ld(result_register(), MemOperand(a4));  // Current entry.
 
   // Get the expected map from the stack or a smi in the
   // permanent slow case into register a2.
-  __ ld(a2, MemOperand(sp, 3 * kPointerSize));
+  __ Ld(a2, MemOperand(sp, 3 * kPointerSize));
 
   // Check if the expected map still matches that of the enumerable.
   // If not, we may have to filter the key.
   Label update_each;
-  __ ld(a1, MemOperand(sp, 4 * kPointerSize));
-  __ ld(a4, FieldMemOperand(a1, HeapObject::kMapOffset));
+  __ Ld(a1, MemOperand(sp, 4 * kPointerSize));
+  __ Ld(a4, FieldMemOperand(a1, HeapObject::kMapOffset));
   __ Branch(&update_each, eq, a4, Operand(a2));
 
   // We need to filter the key, record slow-path here.
   int const vector_index = SmiFromSlot(slot)->value();
   __ EmitLoadFeedbackVector(a3);
   __ li(a2, Operand(FeedbackVector::MegamorphicSentinel(isolate())));
-  __ sd(a2, FieldMemOperand(a3, FixedArray::OffsetOfElementAt(vector_index)));
+  __ Sd(a2, FieldMemOperand(a3, FixedArray::OffsetOfElementAt(vector_index)));
 
   __ mov(a0, result_register());
   // a0 contains the key. The receiver in a1 is the second argument to the
   // ForInFilter. ForInFilter returns undefined if the receiver doesn't
   // have the key or returns the name-converted key.
   __ Call(isolate()->builtins()->ForInFilter(), RelocInfo::CODE_TARGET);
   RestoreContext();
   PrepareForBailoutForId(stmt->FilterId(), BailoutState::TOS_REGISTER);
   __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
   __ Branch(loop_statement.continue_label(), eq, result_register(),
@@ skipping 30 matching lines @@
 
   // Exit and decrement the loop depth.
   PrepareForBailoutForId(stmt->ExitId(), BailoutState::NO_REGISTERS);
   __ bind(&exit);
   decrement_loop_depth();
 }
 
 void FullCodeGenerator::EmitSetHomeObject(Expression* initializer, int offset,
                                           FeedbackSlot slot) {
   DCHECK(NeedsHomeObject(initializer));
-  __ ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp));
-  __ ld(StoreDescriptor::ValueRegister(),
+  __ Ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp));
+  __ Ld(StoreDescriptor::ValueRegister(),
         MemOperand(sp, offset * kPointerSize));
   CallStoreIC(slot, isolate()->factory()->home_object_symbol());
 }
 
 void FullCodeGenerator::EmitSetHomeObjectAccumulator(Expression* initializer,
                                                      int offset,
                                                      FeedbackSlot slot) {
   DCHECK(NeedsHomeObject(initializer));
   __ Move(StoreDescriptor::ReceiverRegister(), v0);
-  __ ld(StoreDescriptor::ValueRegister(),
+  __ Ld(StoreDescriptor::ValueRegister(),
         MemOperand(sp, offset * kPointerSize));
   CallStoreIC(slot, isolate()->factory()->home_object_symbol());
 }
 
 void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy,
                                          TypeofMode typeof_mode) {
   // Record position before possible IC call.
   SetExpressionPosition(proxy);
   PrepareForBailoutForId(proxy->BeforeId(), BailoutState::NO_REGISTERS);
   Variable* var = proxy->var();
@@ skipping 54 matching lines @@
     }
   }
 }
 
 
 void FullCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
 
   Handle<BoilerplateDescription> constant_properties =
       expr->GetOrBuildConstantProperties(isolate());
-  __ ld(a3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+  __ Ld(a3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ li(a2, Operand(SmiFromSlot(expr->literal_slot())));
   __ li(a1, Operand(constant_properties));
   __ li(a0, Operand(Smi::FromInt(expr->ComputeFlags())));
   if (MustCreateObjectLiteralWithRuntime(expr)) {
     __ Push(a3, a2, a1, a0);
     __ CallRuntime(Runtime::kCreateObjectLiteral);
   } else {
     Callable callable = CodeFactory::FastCloneShallowObject(
         isolate(), expr->properties_count());
     __ Call(callable.code(), RelocInfo::CODE_TARGET);
@@ skipping 26 matching lines @@
         // Fall through.
       case ObjectLiteral::Property::COMPUTED:
         // It is safe to use [[Put]] here because the boilerplate already
         // contains computed properties with an uninitialized value.
         if (key->IsStringLiteral()) {
           DCHECK(key->IsPropertyName());
           if (property->emit_store()) {
             VisitForAccumulatorValue(value);
             __ mov(StoreDescriptor::ValueRegister(), result_register());
             DCHECK(StoreDescriptor::ValueRegister().is(a0));
-            __ ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp));
+            __ Ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp));
             CallStoreIC(property->GetSlot(0), key->value(), kStoreOwn);
             PrepareForBailoutForId(key->id(), BailoutState::NO_REGISTERS);
 
             if (NeedsHomeObject(value)) {
               EmitSetHomeObjectAccumulator(value, 0, property->GetSlot(1));
             }
           } else {
             VisitForEffect(value);
           }
           break;
         }
         // Duplicate receiver on stack.
-        __ ld(a0, MemOperand(sp));
+        __ Ld(a0, MemOperand(sp));
         PushOperand(a0);
         VisitForStackValue(key);
         VisitForStackValue(value);
         if (property->emit_store()) {
           if (NeedsHomeObject(value)) {
             EmitSetHomeObject(value, 2, property->GetSlot());
           }
           __ li(a0, Operand(Smi::FromInt(SLOPPY)));  // PropertyAttributes.
           PushOperand(a0);
           CallRuntimeWithOperands(Runtime::kSetProperty);
         } else {
           DropOperands(3);
         }
         break;
       case ObjectLiteral::Property::PROTOTYPE:
         // Duplicate receiver on stack.
-        __ ld(a0, MemOperand(sp));
+        __ Ld(a0, MemOperand(sp));
         PushOperand(a0);
         VisitForStackValue(value);
         DCHECK(property->emit_store());
         CallRuntimeWithOperands(Runtime::kInternalSetPrototype);
         PrepareForBailoutForId(expr->GetIdForPropertySet(i),
                                BailoutState::NO_REGISTERS);
         break;
       case ObjectLiteral::Property::GETTER:
         if (property->emit_store()) {
           AccessorTable::Iterator it = accessor_table.lookup(key);
           it->second->bailout_id = expr->GetIdForPropertySet(i);
           it->second->getter = property;
         }
         break;
       case ObjectLiteral::Property::SETTER:
         if (property->emit_store()) {
           AccessorTable::Iterator it = accessor_table.lookup(key);
           it->second->bailout_id = expr->GetIdForPropertySet(i);
           it->second->setter = property;
         }
         break;
     }
   }
 
   // Emit code to define accessors, using only a single call to the runtime for
   // each pair of corresponding getters and setters.
   for (AccessorTable::Iterator it = accessor_table.begin();
        it != accessor_table.end();
        ++it) {
-    __ ld(a0, MemOperand(sp));  // Duplicate receiver.
+    __ Ld(a0, MemOperand(sp));  // Duplicate receiver.
     PushOperand(a0);
     VisitForStackValue(it->first);
     EmitAccessor(it->second->getter);
     EmitAccessor(it->second->setter);
     __ li(a0, Operand(Smi::FromInt(NONE)));
     PushOperand(a0);
     CallRuntimeWithOperands(Runtime::kDefineAccessorPropertyUnchecked);
     PrepareForBailoutForId(it->second->bailout_id, BailoutState::NO_REGISTERS);
   }
 
   if (result_saved) {
     context()->PlugTOS();
   } else {
     context()->Plug(v0);
   }
 }
 
 
 void FullCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   Comment cmnt(masm_, "[ ArrayLiteral");
 
   Handle<ConstantElementsPair> constant_elements =
       expr->GetOrBuildConstantElements(isolate());
 
   __ mov(a0, result_register());
-  __ ld(a3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+  __ Ld(a3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ li(a2, Operand(SmiFromSlot(expr->literal_slot())));
   __ li(a1, Operand(constant_elements));
   if (MustCreateArrayLiteralWithRuntime(expr)) {
     __ li(a0, Operand(Smi::FromInt(expr->ComputeFlags())));
     __ Push(a3, a2, a1, a0);
     __ CallRuntime(Runtime::kCreateArrayLiteral);
   } else {
     Callable callable =
         CodeFactory::FastCloneShallowArray(isolate(), TRACK_ALLOCATION_SITE);
     __ Call(callable.code(), RelocInfo::CODE_TARGET);
@@ skipping 16 matching lines @@
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
 
     if (!result_saved) {
       PushOperand(v0);  // array literal
       result_saved = true;
     }
 
     VisitForAccumulatorValue(subexpr);
 
     __ li(StoreDescriptor::NameRegister(), Operand(Smi::FromInt(array_index)));
-    __ ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+    __ Ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp, 0));
     __ mov(StoreDescriptor::ValueRegister(), result_register());
     CallKeyedStoreIC(expr->LiteralFeedbackSlot());
 
     PrepareForBailoutForId(expr->GetIdForElement(array_index),
                            BailoutState::NO_REGISTERS);
   }
 
   if (result_saved) {
     context()->PlugTOS();
   } else {
@@ skipping 12 matching lines @@
 
   // Evaluate LHS expression.
   switch (assign_type) {
     case VARIABLE:
       // Nothing to do here.
       break;
     case NAMED_PROPERTY:
       if (expr->is_compound()) {
         // We need the receiver both on the stack and in the register.
         VisitForStackValue(property->obj());
-        __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+        __ Ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
       } else {
         VisitForStackValue(property->obj());
       }
       break;
     case KEYED_PROPERTY:
       // We need the key and receiver on both the stack and in v0 and a1.
       if (expr->is_compound()) {
         VisitForStackValue(property->obj());
         VisitForStackValue(property->key());
-        __ ld(LoadDescriptor::ReceiverRegister(),
+        __ Ld(LoadDescriptor::ReceiverRegister(),
               MemOperand(sp, 1 * kPointerSize));
-        __ ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+        __ Ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
       } else {
         VisitForStackValue(property->obj());
         VisitForStackValue(property->key());
       }
       break;
     case NAMED_SUPER_PROPERTY:
     case KEYED_SUPER_PROPERTY:
       UNREACHABLE();
       break;
   }
@@ skipping 115 matching lines @@
   __ bind(&allocate);
   __ Push(Smi::FromInt(JSIteratorResult::kSize));
   __ CallRuntime(Runtime::kAllocateInNewSpace);
 
   __ bind(&done_allocate);
   __ LoadNativeContextSlot(Context::ITERATOR_RESULT_MAP_INDEX, a1);
   PopOperand(a2);
   __ LoadRoot(a3,
               done ? Heap::kTrueValueRootIndex : Heap::kFalseValueRootIndex);
   __ LoadRoot(a4, Heap::kEmptyFixedArrayRootIndex);
-  __ sd(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
-  __ sd(a4, FieldMemOperand(v0, JSObject::kPropertiesOffset));
-  __ sd(a4, FieldMemOperand(v0, JSObject::kElementsOffset));
-  __ sd(a2, FieldMemOperand(v0, JSIteratorResult::kValueOffset));
-  __ sd(a3, FieldMemOperand(v0, JSIteratorResult::kDoneOffset));
+  __ Sd(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
+  __ Sd(a4, FieldMemOperand(v0, JSObject::kPropertiesOffset));
+  __ Sd(a4, FieldMemOperand(v0, JSObject::kElementsOffset));
+  __ Sd(a2, FieldMemOperand(v0, JSIteratorResult::kValueOffset));
+  __ Sd(a3, FieldMemOperand(v0, JSIteratorResult::kDoneOffset));
   STATIC_ASSERT(JSIteratorResult::kSize == 5 * kPointerSize);
 }
 
 
 void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
                                               Token::Value op,
                                               Expression* left_expr,
                                               Expression* right_expr) {
   Label done, smi_case, stub_call;
 
@@ skipping 125 matching lines @@
     case KEYED_SUPER_PROPERTY:
       UNREACHABLE();
       break;
   }
   context()->Plug(v0);
 }
 
 
 void FullCodeGenerator::EmitStoreToStackLocalOrContextSlot(
     Variable* var, MemOperand location) {
-  __ sd(result_register(), location);
+  __ Sd(result_register(), location);
   if (var->IsContextSlot()) {
     // RecordWrite may destroy all its register arguments.
     __ Move(a3, result_register());
     int offset = Context::SlotOffset(var->index());
     __ RecordWriteContextSlot(
         a1, offset, a3, a2, kRAHasBeenSaved, kDontSaveFPRegs);
   }
 }
 
 void FullCodeGenerator::EmitVariableAssignment(Variable* var, Token::Value op,
                                                FeedbackSlot slot,
                                                HoleCheckMode hole_check_mode) {
   if (var->IsUnallocated()) {
     // Global var, const, or let.
     __ mov(StoreDescriptor::ValueRegister(), result_register());
     __ LoadGlobalObject(StoreDescriptor::ReceiverRegister());
     CallStoreIC(slot, var->name(), kStoreGlobal);
 
   } else if (IsLexicalVariableMode(var->mode()) && op != Token::INIT) {
     DCHECK(!var->IsLookupSlot());
     DCHECK(var->IsStackAllocated() || var->IsContextSlot());
     MemOperand location = VarOperand(var, a1);
     // Perform an initialization check for lexically declared variables.
     if (hole_check_mode == HoleCheckMode::kRequired) {
       Label assign;
-      __ ld(a3, location);
+      __ Ld(a3, location);
       __ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
       __ Branch(&assign, ne, a3, Operand(a4));
       __ li(a3, Operand(var->name()));
       __ push(a3);
       __ CallRuntime(Runtime::kThrowReferenceError);
       __ bind(&assign);
     }
     if (var->mode() != CONST) {
       EmitStoreToStackLocalOrContextSlot(var, location);
     } else if (var->throw_on_const_assignment(language_mode())) {
       __ CallRuntime(Runtime::kThrowConstAssignError);
     }
   } else if (var->is_this() && var->mode() == CONST && op == Token::INIT) {
     // Initializing assignment to const {this} needs a write barrier.
     DCHECK(var->IsStackAllocated() || var->IsContextSlot());
     Label uninitialized_this;
     MemOperand location = VarOperand(var, a1);
-    __ ld(a3, location);
+    __ Ld(a3, location);
     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
     __ Branch(&uninitialized_this, eq, a3, Operand(at));
     __ li(a0, Operand(var->name()));
     __ Push(a0);
     __ CallRuntime(Runtime::kThrowReferenceError);
     __ bind(&uninitialized_this);
     EmitStoreToStackLocalOrContextSlot(var, location);
 
   } else {
     DCHECK(var->mode() != CONST || op == Token::INIT);
     DCHECK((var->IsStackAllocated() || var->IsContextSlot()));
     DCHECK(!var->IsLookupSlot());
     // Assignment to var or initializing assignment to let/const in harmony
     // mode.
     MemOperand location = VarOperand(var, a1);
     if (FLAG_debug_code && var->mode() == LET && op == Token::INIT) {
       // Check for an uninitialized let binding.
-      __ ld(a2, location);
+      __ Ld(a2, location);
       __ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
       __ Check(eq, kLetBindingReInitialization, a2, Operand(a4));
     }
     EmitStoreToStackLocalOrContextSlot(var, location);
   }
 }
 
 
 void FullCodeGenerator::EmitNamedPropertyAssignment(Assignment* expr) {
   // Assignment to a property, using a named store IC.
@@ skipping 41 matching lines @@
     }
     // Push undefined as receiver. This is patched in the method prologue if it
     // is a sloppy mode method.
     __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
     PushOperand(at);
     convert_mode = ConvertReceiverMode::kNullOrUndefined;
   } else {
     // Load the function from the receiver.
     DCHECK(callee->IsProperty());
     DCHECK(!callee->AsProperty()->IsSuperAccess());
-    __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+    __ Ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
     EmitNamedPropertyLoad(callee->AsProperty());
     PrepareForBailoutForId(callee->AsProperty()->LoadId(),
                            BailoutState::TOS_REGISTER);
     // Push the target function under the receiver.
-    __ ld(at, MemOperand(sp, 0));
+    __ Ld(at, MemOperand(sp, 0));
     PushOperand(at);
-    __ sd(v0, MemOperand(sp, kPointerSize));
+    __ Sd(v0, MemOperand(sp, kPointerSize));
     convert_mode = ConvertReceiverMode::kNotNullOrUndefined;
   }
 
   EmitCall(expr, convert_mode);
 }
 
 
 // Code common for calls using the IC.
 void FullCodeGenerator::EmitKeyedCallWithLoadIC(Call* expr,
                                                 Expression* key) {
   // Load the key.
   VisitForAccumulatorValue(key);
 
   Expression* callee = expr->expression();
 
   // Load the function from the receiver.
   DCHECK(callee->IsProperty());
-  __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+  __ Ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
   __ Move(LoadDescriptor::NameRegister(), v0);
   EmitKeyedPropertyLoad(callee->AsProperty());
   PrepareForBailoutForId(callee->AsProperty()->LoadId(),
                          BailoutState::TOS_REGISTER);
 
   // Push the target function under the receiver.
-  __ ld(at, MemOperand(sp, 0));
+  __ Ld(at, MemOperand(sp, 0));
   PushOperand(at);
-  __ sd(v0, MemOperand(sp, kPointerSize));
+  __ Sd(v0, MemOperand(sp, kPointerSize));
 
   EmitCall(expr, ConvertReceiverMode::kNotNullOrUndefined);
 }
 
 
 void FullCodeGenerator::EmitCall(Call* expr, ConvertReceiverMode mode) {
   // Load the arguments.
   ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     VisitForStackValue(args->at(i));
   }
 
   PrepareForBailoutForId(expr->CallId(), BailoutState::NO_REGISTERS);
   // Record source position of the IC call.
   SetCallPosition(expr, expr->tail_call_mode());
   if (expr->tail_call_mode() == TailCallMode::kAllow) {
     if (FLAG_trace) {
       __ CallRuntime(Runtime::kTraceTailCall);
     }
     // Update profiling counters before the tail call since we will
     // not return to this function.
     EmitProfilingCounterHandlingForReturnSequence(true);
   }
   Handle<Code> code =
       CodeFactory::CallICTrampoline(isolate(), mode, expr->tail_call_mode())
           .code();
   __ li(a3, Operand(IntFromSlot(expr->CallFeedbackICSlot())));
-  __ ld(a1, MemOperand(sp, (arg_count + 1) * kPointerSize));
+  __ Ld(a1, MemOperand(sp, (arg_count + 1) * kPointerSize));
   __ li(a0, Operand(arg_count));
   CallIC(code);
   OperandStackDepthDecrement(arg_count + 1);
 
   RecordJSReturnSite(expr);
   RestoreContext();
   context()->DropAndPlug(1, v0);
 }
 
 void FullCodeGenerator::VisitCallNew(CallNew* expr) {
@@ skipping 14 matching lines @@
   for (int i = 0; i < arg_count; i++) {
     VisitForStackValue(args->at(i));
   }
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   SetConstructCallPosition(expr);
 
   // Load function and argument count into a1 and a0.
   __ li(a0, Operand(arg_count));
-  __ ld(a1, MemOperand(sp, arg_count * kPointerSize));
+  __ Ld(a1, MemOperand(sp, arg_count * kPointerSize));
 
   // Record call targets in unoptimized code.
   __ EmitLoadFeedbackVector(a2);
   __ li(a3, Operand(SmiFromSlot(expr->CallNewFeedbackSlot())));
 
   CallConstructStub stub(isolate());
   CallIC(stub.GetCode());
   OperandStackDepthDecrement(arg_count + 1);
   PrepareForBailoutForId(expr->ReturnId(), BailoutState::TOS_REGISTER);
   RestoreContext();
@@ skipping 129 matching lines @@
   __ Branch(&function, hs, a1, Operand(FIRST_FUNCTION_TYPE));
 
   // Check if the constructor in the map is a JS function.
   Register instance_type = a2;
   __ GetMapConstructor(v0, v0, a1, instance_type);
   __ Branch(&non_function_constructor, ne, instance_type,
             Operand(JS_FUNCTION_TYPE));
 
   // v0 now contains the constructor function. Grab the
   // instance class name from there.
-  __ ld(v0, FieldMemOperand(v0, JSFunction::kSharedFunctionInfoOffset));
-  __ ld(v0, FieldMemOperand(v0, SharedFunctionInfo::kInstanceClassNameOffset));
+  __ Ld(v0, FieldMemOperand(v0, JSFunction::kSharedFunctionInfoOffset));
+  __ Ld(v0, FieldMemOperand(v0, SharedFunctionInfo::kInstanceClassNameOffset));
   __ Branch(&done);
 
   // Functions have class 'Function'.
   __ bind(&function);
   __ LoadRoot(v0, Heap::kFunction_stringRootIndex);
   __ jmp(&done);
 
   // Objects with a non-function constructor have class 'Object'.
   __ bind(&non_function_constructor);
   __ LoadRoot(v0, Heap::kObject_stringRootIndex);
@@ skipping 54 matching lines @@
 void FullCodeGenerator::EmitCall(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   DCHECK_LE(2, args->length());
   // Push target, receiver and arguments onto the stack.
   for (Expression* const arg : *args) {
     VisitForStackValue(arg);
   }
   PrepareForBailoutForId(expr->CallId(), BailoutState::NO_REGISTERS);
   // Move target to a1.
   int const argc = args->length() - 2;
-  __ ld(a1, MemOperand(sp, (argc + 1) * kPointerSize));
+  __ Ld(a1, MemOperand(sp, (argc + 1) * kPointerSize));
   // Call the target.
   __ li(a0, Operand(argc));
   __ Call(isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
   OperandStackDepthDecrement(argc + 1);
   RestoreContext();
   // Discard the function left on TOS.
   context()->DropAndPlug(1, v0);
 }
 
 void FullCodeGenerator::EmitGetSuperConstructor(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   DCHECK_EQ(1, args->length());
   VisitForAccumulatorValue(args->at(0));
   __ AssertFunction(v0);
-  __ ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
-  __ ld(v0, FieldMemOperand(v0, Map::kPrototypeOffset));
+  __ Ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
+  __ Ld(v0, FieldMemOperand(v0, Map::kPrototypeOffset));
   context()->Plug(v0);
 }
 
 void FullCodeGenerator::EmitDebugIsActive(CallRuntime* expr) {
   DCHECK(expr->arguments()->length() == 0);
   ExternalReference debug_is_active =
       ExternalReference::debug_is_active_address(isolate());
   __ li(at, Operand(debug_is_active));
-  __ lbu(v0, MemOperand(at));
+  __ Lbu(v0, MemOperand(at));
   __ SmiTag(v0);
   context()->Plug(v0);
 }
 
 
 void FullCodeGenerator::EmitCreateIterResultObject(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   DCHECK_EQ(2, args->length());
   VisitForStackValue(args->at(0));
   VisitForStackValue(args->at(1));
 
   Label runtime, done;
 
   __ Allocate(JSIteratorResult::kSize, v0, a2, a3, &runtime,
               NO_ALLOCATION_FLAGS);
   __ LoadNativeContextSlot(Context::ITERATOR_RESULT_MAP_INDEX, a1);
   __ Pop(a2, a3);
   __ LoadRoot(a4, Heap::kEmptyFixedArrayRootIndex);
-  __ sd(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
-  __ sd(a4, FieldMemOperand(v0, JSObject::kPropertiesOffset));
-  __ sd(a4, FieldMemOperand(v0, JSObject::kElementsOffset));
-  __ sd(a2, FieldMemOperand(v0, JSIteratorResult::kValueOffset));
-  __ sd(a3, FieldMemOperand(v0, JSIteratorResult::kDoneOffset));
+  __ Sd(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
+  __ Sd(a4, FieldMemOperand(v0, JSObject::kPropertiesOffset));
+  __ Sd(a4, FieldMemOperand(v0, JSObject::kElementsOffset));
+  __ Sd(a2, FieldMemOperand(v0, JSIteratorResult::kValueOffset));
+  __ Sd(a3, FieldMemOperand(v0, JSIteratorResult::kDoneOffset));
   STATIC_ASSERT(JSIteratorResult::kSize == 5 * kPointerSize);
   __ jmp(&done);
 
   __ bind(&runtime);
   CallRuntimeWithOperands(Runtime::kCreateIterResultObject);
 
   __ bind(&done);
   context()->Plug(v0);
 }
 
 
 void FullCodeGenerator::EmitLoadJSRuntimeFunction(CallRuntime* expr) {
   // Push function.
   __ LoadNativeContextSlot(expr->context_index(), v0);
   PushOperand(v0);
 
   // Push undefined as the receiver.
   __ LoadRoot(v0, Heap::kUndefinedValueRootIndex);
   PushOperand(v0);
 }
 
 
 void FullCodeGenerator::EmitCallJSRuntimeFunction(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
 
   SetCallPosition(expr);
-  __ ld(a1, MemOperand(sp, (arg_count + 1) * kPointerSize));
+  __ Ld(a1, MemOperand(sp, (arg_count + 1) * kPointerSize));
   __ li(a0, Operand(arg_count));
   __ Call(isolate()->builtins()->Call(ConvertReceiverMode::kNullOrUndefined),
           RelocInfo::CODE_TARGET);
   OperandStackDepthDecrement(arg_count + 1);
   RestoreContext();
 }
 
 
 void FullCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
@@ skipping 120 matching lines @@
   } else {
     // Reserve space for result of postfix operation.
     if (expr->is_postfix() && !context()->IsEffect()) {
       __ li(at, Operand(Smi::kZero));
       PushOperand(at);
     }
     switch (assign_type) {
       case NAMED_PROPERTY: {
         // Put the object both on the stack and in the register.
         VisitForStackValue(prop->obj());
-        __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+        __ Ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
         EmitNamedPropertyLoad(prop);
         break;
       }
 
       case KEYED_PROPERTY: {
         VisitForStackValue(prop->obj());
         VisitForStackValue(prop->key());
-        __ ld(LoadDescriptor::ReceiverRegister(),
+        __ Ld(LoadDescriptor::ReceiverRegister(),
               MemOperand(sp, 1 * kPointerSize));
-        __ ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+        __ Ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
         EmitKeyedPropertyLoad(prop);
         break;
       }
 
       case NAMED_SUPER_PROPERTY:
       case KEYED_SUPER_PROPERTY:
       case VARIABLE:
         UNREACHABLE();
     }
   }
@@ skipping 20 matching lines @@
     if (expr->is_postfix()) {
       if (!context()->IsEffect()) {
         // Save the result on the stack. If we have a named or keyed property
         // we store the result under the receiver that is currently on top
         // of the stack.
         switch (assign_type) {
           case VARIABLE:
             __ push(v0);
             break;
           case NAMED_PROPERTY:
-            __ sd(v0, MemOperand(sp, kPointerSize));
+            __ Sd(v0, MemOperand(sp, kPointerSize));
             break;
           case KEYED_PROPERTY:
-            __ sd(v0, MemOperand(sp, 2 * kPointerSize));
+            __ Sd(v0, MemOperand(sp, 2 * kPointerSize));
             break;
           case NAMED_SUPER_PROPERTY:
           case KEYED_SUPER_PROPERTY:
             UNREACHABLE();
             break;
         }
       }
     }
 
     Register scratch1 = a1;
@@ skipping 14 matching lines @@
   if (expr->is_postfix()) {
     if (!context()->IsEffect()) {
       // Save the result on the stack. If we have a named or keyed property
       // we store the result under the receiver that is currently on top
       // of the stack.
       switch (assign_type) {
         case VARIABLE:
           PushOperand(v0);
           break;
         case NAMED_PROPERTY:
-          __ sd(v0, MemOperand(sp, kPointerSize));
+          __ Sd(v0, MemOperand(sp, kPointerSize));
           break;
         case KEYED_PROPERTY:
-          __ sd(v0, MemOperand(sp, 2 * kPointerSize));
+          __ Sd(v0, MemOperand(sp, 2 * kPointerSize));
           break;
         case NAMED_SUPER_PROPERTY:
         case KEYED_SUPER_PROPERTY:
           UNREACHABLE();
           break;
       }
     }
   }
 
   __ bind(&stub_call);
@@ skipping 81 matching lines @@
                          &if_true, &if_false, &fall_through);
 
   { AccumulatorValueContext context(this);
     VisitForTypeofValue(sub_expr);
   }
   PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
 
   Factory* factory = isolate()->factory();
   if (String::Equals(check, factory->number_string())) {
     __ JumpIfSmi(v0, if_true);
-    __ ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
+    __ Ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
     Split(eq, v0, Operand(at), if_true, if_false, fall_through);
   } else if (String::Equals(check, factory->string_string())) {
     __ JumpIfSmi(v0, if_false);
     __ GetObjectType(v0, v0, a1);
     Split(lt, a1, Operand(FIRST_NONSTRING_TYPE), if_true, if_false,
           fall_through);
   } else if (String::Equals(check, factory->symbol_string())) {
     __ JumpIfSmi(v0, if_false);
     __ GetObjectType(v0, v0, a1);
     Split(eq, a1, Operand(SYMBOL_TYPE), if_true, if_false, fall_through);
   } else if (String::Equals(check, factory->boolean_string())) {
     __ LoadRoot(at, Heap::kTrueValueRootIndex);
     __ Branch(if_true, eq, v0, Operand(at));
     __ LoadRoot(at, Heap::kFalseValueRootIndex);
     Split(eq, v0, Operand(at), if_true, if_false, fall_through);
   } else if (String::Equals(check, factory->undefined_string())) {
     __ LoadRoot(at, Heap::kNullValueRootIndex);
     __ Branch(if_false, eq, v0, Operand(at));
     __ JumpIfSmi(v0, if_false);
     // Check for undetectable objects => true.
-    __ ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
-    __ lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
+    __ Ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
+    __ Lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
     __ And(a1, a1, Operand(1 << Map::kIsUndetectable));
     Split(ne, a1, Operand(zero_reg), if_true, if_false, fall_through);
   } else if (String::Equals(check, factory->function_string())) {
     __ JumpIfSmi(v0, if_false);
-    __ ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
-    __ lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
+    __ Ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
+    __ Lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
     __ And(a1, a1,
            Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
     Split(eq, a1, Operand(1 << Map::kIsCallable), if_true, if_false,
           fall_through);
   } else if (String::Equals(check, factory->object_string())) {
     __ JumpIfSmi(v0, if_false);
     __ LoadRoot(at, Heap::kNullValueRootIndex);
     __ Branch(if_true, eq, v0, Operand(at));
     STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
     __ GetObjectType(v0, v0, a1);
     __ Branch(if_false, lt, a1, Operand(FIRST_JS_RECEIVER_TYPE));
     // Check for callable or undetectable objects => false.
-    __ lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
+    __ Lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
     __ And(a1, a1,
            Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
     Split(eq, a1, Operand(zero_reg), if_true, if_false, fall_through);
   } else {
     if (if_false != fall_through) __ jmp(if_false);
   }
   context()->Plug(if_true, if_false);
 }
 
 
@@ skipping 82 matching lines @@
   VisitForAccumulatorValue(sub_expr);
   PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
   if (expr->op() == Token::EQ_STRICT) {
     Heap::RootListIndex nil_value = nil == kNullValue ?
         Heap::kNullValueRootIndex :
         Heap::kUndefinedValueRootIndex;
     __ LoadRoot(a1, nil_value);
     Split(eq, v0, Operand(a1), if_true, if_false, fall_through);
   } else {
     __ JumpIfSmi(v0, if_false);
-    __ ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
-    __ lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
+    __ Ld(v0, FieldMemOperand(v0, HeapObject::kMapOffset));
+    __ Lbu(a1, FieldMemOperand(v0, Map::kBitFieldOffset));
     __ And(a1, a1, Operand(1 << Map::kIsUndetectable));
     Split(ne, a1, Operand(zero_reg), if_true, if_false, fall_through);
   }
   context()->Plug(if_true, if_false);
 }
 
 
 Register FullCodeGenerator::result_register() {
   return v0;
 }
 
 
 Register FullCodeGenerator::context_register() {
   return cp;
 }
 
 void FullCodeGenerator::LoadFromFrameField(int frame_offset, Register value) {
   // DCHECK_EQ(POINTER_SIZE_ALIGN(frame_offset), frame_offset);
   DCHECK(IsAligned(frame_offset, kPointerSize));
-  //  __ sw(value, MemOperand(fp, frame_offset));
-  __ ld(value, MemOperand(fp, frame_offset));
+  //  __ Sw(value, MemOperand(fp, frame_offset));
+  __ Ld(value, MemOperand(fp, frame_offset));
 }
 
 void FullCodeGenerator::StoreToFrameField(int frame_offset, Register value) {
   // DCHECK_EQ(POINTER_SIZE_ALIGN(frame_offset), frame_offset);
   DCHECK(IsAligned(frame_offset, kPointerSize));
-  //  __ sw(value, MemOperand(fp, frame_offset));
-  __ sd(value, MemOperand(fp, frame_offset));
+  //  __ Sw(value, MemOperand(fp, frame_offset));
+  __ Sd(value, MemOperand(fp, frame_offset));
 }
 
 
 void FullCodeGenerator::LoadContextField(Register dst, int context_index) {
-  __ ld(dst, ContextMemOperand(cp, context_index));
+  __ Ld(dst, ContextMemOperand(cp, context_index));
 }
 
 
 void FullCodeGenerator::PushFunctionArgumentForContextAllocation() {
   DeclarationScope* closure_scope = scope()->GetClosureScope();
   if (closure_scope->is_script_scope() ||
       closure_scope->is_module_scope()) {
     // Contexts nested in the native context have a canonical empty function
     // as their closure, not the anonymous closure containing the global
     // code.
     __ LoadNativeContextSlot(Context::CLOSURE_INDEX, at);
   } else if (closure_scope->is_eval_scope()) {
     // Contexts created by a call to eval have the same closure as the
     // context calling eval, not the anonymous closure containing the eval
     // code.  Fetch it from the context.
-    __ ld(at, ContextMemOperand(cp, Context::CLOSURE_INDEX));
+    __ Ld(at, ContextMemOperand(cp, Context::CLOSURE_INDEX));
   } else {
     DCHECK(closure_scope->is_function_scope());
-    __ ld(at, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+    __ Ld(at, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   }
   PushOperand(at);
 }
 
 
 #undef __
 
 
 void BackEdgeTable::PatchAt(Code* unoptimized_code,
                             Address pc,
@@ skipping 67 matching lines @@
          reinterpret_cast<uint64_t>(
              isolate->builtins()->OnStackReplacement()->entry()));
   return ON_STACK_REPLACEMENT;
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64