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

src/a64/macro-assembler-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 1235 matching lines @@
 void MacroAssembler::EnumLengthUntagged(Register dst, Register map) {
   STATIC_ASSERT(Map::EnumLengthBits::kShift == 0);
   Ldrsw(dst, UntagSmiFieldMemOperand(map, Map::kBitField3Offset));
   And(dst, dst, Map::EnumLengthBits::kMask);
 }
 
 
 void MacroAssembler::EnumLengthSmi(Register dst, Register map) {
   STATIC_ASSERT(Map::EnumLengthBits::kShift == 0);
   Ldr(dst, FieldMemOperand(map, Map::kBitField3Offset));
-  And(dst, dst, Operand(Smi::FromInt(Map::EnumLengthBits::kMask)));
+  And(dst, dst, Smi::FromInt(Map::EnumLengthBits::kMask));
 }
 
 
 void MacroAssembler::CheckEnumCache(Register object,
                                     Register null_value,
                                     Register scratch0,
                                     Register scratch1,
                                     Register scratch2,
                                     Register scratch3,
                                     Label* call_runtime) {
@@ skipping 52 matching lines @@
                                                      Register scratch1,
                                                      Register scratch2,
                                                      Label* no_memento_found) {
   ExternalReference new_space_start =
       ExternalReference::new_space_start(isolate());
   ExternalReference new_space_allocation_top =
       ExternalReference::new_space_allocation_top_address(isolate());
 
   Add(scratch1, receiver,
       JSArray::kSize + AllocationMemento::kSize - kHeapObjectTag);
-  Cmp(scratch1, Operand(new_space_start));
+  Cmp(scratch1, new_space_start);
   B(lt, no_memento_found);
 
-  Mov(scratch2, Operand(new_space_allocation_top));
+  Mov(scratch2, new_space_allocation_top);
   Ldr(scratch2, MemOperand(scratch2));
   Cmp(scratch1, scratch2);
   B(gt, no_memento_found);
 
   Ldr(scratch1, MemOperand(scratch1, -AllocationMemento::kSize));
   Cmp(scratch1,
       Operand(isolate()->factory()->allocation_memento_map()));
 }
 
 
@@ skipping 17 matching lines @@
   Br(scratch1);
 }
 
 
 void MacroAssembler::InNewSpace(Register object,
                                 Condition cond,
                                 Label* branch) {
   ASSERT(cond == eq || cond == ne);
   UseScratchRegisterScope temps(this);
   Register temp = temps.AcquireX();
-  And(temp, object, Operand(ExternalReference::new_space_mask(isolate())));
-  Cmp(temp, Operand(ExternalReference::new_space_start(isolate())));
+  And(temp, object, ExternalReference::new_space_mask(isolate()));
+  Cmp(temp, ExternalReference::new_space_start(isolate()));
   B(cond, branch);
 }
 
 
 void MacroAssembler::Throw(Register value,
                            Register scratch1,
                            Register scratch2,
                            Register scratch3,
                            Register scratch4) {
   // Adjust this code if not the case.
@@ skipping 82 matching lines @@
 
 void MacroAssembler::Throw(BailoutReason reason) {
   Label throw_start;
   Bind(&throw_start);
 #ifdef DEBUG
   const char* msg = GetBailoutReason(reason);
   RecordComment("Throw message: ");
   RecordComment((msg != NULL) ? msg : "UNKNOWN");
 #endif
 
-  Mov(x0, Operand(Smi::FromInt(reason)));
+  Mov(x0, Smi::FromInt(reason));
   Push(x0);
 
   // Disable stub call restrictions to always allow calls to throw.
   if (!has_frame_) {
     // We don't actually want to generate a pile of code for this, so just
     // claim there is a stack frame, without generating one.
     FrameScope scope(this, StackFrame::NONE);
     CallRuntime(Runtime::kThrowMessage, 1);
   } else {
     CallRuntime(Runtime::kThrowMessage, 1);
@@ skipping 108 matching lines @@
     // Illegal operation: drop the stack arguments and return undefined.
     if (num_arguments > 0) {
       Drop(num_arguments);
     }
     LoadRoot(x0, Heap::kUndefinedValueRootIndex);
     return;
   }
 
   // Place the necessary arguments.
   Mov(x0, num_arguments);
-  Mov(x1, Operand(ExternalReference(f, isolate())));
+  Mov(x1, ExternalReference(f, isolate()));
 
   CEntryStub stub(1, save_doubles);
   CallStub(&stub);
 }
 
 
 static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
   return ref0.address() - ref1.address();
 }
 
