A64: Remove Operand constructors where an implicit constructor can be used.

src/a64/code-stubs-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1062 matching lines @@
     native = strict() ? Builtins::STRICT_EQUALS : Builtins::EQUALS;
   } else {
     native = Builtins::COMPARE;
     int ncr;  // NaN compare result
     if ((cond == lt) || (cond == le)) {
       ncr = GREATER;
     } else {
       ASSERT((cond == gt) || (cond == ge));  // remaining cases
       ncr = LESS;
     }
-    __ Mov(x10, Operand(Smi::FromInt(ncr)));
+    __ Mov(x10, Smi::FromInt(ncr));
     __ Push(x10);
   }
 
   // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ InvokeBuiltin(native, JUMP_FUNCTION);
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
@@ skipping 10 matching lines @@
 
   // We don't allow a GC during a store buffer overflow so there is no need to
   // store the registers in any particular way, but we do have to store and
   // restore them.
   __ PushCPURegList(saved_regs);
   if (save_doubles_ == kSaveFPRegs) {
     __ PushCPURegList(kCallerSavedFP);
   }
 
   AllowExternalCallThatCantCauseGC scope(masm);
-  __ Mov(x0, Operand(ExternalReference::isolate_address(masm->isolate())));
+  __ Mov(x0, ExternalReference::isolate_address(masm->isolate()));
   __ CallCFunction(
       ExternalReference::store_buffer_overflow_function(masm->isolate()),
                                                         1, 0);
 
   if (save_doubles_ == kSaveFPRegs) {
     __ PopCPURegList(kCallerSavedFP);
   }
   __ PopCPURegList(saved_regs);
   __ Ret();
 }
@@ skipping 358 matching lines @@
 
   Isolate* isolate = masm->isolate();
 
   const Register& argv = x21;
   const Register& argc = x22;
   const Register& target = x23;
 
   if (do_gc) {
     // Call Runtime::PerformGC, passing x0 (the result parameter for
     // PerformGC) and x1 (the isolate).
-    __ Mov(x1, Operand(ExternalReference::isolate_address(masm->isolate())));
+    __ Mov(x1, ExternalReference::isolate_address(masm->isolate()));
     __ CallCFunction(
         ExternalReference::perform_gc_function(isolate), 2, 0);
   }
 
   ExternalReference scope_depth =
       ExternalReference::heap_always_allocate_scope_depth(isolate);
   if (always_allocate) {
     __ Mov(x10, Operand(scope_depth));
     __ Ldr(x11, MemOperand(x10));
     __ Add(x11, x11, 1);
     __ Str(x11, MemOperand(x10));
   }
 
   // Prepare AAPCS64 arguments to pass to the builtin.
   __ Mov(x0, argc);
   __ Mov(x1, argv);
-  __ Mov(x2, Operand(ExternalReference::isolate_address(isolate)));
+  __ Mov(x2, ExternalReference::isolate_address(isolate));
 
   // Store the return address on the stack, in the space previously allocated
   // by EnterExitFrame. The return address is queried by
   // ExitFrame::GetStateForFramePointer.
   Label return_location;
   __ Adr(x12, &return_location);
   __ Poke(x12, 0);
   if (__ emit_debug_code()) {
     // Verify that the slot below fp[kSPOffset]-8 points to the return location
     // (currently in x12).
@@ skipping 292 matching lines @@
   // Set up the reserved register for 0.0.
   __ Fmov(fp_zero, 0.0);
 
   // Build an entry frame (see layout below).
   Isolate* isolate = masm->isolate();
 
   // Build an entry frame.
   int marker = is_construct ? StackFrame::ENTRY_CONSTRUCT : StackFrame::ENTRY;
   int64_t bad_frame_pointer = -1L;  // Bad frame pointer to fail if it is used.
   __ Mov(x13, bad_frame_pointer);
-  __ Mov(x12, Operand(Smi::FromInt(marker)));
-  __ Mov(x11, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate)));
+  __ Mov(x12, Smi::FromInt(marker));
+  __ Mov(x11, ExternalReference(Isolate::kCEntryFPAddress, isolate));
   __ Ldr(x10, MemOperand(x11));
 
   __ Push(x13, xzr, x12, x10);
   // Set up fp.
   __ Sub(fp, jssp, EntryFrameConstants::kCallerFPOffset);
 
   // Push the JS entry frame marker. Also set js_entry_sp if this is the
   // outermost JS call.
   Label non_outermost_js, done;
   ExternalReference js_entry_sp(Isolate::kJSEntrySPAddress, isolate);