@@ skipping 18 matching lines @@
 
   ASSERT(function_address.is(x1) || function_address.is(x2));
 
   Label profiler_disabled;
   Label end_profiler_check;
   bool* is_profiling_flag = isolate()->cpu_profiler()->is_profiling_address();
   STATIC_ASSERT(sizeof(*is_profiling_flag) == 1);
   Mov(x10, reinterpret_cast<uintptr_t>(is_profiling_flag));
   Ldrb(w10, MemOperand(x10));
   Cbz(w10, &profiler_disabled);
-  Mov(x3, Operand(thunk_ref));
+  Mov(x3, thunk_ref);
   B(&end_profiler_check);
 
   Bind(&profiler_disabled);
   Mov(x3, function_address);
   Bind(&end_profiler_check);
 
   // Save the callee-save registers we are going to use.
   // TODO(all): Is this necessary? ARM doesn't do it.
   STATIC_ASSERT(kCallApiFunctionSpillSpace == 4);
   Poke(x19, (spill_offset + 0) * kXRegSize);
   Poke(x20, (spill_offset + 1) * kXRegSize);
   Poke(x21, (spill_offset + 2) * kXRegSize);
   Poke(x22, (spill_offset + 3) * kXRegSize);
 
   // Allocate HandleScope in callee-save registers.
   // We will need to restore the HandleScope after the call to the API function,
   // by allocating it in callee-save registers they will be preserved by C code.
   Register handle_scope_base = x22;
   Register next_address_reg = x19;
   Register limit_reg = x20;
   Register level_reg = w21;
 
-  Mov(handle_scope_base, Operand(next_address));
+  Mov(handle_scope_base, next_address);
   Ldr(next_address_reg, MemOperand(handle_scope_base, kNextOffset));
   Ldr(limit_reg, MemOperand(handle_scope_base, kLimitOffset));
   Ldr(level_reg, MemOperand(handle_scope_base, kLevelOffset));
   Add(level_reg, level_reg, 1);
   Str(level_reg, MemOperand(handle_scope_base, kLevelOffset));
 
   if (FLAG_log_timer_events) {
     FrameScope frame(this, StackFrame::MANUAL);
     PushSafepointRegisters();
-    Mov(x0, Operand(ExternalReference::isolate_address(isolate())));
+    Mov(x0, ExternalReference::isolate_address(isolate()));
     CallCFunction(ExternalReference::log_enter_external_function(isolate()), 1);
     PopSafepointRegisters();
   }
 
   // Native call returns to the DirectCEntry stub which redirects to the
   // return address pushed on stack (could have moved after GC).
   // DirectCEntry stub itself is generated early and never moves.
   DirectCEntryStub stub;
   stub.GenerateCall(this, x3);
 
   if (FLAG_log_timer_events) {
     FrameScope frame(this, StackFrame::MANUAL);
     PushSafepointRegisters();
-    Mov(x0, Operand(ExternalReference::isolate_address(isolate())));
+    Mov(x0, ExternalReference::isolate_address(isolate()));
     CallCFunction(ExternalReference::log_leave_external_function(isolate()), 1);
     PopSafepointRegisters();
   }
 
   Label promote_scheduled_exception;
   Label exception_handled;
   Label delete_allocated_handles;
   Label leave_exit_frame;
   Label return_value_loaded;
 