-  __ Mov(x10, Operand(ExternalReference(js_entry_sp)));
+  __ Mov(x10, ExternalReference(js_entry_sp));
   __ Ldr(x11, MemOperand(x10));
   __ Cbnz(x11, &non_outermost_js);
   __ Str(fp, MemOperand(x10));
-  __ Mov(x12, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+  __ Mov(x12, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
   __ Push(x12);
   __ B(&done);
   __ Bind(&non_outermost_js);
   // We spare one instruction by pushing xzr since the marker is 0.
   ASSERT(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME) == NULL);
   __ Push(xzr);
   __ Bind(&done);
 
   // The frame set up looks like this:
   // jssp[0] : JS entry frame marker.
@@ skipping 48 matching lines @@
 
   // Expected registers by Builtins::JSEntryTrampoline
   // x0: code entry.
   // x1: function.
   // x2: receiver.
   // x3: argc.
   // x4: argv.
   ExternalReference entry(is_construct ? Builtins::kJSConstructEntryTrampoline
                                        : Builtins::kJSEntryTrampoline,
                           isolate);
-  __ Mov(x10, Operand(entry));
+  __ Mov(x10, entry);
 
   // Call the JSEntryTrampoline.
   __ Ldr(x11, MemOperand(x10));  // Dereference the address.
   __ Add(x12, x11, Code::kHeaderSize - kHeapObjectTag);
   __ Blr(x12);
 
   // Unlink this frame from the handler chain.
   __ PopTryHandler();
 
 
   __ Bind(&exit);
   // x0 holds the result.
   // The stack pointer points to the top of the entry frame pushed on entry from
   // C++ (at the beginning of this stub):
   // jssp[0] : JS entry frame marker.
   // jssp[1] : C entry FP.
   // jssp[2] : stack frame marker.
   // jssp[3] : stack frmae marker.
   // jssp[4] : bad frame pointer 0xfff...ff   <- fp points here.
 
   // Check if the current stack frame is marked as the outermost JS frame.
   Label non_outermost_js_2;
   __ Pop(x10);
-  __ Cmp(x10, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+  __ Cmp(x10, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
   __ B(ne, &non_outermost_js_2);
-  __ Mov(x11, Operand(ExternalReference(js_entry_sp)));
+  __ Mov(x11, ExternalReference(js_entry_sp));
   __ Str(xzr, MemOperand(x11));
   __ Bind(&non_outermost_js_2);
 
   // Restore the top frame descriptors from the stack.
   __ Pop(x10);
-  __ Mov(x11, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate)));
+  __ Mov(x11, ExternalReference(Isolate::kCEntryFPAddress, isolate));
   __ Str(x10, MemOperand(x11));
 
   // Reset the stack to the callee saved registers.
   __ Drop(-EntryFrameConstants::kCallerFPOffset, kByteSizeInBytes);
   // Restore the callee-saved registers and return.
   ASSERT(jssp.Is(__ StackPointer()));
   __ Mov(csp, jssp);
   __ SetStackPointer(csp);
   __ PopCalleeSavedRegisters();
   // After this point, we must not modify jssp because it is a callee-saved
@@ skipping 59 matching lines @@
   Label not_js_object, slow;
 
   if (!HasArgsInRegisters()) {
     __ Pop(function, object);
   }
 
   if (ReturnTrueFalseObject()) {
     __ LoadTrueFalseRoots(res_true, res_false);
   } else {
     // This is counter-intuitive, but correct.
-    __ Mov(res_true, Operand(Smi::FromInt(0)));
-    __ Mov(res_false, Operand(Smi::FromInt(1)));
+    __ Mov(res_true, Smi::FromInt(0));
+    __ Mov(res_false, Smi::FromInt(1));
   }
 
   // Check that the left hand side is a JS object and load its map as a side
   // effect.
   Register map = x12;
   __ JumpIfSmi(object, &not_js_object);
   __ IsObjectJSObjectType(object, map, scratch2, &not_js_object);
 
   // If there is a call site cache, don't look in the global cache, but do the
   // real lookup and update the call site cache.
@@ skipping 149 matching lines @@
   __ JumpIfNotSmi(key, &slow);
 
   // Check if the calling frame is an arguments adaptor frame.
   Register local_fp = x11;
   Register caller_fp = x11;
   Register caller_ctx = x12;
   Label skip_adaptor;
   __ Ldr(caller_fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ Ldr(caller_ctx, MemOperand(caller_fp,
                                 StandardFrameConstants::kContextOffset));
-  __ Cmp(caller_ctx, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+  __ Cmp(caller_ctx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   __ Csel(local_fp, fp, caller_fp, ne);
   __ B(ne, &skip_adaptor);
 
   // Load the actual arguments limit found in the arguments adaptor frame.
   __ Ldr(arg_count, MemOperand(caller_fp,
                                ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ Bind(&skip_adaptor);
 
   // Check index against formal parameters count limit. Use unsigned comparison
   // to get negative check for free: branch if key < 0 or key >= arg_count.
@@ skipping 29 matching lines @@
   __ Ldr(w11, MemOperand(caller_fp, StandardFrameConstants::kContextOffset +
                          (kSmiShift / kBitsPerByte)));
   __ Cmp(w11, StackFrame::ARGUMENTS_ADAPTOR);
   __ B(ne, &runtime);
 
   // Patch the arguments.length and parameters pointer in the current frame.
   __ Ldr(x11, MemOperand(caller_fp,
                          ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ Poke(x11, 0 * kXRegSize);
   __ Add(x10, caller_fp, Operand::UntagSmiAndScale(x11, kPointerSizeLog2));
-  __ Add(x10, x10, Operand(StandardFrameConstants::kCallerSPOffset));
+  __ Add(x10, x10, StandardFrameConstants::kCallerSPOffset);
   __ Poke(x10, 1 * kXRegSize);
 
   __ Bind(&runtime);
   __ TailCallRuntime(Runtime::kNewArgumentsFast, 3, 1);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppyFast(MacroAssembler* masm) {
   // Stack layout on entry.
   //  jssp[0]:  number of parameters (tagged)
@@ skipping 12 matching lines @@
   __ SmiUntag(param_count, param_count_smi);
 
   // Check if the calling frame is an arguments adaptor frame.
   Register caller_fp = x11;
   Register caller_ctx = x12;
   Label runtime;
   Label adaptor_frame, try_allocate;
   __ Ldr(caller_fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ Ldr(caller_ctx, MemOperand(caller_fp,
                                 StandardFrameConstants::kContextOffset));
-  __ Cmp(caller_ctx, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+  __ Cmp(caller_ctx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   __ B(eq, &adaptor_frame);
 
   // No adaptor, parameter count = argument count.
 
   //   x1   mapped_params number of mapped params, min(params, args) (uninit)
   //   x2   arg_count     number of function arguments (uninit)
   //   x3   arg_count_smi number of function arguments (smi)
   //   x4   function      function pointer
   //   x7   param_count   number of function parameters
   //   x11  caller_fp     caller's frame pointer
@@ skipping 181 matching lines @@
 
   __ B(&parameters_test);
 
   __ Bind(&parameters_loop);
   __ Sub(loop_count, loop_count, 1);
   __ Mov(x10, Operand(loop_count, LSL, kPointerSizeLog2));
   __ Add(x10, x10, kParameterMapHeaderSize - kHeapObjectTag);
   __ Str(index, MemOperand(elements, x10));
   __ Sub(x10, x10, kParameterMapHeaderSize - FixedArray::kHeaderSize);
   __ Str(the_hole, MemOperand(backing_store, x10));
-  __ Add(index, index, Operand(Smi::FromInt(1)));
+  __ Add(index, index, Smi::FromInt(1));
   __ Bind(&parameters_test);
   __ Cbnz(loop_count, &parameters_loop);
 
   __ Bind(&skip_parameter_map);
   // Copy arguments header and remaining slots (if there are any.)
   __ LoadRoot(x10, Heap::kFixedArrayMapRootIndex);
   __ Str(x10, FieldMemOperand(backing_store, FixedArray::kMapOffset));
   __ Str(arg_count_smi, FieldMemOperand(backing_store,
                                         FixedArray::kLengthOffset));
 
@@ skipping 48 matching lines @@
   __ Pop(param_count_smi, params, function);
   __ SmiUntag(param_count, param_count_smi);
 
   // Test if arguments adaptor needed.
   Register caller_fp = x11;
   Register caller_ctx = x12;
   Label try_allocate, runtime;
   __ Ldr(caller_fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ Ldr(caller_ctx, MemOperand(caller_fp,
                                 StandardFrameConstants::kContextOffset));
-  __ Cmp(caller_ctx, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+  __ Cmp(caller_ctx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   __ B(ne, &try_allocate);
 
   //   x1   param_count_smi   number of parameters passed to function (smi)
   //   x2   params            pointer to parameters
   //   x3   function          function pointer
   //   x11  caller_fp         caller's frame pointer
   //   x13  param_count       number of parameters passed to function
 
   // Patch the argument length and parameters pointer.
   __ Ldr(param_count_smi,
@@ skipping 165 matching lines @@
   const int kPreviousIndexOffset = 5 * kPointerSize;
   const int kSubjectOffset = 6 * kPointerSize;
   const int kJSRegExpOffset = 7 * kPointerSize;
 
   // Ensure that a RegExp stack is allocated.
   Isolate* isolate = masm->isolate();
   ExternalReference address_of_regexp_stack_memory_address =
       ExternalReference::address_of_regexp_stack_memory_address(isolate);
   ExternalReference address_of_regexp_stack_memory_size =
       ExternalReference::address_of_regexp_stack_memory_size(isolate);
-  __ Mov(x10, Operand(address_of_regexp_stack_memory_size));
+  __ Mov(x10, address_of_regexp_stack_memory_size);
   __ Ldr(x10, MemOperand(x10));
   __ Cbz(x10, &runtime);
 
   // Check that the first argument is a JSRegExp object.
   ASSERT(jssp.Is(__ StackPointer()));
   __ Peek(jsregexp_object, kJSRegExpOffset);
   __ JumpIfSmi(jsregexp_object, &runtime);
   __ JumpIfNotObjectType(jsregexp_object, x10, x10, JS_REGEXP_TYPE, &runtime);
 
   // Check that the RegExp has been compiled (data contains a fixed array).
   __ Ldr(regexp_data, FieldMemOperand(jsregexp_object, JSRegExp::kDataOffset));
   if (FLAG_debug_code) {
     STATIC_ASSERT(kSmiTag == 0);
     __ Tst(regexp_data, kSmiTagMask);
     __ Check(ne, kUnexpectedTypeForRegExpDataFixedArrayExpected);
     __ CompareObjectType(regexp_data, x10, x10, FIXED_ARRAY_TYPE);
     __ Check(eq, kUnexpectedTypeForRegExpDataFixedArrayExpected);
   }
 
   // Check the type of the RegExp. Only continue if type is JSRegExp::IRREGEXP.
   __ Ldr(x10, FieldMemOperand(regexp_data, JSRegExp::kDataTagOffset));
-  __ Cmp(x10, Operand(Smi::FromInt(JSRegExp::IRREGEXP)));
+  __ Cmp(x10, Smi::FromInt(JSRegExp::IRREGEXP));
   __ B(ne, &runtime);
 
   // Check that the number of captures fit in the static offsets vector buffer.
   // We have always at least one capture for the whole match, plus additional
   // ones due to capturing parentheses. A capture takes 2 registers.
   // The number of capture registers then is (number_of_captures + 1) * 2.
   __ Ldrsw(x10,
            UntagSmiFieldMemOperand(regexp_data,
                                    JSRegExp::kIrregexpCaptureCountOffset));
   // Check (number_of_captures + 1) * 2 <= offsets vector size
@@ skipping 134 matching lines @@
   ASSERT(csp.Is(__ StackPointer()));
 
   // We have 9 arguments to pass to the regexp code, therefore we have to pass
   // one on the stack and the rest as registers.
 
   // Note that the placement of the argument on the stack isn't standard
   // AAPCS64:
   // csp[0]: Space for the return address placed by DirectCEntryStub.
   // csp[8]: Argument 9, the current isolate address.
 
-  __ Mov(x10, Operand(ExternalReference::isolate_address(isolate)));
+  __ Mov(x10, ExternalReference::isolate_address(isolate));
   __ Poke(x10, kPointerSize);
 
   Register length = w11;
   Register previous_index_in_bytes = w12;
   Register start = x13;
 
   // Load start of the subject string.
   __ Add(start, subject, SeqString::kHeaderSize - kHeapObjectTag);
   // Load the length from the original subject string from the previous stack
   // frame. Therefore we have to use fp, which points exactly to two pointer
@@ skipping 28 matching lines @@
   //                                                      is not sliced).
   __ Add(w10, previous_index_in_bytes, sliced_string_offset);
   __ Add(x2, start, Operand(w10, UXTW));
 
   // Argument 4 (x3):
   // End of input = start of input + (length of input - previous index)
   __ Sub(w10, length, previous_index_in_bytes);
   __ Add(x3, x2, Operand(w10, UXTW));
 
   // Argument 5 (x4): static offsets vector buffer.
-  __ Mov(x4,
-         Operand(ExternalReference::address_of_static_offsets_vector(isolate)));
+  __ Mov(x4, ExternalReference::address_of_static_offsets_vector(isolate));
 
   // Argument 6 (x5): Set the number of capture registers to zero to force
   // global regexps to behave as non-global. This stub is not used for global
   // regexps.
   __ Mov(x5, 0);
 
   // Argument 7 (x6): Start (high end) of backtracking stack memory area.
-  __ Mov(x10, Operand(address_of_regexp_stack_memory_address));
+  __ Mov(x10, address_of_regexp_stack_memory_address);
   __ Ldr(x10, MemOperand(x10));
-  __ Mov(x11, Operand(address_of_regexp_stack_memory_size));
+  __ Mov(x11, address_of_regexp_stack_memory_size);
   __ Ldr(x11, MemOperand(x11));
   __ Add(x6, x10, x11);
 
   // Argument 8 (x7): Indicate that this is a direct call from JavaScript.
   __ Mov(x7, 1);
 
   // Locate the code entry and call it.
   __ Add(code_object, code_object, Code::kHeaderSize - kHeapObjectTag);
   DirectCEntryStub stub;
   stub.GenerateCall(masm, code_object);
@@ skipping 75 matching lines @@
                       kDontSaveFPRegs);
 
   Register last_match_offsets = x13;
   Register offsets_vector_index = x14;
   Register current_offset = x15;
 
   // Get the static offsets vector filled by the native regexp code
   // and fill the last match info.
   ExternalReference address_of_static_offsets_vector =
       ExternalReference::address_of_static_offsets_vector(isolate);
-  __ Mov(offsets_vector_index, Operand(address_of_static_offsets_vector));
+  __ Mov(offsets_vector_index, address_of_static_offsets_vector);
 
   Label next_capture, done;
   // Capture register counter starts from number of capture registers and
   // iterates down to zero (inclusive).
   __ Add(last_match_offsets,
          last_match_info_elements,
          RegExpImpl::kFirstCaptureOffset - kHeapObjectTag);
   __ Bind(&next_capture);
   __ Subs(number_of_capture_registers, number_of_capture_registers, 2);
   __ B(mi, &done);
@@ skipping 474 matching lines @@
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 
 void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
   __ JumpIfNotSmi(code_, &slow_case_);
-  __ Cmp(code_, Operand(Smi::FromInt(String::kMaxOneByteCharCode)));
+  __ Cmp(code_, Smi::FromInt(String::kMaxOneByteCharCode));
   __ B(hi, &slow_case_);
 
   __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
   // At this point code register contains smi tagged ASCII char code.
   STATIC_ASSERT(kSmiShift > kPointerSizeLog2);
   __ Add(result_, result_, Operand(code_, LSR, kSmiShift - kPointerSizeLog2));
   __ Ldr(result_, FieldMemOperand(result_, FixedArray::kHeaderSize));
   __ JumpIfRoot(result_, Heap::kUndefinedValueRootIndex, &slow_case_);
   __ Bind(&exit_);
 }
@@ skipping 329 matching lines @@
     ExternalReference miss =
       ExternalReference(IC_Utility(IC::kCompareIC_Miss), masm->isolate());
 
     FrameScope scope(masm, StackFrame::INTERNAL);
     Register op = x10;
     Register left = x1;
     Register right = x0;
     // Preserve some caller-saved registers.
     __ Push(x1, x0, lr);
     // Push the arguments.
-    __ Mov(op, Operand(Smi::FromInt(op_)));
+    __ Mov(op, Smi::FromInt(op_));
     __ Push(left, right, op);
 
     // Call the miss handler. This also pops the arguments.
     __ CallExternalReference(miss, 3);
 
     // Compute the entry point of the rewritten stub.
     __ Add(stub_entry, x0, Code::kHeaderSize - kHeapObjectTag);
     // Restore caller-saved registers.
     __ Pop(lr, x0, x1);
   }
@@ skipping 328 matching lines @@
 
   // Compare lengths. If lengths differ, strings can't be equal. Lengths are
   // smis, and don't need to be untagged.
   Label strings_not_equal, check_zero_length;
   __ Ldr(left_length, FieldMemOperand(left, String::kLengthOffset));
   __ Ldr(right_length, FieldMemOperand(right, String::kLengthOffset));
   __ Cmp(left_length, right_length);
   __ B(eq, &check_zero_length);
 
   __ Bind(&strings_not_equal);
-  __ Mov(result, Operand(Smi::FromInt(NOT_EQUAL)));
+  __ Mov(result, Smi::FromInt(NOT_EQUAL));
   __ Ret();
 
   // Check if the length is zero. If so, the strings must be equal (and empty.)
   Label compare_chars;
   __ Bind(&check_zero_length);
   STATIC_ASSERT(kSmiTag == 0);
   __ Cbnz(left_length, &compare_chars);
-  __ Mov(result, Operand(Smi::FromInt(EQUAL)));
+  __ Mov(result, Smi::FromInt(EQUAL));
   __ Ret();
 
   // Compare characters. Falls through if all characters are equal.
   __ Bind(&compare_chars);
   GenerateAsciiCharsCompareLoop(masm, left, right, left_length, scratch2,
                                 scratch3, &strings_not_equal);
 
   // Characters in strings are equal.
-  __ Mov(result, Operand(Smi::FromInt(EQUAL)));
+  __ Mov(result, Smi::FromInt(EQUAL));
   __ Ret();
 }
 
 
 void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
                                                         Register left,
                                                         Register right,
                                                         Register scratch1,
                                                         Register scratch2,
                                                         Register scratch3,
@@ skipping 21 matching lines @@
 
   ASSERT(Smi::FromInt(EQUAL) == static_cast<Smi*>(0));
 
   // Use length_delta as result if it's zero.
   Register result = x0;
   __ Subs(result, length_delta, 0);
 
   __ Bind(&result_not_equal);
   Register greater = x10;
   Register less = x11;
-  __ Mov(greater, Operand(Smi::FromInt(GREATER)));
-  __ Mov(less, Operand(Smi::FromInt(LESS)));
+  __ Mov(greater, Smi::FromInt(GREATER));
+  __ Mov(less, Smi::FromInt(LESS));
   __ CmovX(result, greater, gt);
   __ CmovX(result, less, lt);
   __ Ret();
 }
 
 
 void StringCompareStub::GenerateAsciiCharsCompareLoop(
     MacroAssembler* masm,
     Register left,
     Register right,
@@ skipping 105 matching lines @@
     __ CheckMap(elements,
                 x10,
                 Heap::kFixedArrayMapRootIndex,
                 &call_builtin,
                 DONT_DO_SMI_CHECK);
   }
 
   // Get the array's length and calculate new length.
   __ Ldr(length, FieldMemOperand(receiver, JSArray::kLengthOffset));
   STATIC_ASSERT(kSmiTag == 0);
-  __ Add(length, length, Operand(Smi::FromInt(argc)));
+  __ Add(length, length, Smi::FromInt(argc));
 
   // Check if we could survive without allocation.
   __ Ldr(elements_length,
          FieldMemOperand(elements, FixedArray::kLengthOffset));
   __ Cmp(length, elements_length);
 
   const int kEndElementsOffset =
       FixedArray::kHeaderSize - kHeapObjectTag - argc * kPointerSize;
 
   if (IsFastSmiOrObjectElementsKind(elements_kind())) {
@@ skipping 106 matching lines @@
       ExternalReference::new_space_allocation_limit_address(isolate);
 
   const int kAllocationDelta = 4;
   ASSERT(kAllocationDelta >= argc);
   Register allocation_top_addr = x5;
   Register allocation_top = x9;
   // Load top and check if it is the end of elements.
   __ Add(end_elements, elements,
          Operand::UntagSmiAndScale(length, kPointerSizeLog2));
   __ Add(end_elements, end_elements, kEndElementsOffset);
-  __ Mov(allocation_top_addr, Operand(new_space_allocation_top));
+  __ Mov(allocation_top_addr, new_space_allocation_top);
   __ Ldr(allocation_top, MemOperand(allocation_top_addr));
   __ Cmp(end_elements, allocation_top);
   __ B(ne, &call_builtin);
 
-  __ Mov(x10, Operand(new_space_allocation_limit));
+  __ Mov(x10, new_space_allocation_limit);
   __ Ldr(x10, MemOperand(x10));
   __ Add(allocation_top, allocation_top, kAllocationDelta * kPointerSize);
   __ Cmp(allocation_top, x10);
   __ B(hi, &call_builtin);
 
   // We fit and could grow elements.
   // Update new_space_allocation_top.
   __ Str(allocation_top, MemOperand(allocation_top_addr));
   // Push the argument.
   __ Str(argument, MemOperand(end_elements));
   // Fill the rest with holes.
   __ LoadRoot(x10, Heap::kTheHoleValueRootIndex);
   ASSERT(kAllocationDelta == 4);
   __ Stp(x10, x10, MemOperand(end_elements, 1 * kPointerSize));
   __ Stp(x10, x10, MemOperand(end_elements, 3 * kPointerSize));
 
   // Update elements' and array's sizes.
   __ Str(length, FieldMemOperand(receiver, JSArray::kLengthOffset));
-  __ Add(elements_length,
-         elements_length,
-         Operand(Smi::FromInt(kAllocationDelta)));
+  __ Add(elements_length, elements_length, Smi::FromInt(kAllocationDelta));
   __ Str(elements_length,
          FieldMemOperand(elements, FixedArray::kLengthOffset));
 
   // Elements are in new space, so write barrier is not required.
   __ Drop(argc + 1);
   __ Mov(x0, length);
   __ Ret();
 
   __ Bind(&call_builtin);
   __ TailCallExternalReference(
@@ skipping 78 matching lines @@
 
 void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) {
   regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_);
   Register address =
     x0.Is(regs_.address()) ? regs_.scratch0() : regs_.address();
   ASSERT(!address.Is(regs_.object()));
   ASSERT(!address.Is(x0));
   __ Mov(address, regs_.address());
   __ Mov(x0, regs_.object());
   __ Mov(x1, address);
-  __ Mov(x2, Operand(ExternalReference::isolate_address(masm->isolate())));
+  __ Mov(x2, ExternalReference::isolate_address(masm->isolate()));
 
   AllowExternalCallThatCantCauseGC scope(masm);
   ExternalReference function =
       ExternalReference::incremental_marking_record_write_function(
           masm->isolate());
   __ CallCFunction(function, 3, 0);
 
   regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_);
 }
 
@@ skipping 234 matching lines @@
       reinterpret_cast<uintptr_t>(masm->isolate()->function_entry_hook());
   __ Mov(x10, entry_hook);
 #else
   // Under the simulator we need to indirect the entry hook through a trampoline
   // function at a known address.
   ApiFunction dispatcher(FUNCTION_ADDR(EntryHookTrampoline));
   __ Mov(x10, Operand(ExternalReference(&dispatcher,
                                         ExternalReference::BUILTIN_CALL,
                                         masm->isolate())));
   // It additionally takes an isolate as a third parameter
-  __ Mov(x2, Operand(ExternalReference::isolate_address(masm->isolate())));
+  __ Mov(x2, ExternalReference::isolate_address(masm->isolate()));
 #endif
 
   // The caller's return address is above the saved temporaries.
   // Grab its location for the second argument to the hook.
   __ Add(x1, __ StackPointer(), kNumSavedRegs * kPointerSize);
 
   {
     // Create a dummy frame, as CallCFunction requires this.
     FrameScope frame(masm, StackFrame::MANUAL);
     __ CallCFunction(x10, 2, 0);
@@ skipping 366 matching lines @@
                        &normal_sequence);
       __ Assert(eq, kExpectedAllocationSite);
     }
 
     // Save the resulting elements kind in type info. We can't just store 'kind'
     // in the AllocationSite::transition_info field because elements kind is
     // restricted to a portion of the field; upper bits need to be left alone.
     STATIC_ASSERT(AllocationSite::ElementsKindBits::kShift == 0);
     __ Ldr(x11, FieldMemOperand(allocation_site,
                                 AllocationSite::kTransitionInfoOffset));
-    __ Add(x11, x11, Operand(Smi::FromInt(kFastElementsKindPackedToHoley)));
+    __ Add(x11, x11, Smi::FromInt(kFastElementsKindPackedToHoley));
     __ Str(x11, FieldMemOperand(allocation_site,
                                 AllocationSite::kTransitionInfoOffset));
 
     __ Bind(&normal_sequence);
     int last_index =
         GetSequenceIndexFromFastElementsKind(TERMINAL_FAST_ELEMENTS_KIND);
     for (int i = 0; i <= last_index; ++i) {
       Label next;
       ElementsKind candidate_kind = GetFastElementsKindFromSequenceIndex(i);
       __ CompareAndBranch(kind, candidate_kind, ne, &next);
@@ skipping 261 matching lines @@
   // FunctionCallbackArguments: context, callee and call data.
   __ Push(context, callee, call_data);
 
   // Load context from callee
   __ Ldr(context, FieldMemOperand(callee, JSFunction::kContextOffset));
 
   if (!call_data_undefined) {
     __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex);
   }
   Register isolate_reg = x5;
-  __ Mov(isolate_reg, Operand(ExternalReference::isolate_address(isolate)));
+  __ Mov(isolate_reg, ExternalReference::isolate_address(isolate));
 
   // FunctionCallbackArguments:
   //    return value, return value default, isolate, holder.
   __ Push(call_data, call_data, isolate_reg, holder);
 
   // Prepare arguments.
   Register args = x6;
   __ Mov(args, masm->StackPointer());
 
   // Allocate the v8::Arguments structure in the arguments' space, since it's
@@ skipping 92 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64