@@ skipping 15 matching lines @@
   B(ne, &delete_allocated_handles);
 
   Bind(&leave_exit_frame);
   // Restore callee-saved registers.
   Peek(x19, (spill_offset + 0) * kXRegSize);
   Peek(x20, (spill_offset + 1) * kXRegSize);
   Peek(x21, (spill_offset + 2) * kXRegSize);
   Peek(x22, (spill_offset + 3) * kXRegSize);
 
   // Check if the function scheduled an exception.
-  Mov(x5, Operand(ExternalReference::scheduled_exception_address(isolate())));
+  Mov(x5, ExternalReference::scheduled_exception_address(isolate()));
   Ldr(x5, MemOperand(x5));
   JumpIfNotRoot(x5, Heap::kTheHoleValueRootIndex, &promote_scheduled_exception);
   Bind(&exception_handled);
 
   bool restore_context = context_restore_operand != NULL;
   if (restore_context) {
     Ldr(cp, *context_restore_operand);
   }
 
   LeaveExitFrame(false, x1, !restore_context);
   Drop(stack_space);
   Ret();
 
   Bind(&promote_scheduled_exception);
   {
     FrameScope frame(this, StackFrame::INTERNAL);
     CallExternalReference(
         ExternalReference(Runtime::kPromoteScheduledException, isolate()), 0);
   }
   B(&exception_handled);
 
   // HandleScope limit has changed. Delete allocated extensions.
   Bind(&delete_allocated_handles);
   Str(limit_reg, MemOperand(handle_scope_base, kLimitOffset));
   // Save the return value in a callee-save register.
   Register saved_result = x19;
   Mov(saved_result, x0);
-  Mov(x0, Operand(ExternalReference::isolate_address(isolate())));
+  Mov(x0, ExternalReference::isolate_address(isolate()));
   CallCFunction(
       ExternalReference::delete_handle_scope_extensions(isolate()), 1);
   Mov(x0, saved_result);
   B(&leave_exit_frame);
 }
 
 
 void MacroAssembler::CallExternalReference(const ExternalReference& ext,
                                            int num_arguments) {
   Mov(x0, num_arguments);
-  Mov(x1, Operand(ext));
+  Mov(x1, ext);
 
   CEntryStub stub(1);
   CallStub(&stub);
 }
 
 
 void MacroAssembler::JumpToExternalReference(const ExternalReference& builtin) {
-  Mov(x1, Operand(builtin));
+  Mov(x1, builtin);
   CEntryStub stub(1);
   Jump(stub.GetCode(isolate()), RelocInfo::CODE_TARGET);
 }
 
 
 void MacroAssembler::GetBuiltinFunction(Register target,
                                         Builtins::JavaScript id) {
   // Load the builtins object into target register.
   Ldr(target, GlobalObjectMemOperand());
   Ldr(target, FieldMemOperand(target, GlobalObject::kBuiltinsOffset));
@@ skipping 91 matching lines @@
                                    int num_of_reg_args) {
   CallCFunction(function, num_of_reg_args, 0);
 }
 
 
 void MacroAssembler::CallCFunction(ExternalReference function,
                                    int num_of_reg_args,
                                    int num_of_double_args) {
   UseScratchRegisterScope temps(this);
   Register temp = temps.AcquireX();
-  Mov(temp, Operand(function));
+  Mov(temp, function);
   CallCFunction(temp, num_of_reg_args, num_of_double_args);
 }
 
 
 void MacroAssembler::CallCFunction(Register function,
                                    int num_of_reg_args,
                                    int num_of_double_args) {
   ASSERT(has_frame());
   // We can pass 8 integer arguments in registers. If we need to pass more than
   // that, we'll need to implement support for passing them on the stack.
@@ skipping 1010 matching lines @@
 
   Bind(&done);
 }
 
 
 void MacroAssembler::Prologue(PrologueFrameMode frame_mode) {
   if (frame_mode == BUILD_STUB_FRAME) {
     ASSERT(StackPointer().Is(jssp));
     UseScratchRegisterScope temps(this);
     Register temp = temps.AcquireX();
-    __ Mov(temp, Operand(Smi::FromInt(StackFrame::STUB)));
+    __ Mov(temp, Smi::FromInt(StackFrame::STUB));
     // Compiled stubs don't age, and so they don't need the predictable code
     // ageing sequence.
     __ Push(lr, fp, cp, temp);
     __ Add(fp, jssp, StandardFrameConstants::kFixedFrameSizeFromFp);
   } else {
     if (isolate()->IsCodePreAgingActive()) {
       Code* stub = Code::GetPreAgedCodeAgeStub(isolate());
       __ EmitCodeAgeSequence(stub);
     } else {
       __ EmitFrameSetupForCodeAgePatching();
     }
   }
 }
 
 
 void MacroAssembler::EnterFrame(StackFrame::Type type) {
   ASSERT(jssp.Is(StackPointer()));
   UseScratchRegisterScope temps(this);
   Register type_reg = temps.AcquireX();
   Register code_reg = temps.AcquireX();
 
   Push(lr, fp, cp);
-  Mov(type_reg, Operand(Smi::FromInt(type)));
+  Mov(type_reg, Smi::FromInt(type));
   Mov(code_reg, Operand(CodeObject()));
   Push(type_reg, code_reg);
   // jssp[4] : lr
   // jssp[3] : fp
   // jssp[2] : cp
   // jssp[1] : type
   // jssp[0] : code object
 
   // Adjust FP to point to saved FP.
   Add(fp, jssp, StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize);
@@ skipping 136 matching lines @@
   SetStackPointer(jssp);
   AssertStackConsistency();
   Pop(fp, lr);
 }
 
 
 void MacroAssembler::SetCounter(StatsCounter* counter, int value,
                                 Register scratch1, Register scratch2) {
   if (FLAG_native_code_counters && counter->Enabled()) {
     Mov(scratch1, value);
-    Mov(scratch2, Operand(ExternalReference(counter)));
+    Mov(scratch2, ExternalReference(counter));
     Str(scratch1, MemOperand(scratch2));
   }
 }
 
 
 void MacroAssembler::IncrementCounter(StatsCounter* counter, int value,
                                       Register scratch1, Register scratch2) {
   ASSERT(value != 0);
   if (FLAG_native_code_counters && counter->Enabled()) {
-    Mov(scratch2, Operand(ExternalReference(counter)));
+    Mov(scratch2, ExternalReference(counter));
     Ldr(scratch1, MemOperand(scratch2));
     Add(scratch1, scratch1, value);
     Str(scratch1, MemOperand(scratch2));
   }
 }
 
 
 void MacroAssembler::DecrementCounter(StatsCounter* counter, int value,
                                       Register scratch1, Register scratch2) {
   IncrementCounter(counter, -value, scratch1, scratch2);
@@ skipping 12 matching lines @@
     // destination register in case we store into it (the write barrier
     // cannot be allowed to destroy the context in cp).
     Mov(dst, cp);
   }
 }
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 void MacroAssembler::DebugBreak() {
   Mov(x0, 0);
-  Mov(x1, Operand(ExternalReference(Runtime::kDebugBreak, isolate())));
+  Mov(x1, ExternalReference(Runtime::kDebugBreak, isolate()));
   CEntryStub ces(1);
   ASSERT(AllowThisStubCall(&ces));
   Call(ces.GetCode(isolate()), RelocInfo::DEBUG_BREAK);
 }
 #endif
 
 
 void MacroAssembler::PushTryHandler(StackHandler::Kind kind,
                                     int handler_index) {
   ASSERT(jssp.Is(StackPointer()));
@@ skipping 18 matching lines @@
 
   // Push the frame pointer, context, state, and code object.
   if (kind == StackHandler::JS_ENTRY) {
     ASSERT(Smi::FromInt(0) == 0);
     Push(xzr, xzr, x11, x10);
   } else {
     Push(fp, cp, x11, x10);
   }
 
   // Link the current handler as the next handler.
-  Mov(x11, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+  Mov(x11, ExternalReference(Isolate::kHandlerAddress, isolate()));
   Ldr(x10, MemOperand(x11));
   Push(x10);
   // Set this new handler as the current one.
   Str(jssp, MemOperand(x11));
 }
 
 
 void MacroAssembler::PopTryHandler() {
   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
   Pop(x10);
-  Mov(x11, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+  Mov(x11, ExternalReference(Isolate::kHandlerAddress, isolate()));
   Drop(StackHandlerConstants::kSize - kXRegSize, kByteSizeInBytes);
   Str(x10, MemOperand(x11));
 }
 
 
 void MacroAssembler::Allocate(int object_size,
                               Register result,
                               Register scratch1,
                               Register scratch2,
                               Label* gc_required,
@@ skipping 101 matching lines @@
       AllocationUtils::GetAllocationTopReference(isolate(), flags);
   ExternalReference heap_allocation_limit =
       AllocationUtils::GetAllocationLimitReference(isolate(), flags);
   intptr_t top = reinterpret_cast<intptr_t>(heap_allocation_top.address());
   intptr_t limit = reinterpret_cast<intptr_t>(heap_allocation_limit.address());
   ASSERT((limit - top) == kPointerSize);
 
   // Set up allocation top address and object size registers.
   Register top_address = scratch1;
   Register allocation_limit = scratch2;
-  Mov(top_address, Operand(heap_allocation_top));
+  Mov(top_address, heap_allocation_top);
 
   if ((flags & RESULT_CONTAINS_TOP) == 0) {
     // Load allocation top into result and the allocation limit.
     Ldp(result, allocation_limit, MemOperand(top_address));
   } else {
     if (emit_debug_code()) {
       // Assert that result actually contains top on entry.
       Ldr(scratch3, MemOperand(top_address));
       Cmp(result, scratch3);
       Check(eq, kUnexpectedAllocationTop);
@@ skipping 32 matching lines @@
 
 void MacroAssembler::UndoAllocationInNewSpace(Register object,
                                               Register scratch) {
   ExternalReference new_space_allocation_top =
       ExternalReference::new_space_allocation_top_address(isolate());
 
   // Make sure the object has no tag before resetting top.
   Bic(object, object, kHeapObjectTagMask);
 #ifdef DEBUG
   // Check that the object un-allocated is below the current top.
-  Mov(scratch, Operand(new_space_allocation_top));
+  Mov(scratch, new_space_allocation_top);
   Ldr(scratch, MemOperand(scratch));
   Cmp(object, scratch);
   Check(lt, kUndoAllocationOfNonAllocatedMemory);
 #endif
   // Write the address of the object to un-allocate as the current top.
-  Mov(scratch, Operand(new_space_allocation_top));
+  Mov(scratch, new_space_allocation_top);
   Str(object, MemOperand(scratch));
 }
 
 
 void MacroAssembler::AllocateTwoByteString(Register result,
                                            Register length,
                                            Register scratch1,
                                            Register scratch2,
                                            Register scratch3,
                                            Label* gc_required) {
@@ skipping 72 matching lines @@
 void MacroAssembler::AllocateAsciiConsString(Register result,
                                              Register length,
                                              Register scratch1,
                                              Register scratch2,
                                              Label* gc_required) {
   Label allocate_new_space, install_map;
   AllocationFlags flags = TAG_OBJECT;
 
   ExternalReference high_promotion_mode = ExternalReference::
       new_space_high_promotion_mode_active_address(isolate());
-  Mov(scratch1, Operand(high_promotion_mode));
+  Mov(scratch1, high_promotion_mode);
   Ldr(scratch1, MemOperand(scratch1));
   Cbz(scratch1, &allocate_new_space);
 
   Allocate(ConsString::kSize,
            result,
            scratch1,
            scratch2,
            gc_required,
            static_cast<AllocationFlags>(flags | PRETENURE_OLD_POINTER_SPACE));
 
@@ skipping 632 matching lines @@
   if (emit_debug_code()) {
     Label ok;
     JumpIfNotInNewSpace(object, &ok);
     Abort(kRememberedSetPointerInNewSpace);
     bind(&ok);
   }
   UseScratchRegisterScope temps(this);
   Register scratch2 = temps.AcquireX();
 
   // Load store buffer top.
-  Mov(scratch2, Operand(ExternalReference::store_buffer_top(isolate())));
+  Mov(scratch2, ExternalReference::store_buffer_top(isolate()));
   Ldr(scratch1, MemOperand(scratch2));
   // Store pointer to buffer and increment buffer top.
   Str(address, MemOperand(scratch1, kPointerSize, PostIndex));
   // Write back new top of buffer.
   Str(scratch1, MemOperand(scratch2));
   // Call stub on end of buffer.
   // Check for end of buffer.
   ASSERT(StoreBuffer::kStoreBufferOverflowBit ==
          (1 << (14 + kPointerSizeLog2)));
   if (and_then == kFallThroughAtEnd) {
@@ skipping 488 matching lines @@
     Bind(&ok);
   }
 }
 
 
 void MacroAssembler::AssertIsString(const Register& object) {
   if (emit_debug_code()) {
     UseScratchRegisterScope temps(this);
     Register temp = temps.AcquireX();
     STATIC_ASSERT(kSmiTag == 0);
-    Tst(object, Operand(kSmiTagMask));
+    Tst(object, kSmiTagMask);
     Check(ne, kOperandIsNotAString);
     Ldr(temp, FieldMemOperand(object, HeapObject::kMapOffset));
     CompareInstanceType(temp, temp, FIRST_NONSTRING_TYPE);
     Check(lo, kOperandIsNotAString);
   }
 }
 
 
 void MacroAssembler::Check(Condition cond, BailoutReason reason) {
   Label ok;
@@ skipping 34 matching lines @@
   // We need some scratch registers for the MacroAssembler, so make sure we have
   // some. This is safe here because Abort never returns.
   RegList old_tmp_list = TmpList()->list();
   TmpList()->Combine(ip0);
   TmpList()->Combine(ip1);
 
   if (use_real_aborts()) {
     // Avoid infinite recursion; Push contains some assertions that use Abort.
     NoUseRealAbortsScope no_real_aborts(this);
 
-    Mov(x0, Operand(Smi::FromInt(reason)));
+    Mov(x0, Smi::FromInt(reason));
     Push(x0);
 
     if (!has_frame_) {
       // We don't actually want to generate a pile of code for this, so just
       // claim there is a stack frame, without generating one.
       FrameScope scope(this, StackFrame::NONE);
       CallRuntime(Runtime::kAbort, 1);
     } else {
       CallRuntime(Runtime::kAbort, 1);
     }
@@ skipping 381 matching lines @@
 }
 #endif
 
 
 void MacroAssembler::TruncatingDiv(Register result,
                                    Register dividend,
                                    int32_t divisor) {
   ASSERT(!AreAliased(result, dividend));
   ASSERT(result.Is32Bits() && dividend.Is32Bits());
   MultiplierAndShift ms(divisor);
-  Mov(result, Operand(ms.multiplier()));
+  Mov(result, ms.multiplier());
   Smull(result.X(), dividend, result);
   Asr(result.X(), result.X(), 32);
   if (divisor > 0 && ms.multiplier() < 0) Add(result, result, dividend);
   if (divisor < 0 && ms.multiplier() > 0) Sub(result, result, dividend);
   if (ms.shift() > 0) Asr(result, result, ms.shift());
   Add(result, result, Operand(dividend, LSR, 31));
 }
 
 
 #undef __
@@ skipping 70 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64