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

src/a64/full-codegen-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 225 matching lines @@
     if (!function_in_register_x1) {
       // Load this again, if it's used by the local context below.
       __ Ldr(x3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
     } else {
       __ Mov(x3, x1);
     }
     // Receiver is just before the parameters on the caller's stack.
     int num_parameters = info->scope()->num_parameters();
     int offset = num_parameters * kPointerSize;
     __ Add(x2, fp, StandardFrameConstants::kCallerSPOffset + offset);
-    __ Mov(x1, Operand(Smi::FromInt(num_parameters)));
+    __ Mov(x1, Smi::FromInt(num_parameters));
     __ Push(x3, x2, x1);
 
     // Arguments to ArgumentsAccessStub:
     //   function, receiver address, parameter count.
     // The stub will rewrite receiver and parameter count if the previous
     // stack frame was an arguments adapter frame.
     ArgumentsAccessStub::Type type;
     if (strict_mode() == STRICT) {
       type = ArgumentsAccessStub::NEW_STRICT;
     } else if (function()->has_duplicate_parameters()) {
@@ skipping 58 matching lines @@
   EmitReturnSequence();
 
   // Force emission of the pools, so they don't get emitted in the middle
   // of the back edge table.
   masm()->CheckVeneerPool(true, false);
   masm()->CheckConstPool(true, false);
 }
 
 
 void FullCodeGenerator::ClearAccumulator() {
-  __ Mov(x0, Operand(Smi::FromInt(0)));
+  __ Mov(x0, Smi::FromInt(0));
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
   __ Mov(x2, Operand(profiling_counter_));
   __ Ldr(x3, FieldMemOperand(x2, Cell::kValueOffset));
-  __ Subs(x3, x3, Operand(Smi::FromInt(delta)));
+  __ Subs(x3, x3, Smi::FromInt(delta));
   __ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterReset() {
   int reset_value = FLAG_interrupt_budget;
   if (isolate()->IsDebuggerActive()) {
     // Detect debug break requests as soon as possible.
     reset_value = FLAG_interrupt_budget >> 4;
   }
   __ Mov(x2, Operand(profiling_counter_));
-  __ Mov(x3, Operand(Smi::FromInt(reset_value)));
+  __ Mov(x3, Smi::FromInt(reset_value));
   __ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
 }
 
 
 void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,
                                                 Label* back_edge_target) {
   ASSERT(jssp.Is(__ StackPointer()));
   Comment cmnt(masm_, "[ Back edge bookkeeping");
   // Block literal pools whilst emitting back edge code.
   Assembler::BlockPoolsScope block_const_pool(masm_);
@@ skipping 469 matching lines @@
       }
       break;
 
     case Variable::LOOKUP: {
       Comment cmnt(masm_, "[ VariableDeclaration");
       __ Mov(x2, Operand(variable->name()));
       // Declaration nodes are always introduced in one of four modes.
       ASSERT(IsDeclaredVariableMode(mode));
       PropertyAttributes attr = IsImmutableVariableMode(mode) ? READ_ONLY
                                                               : NONE;
-      __ Mov(x1, Operand(Smi::FromInt(attr)));
+      __ Mov(x1, Smi::FromInt(attr));
       // Push initial value, if any.
       // Note: For variables we must not push an initial value (such as
       // 'undefined') because we may have a (legal) redeclaration and we
       // must not destroy the current value.
       if (hole_init) {
         __ LoadRoot(x0, Heap::kTheHoleValueRootIndex);
         __ Push(cp, x2, x1, x0);
       } else {
         // Pushing 0 (xzr) indicates no initial value.
         __ Push(cp, x2, x1, xzr);
@@ skipping 43 matching lines @@
                                 kDontSaveFPRegs,
                                 EMIT_REMEMBERED_SET,
                                 OMIT_SMI_CHECK);
       PrepareForBailoutForId(proxy->id(), NO_REGISTERS);
       break;
     }
 
     case Variable::LOOKUP: {
       Comment cmnt(masm_, "[ Function Declaration");
       __ Mov(x2, Operand(variable->name()));
-      __ Mov(x1, Operand(Smi::FromInt(NONE)));
+      __ Mov(x1, Smi::FromInt(NONE));
       __ Push(cp, x2, x1);
       // Push initial value for function declaration.
       VisitForStackValue(declaration->fun());
       __ CallRuntime(Runtime::kDeclareContextSlot, 4);
       break;
     }
   }
 }
 
 
@@ skipping 55 matching lines @@
   // TODO(rossberg)
 }
 
 
 void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   // Call the runtime to declare the globals.
   __ Mov(x11, Operand(pairs));
   Register flags = xzr;
   if (Smi::FromInt(DeclareGlobalsFlags())) {
     flags = x10;
-  __ Mov(flags, Operand(Smi::FromInt(DeclareGlobalsFlags())));
+  __ Mov(flags, Smi::FromInt(DeclareGlobalsFlags()));
   }
   __ Push(cp, x11, flags);
   __ CallRuntime(Runtime::kDeclareGlobals, 3);
   // Return value is ignored.
 }
 
 
 void FullCodeGenerator::DeclareModules(Handle<FixedArray> descriptions) {
   // Call the runtime to declare the modules.
   __ Push(descriptions);
@@ skipping 158 matching lines @@
   __ EnumLengthUntagged(x1, x0);
   __ Cbz(x1, &no_descriptors);
 
   __ LoadInstanceDescriptors(x0, x2);
   __ Ldr(x2, FieldMemOperand(x2, DescriptorArray::kEnumCacheOffset));
   __ Ldr(x2,
          FieldMemOperand(x2, DescriptorArray::kEnumCacheBridgeCacheOffset));
 
   // Set up the four remaining stack slots.
   __ Push(x0);  // Map.
-  __ Mov(x0, Operand(Smi::FromInt(0)));
+  __ Mov(x0, Smi::FromInt(0));
   // Push enumeration cache, enumeration cache length (as smi) and zero.
   __ SmiTag(x1);
   __ Push(x2, x1, x0);
   __ B(&loop);
 
   __ Bind(&no_descriptors);
   __ Drop(1);
   __ B(&exit);
 
   // We got a fixed array in register x0. Iterate through that.
   __ Bind(&fixed_array);
 
   Handle<Object> feedback = Handle<Object>(
       Smi::FromInt(TypeFeedbackInfo::kForInFastCaseMarker),
       isolate());
   StoreFeedbackVectorSlot(slot, feedback);
   __ LoadObject(x1, FeedbackVector());
-  __ Mov(x10, Operand(Smi::FromInt(TypeFeedbackInfo::kForInSlowCaseMarker)));
+  __ Mov(x10, Smi::FromInt(TypeFeedbackInfo::kForInSlowCaseMarker));
   __ Str(x10, FieldMemOperand(x1, FixedArray::OffsetOfElementAt(slot)));
 
-  __ Mov(x1, Operand(Smi::FromInt(1)));  // Smi indicates slow check.
+  __ Mov(x1, Smi::FromInt(1));  // Smi indicates slow check.
   __ Peek(x10, 0);  // Get enumerated object.
   STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
   // TODO(all): similar check was done already. Can we avoid it here?
   __ CompareObjectType(x10, x11, x12, LAST_JS_PROXY_TYPE);
   ASSERT(Smi::FromInt(0) == 0);
   __ CzeroX(x1, le);  // Zero indicates proxy.
   __ Push(x1, x0);  // Smi and array
   __ Ldr(x1, FieldMemOperand(x0, FixedArray::kLengthOffset));
   __ Push(x1, xzr);  // Fixed array length (as smi) and initial index.
 
@@ skipping 45 matching lines @@
   }
 
   // Generate code for the body of the loop.
   Visit(stmt->body());
 
   // Generate code for going to the next element by incrementing
   // the index (smi) stored on top of the stack.
   __ Bind(loop_statement.continue_label());
   // TODO(all): We could use a callee saved register to avoid popping.
   __ Pop(x0);
-  __ Add(x0, x0, Operand(Smi::FromInt(1)));
+  __ Add(x0, x0, Smi::FromInt(1));
   __ Push(x0);
 
   EmitBackEdgeBookkeeping(stmt, &loop);
   __ B(&loop);
 
   // Remove the pointers stored on the stack.
   __ Bind(loop_statement.break_label());
   __ Drop(5);
 
   // Exit and decrement the loop depth.
@@ skipping 324 matching lines @@
   // x0 = RegExp literal clone
   __ Ldr(x10, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ Ldr(x4, FieldMemOperand(x10, JSFunction::kLiteralsOffset));
   int literal_offset =
       FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ Ldr(x5, FieldMemOperand(x4, literal_offset));
   __ JumpIfNotRoot(x5, Heap::kUndefinedValueRootIndex, &materialized);
 
   // Create regexp literal using runtime function.
   // Result will be in x0.
-  __ Mov(x3, Operand(Smi::FromInt(expr->literal_index())));
+  __ Mov(x3, Smi::FromInt(expr->literal_index()));
   __ Mov(x2, Operand(expr->pattern()));
   __ Mov(x1, Operand(expr->flags()));
   __ Push(x4, x3, x2, x1);
   __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
   __ Mov(x5, x0);
 
   __ Bind(&materialized);
   int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
   Label allocated, runtime_allocate;
   __ Allocate(size, x0, x2, x3, &runtime_allocate, TAG_OBJECT);
   __ B(&allocated);
 
   __ Bind(&runtime_allocate);
-  __ Mov(x10, Operand(Smi::FromInt(size)));
+  __ Mov(x10, Smi::FromInt(size));
   __ Push(x5, x10);
   __ CallRuntime(Runtime::kAllocateInNewSpace, 1);
   __ Pop(x5);
 
   __ Bind(&allocated);
   // After this, registers are used as follows:
   // x0: Newly allocated regexp.
   // x5: Materialized regexp.
   // x10, x11, x12: temps.
   __ CopyFields(x0, x5, CPURegList(x10, x11, x12), size / kPointerSize);
@@ skipping 11 matching lines @@
 }
 
 
 void FullCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
 
   expr->BuildConstantProperties(isolate());
   Handle<FixedArray> constant_properties = expr->constant_properties();
   __ Ldr(x3, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
   __ Ldr(x3, FieldMemOperand(x3, JSFunction::kLiteralsOffset));
-  __ Mov(x2, Operand(Smi::FromInt(expr->literal_index())));
+  __ Mov(x2, Smi::FromInt(expr->literal_index()));
   __ Mov(x1, Operand(constant_properties));
   int flags = expr->fast_elements()
       ? ObjectLiteral::kFastElements
       : ObjectLiteral::kNoFlags;
   flags |= expr->has_function()
       ? ObjectLiteral::kHasFunction
       : ObjectLiteral::kNoFlags;
-  __ Mov(x0, Operand(Smi::FromInt(flags)));
+  __ Mov(x0, Smi::FromInt(flags));
   int properties_count = constant_properties->length() / 2;
   const int max_cloned_properties =
       FastCloneShallowObjectStub::kMaximumClonedProperties;
   if (expr->may_store_doubles() || expr->depth() > 1 || Serializer::enabled() ||
       flags != ObjectLiteral::kFastElements ||
       properties_count > max_cloned_properties) {
     __ Push(x3, x2, x1, x0);
     __ CallRuntime(Runtime::kCreateObjectLiteral, 4);
   } else {
     FastCloneShallowObjectStub stub(properties_count);
@@ skipping 38 matching lines @@
             VisitForEffect(value);
           }
           break;
         }
         if (property->emit_store()) {
           // Duplicate receiver on stack.
           __ Peek(x0, 0);
           __ Push(x0);
           VisitForStackValue(key);
           VisitForStackValue(value);
-          __ Mov(x0, Operand(Smi::FromInt(NONE)));  // PropertyAttributes
+          __ Mov(x0, Smi::FromInt(NONE));  // PropertyAttributes
           __ Push(x0);
           __ CallRuntime(Runtime::kSetProperty, 4);
         } else {
           VisitForEffect(key);
           VisitForEffect(value);
         }
         break;
       case ObjectLiteral::Property::PROTOTYPE:
         if (property->emit_store()) {
           // Duplicate receiver on stack.
@@ skipping 17 matching lines @@
   // 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) {
       __ Peek(x10, 0);  // Duplicate receiver.
       __ Push(x10);
       VisitForStackValue(it->first);
       EmitAccessor(it->second->getter);
       EmitAccessor(it->second->setter);
-      __ Mov(x10, Operand(Smi::FromInt(NONE)));
+      __ Mov(x10, Smi::FromInt(NONE));
       __ Push(x10);
       __ CallRuntime(Runtime::kDefineOrRedefineAccessorProperty, 5);
   }
 
   if (expr->has_function()) {
     ASSERT(result_saved);
     __ Peek(x0, 0);
     __ Push(x0);
     __ CallRuntime(Runtime::kToFastProperties, 1);
   }
@@ skipping 25 matching lines @@
 
   AllocationSiteMode allocation_site_mode = TRACK_ALLOCATION_SITE;
   if (has_fast_elements && !FLAG_allocation_site_pretenuring) {
     // If the only customer of allocation sites is transitioning, then
     // we can turn it off if we don't have anywhere else to transition to.
     allocation_site_mode = DONT_TRACK_ALLOCATION_SITE;
   }
 
   __ Ldr(x3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ Ldr(x3, FieldMemOperand(x3, JSFunction::kLiteralsOffset));
-  // TODO(jbramley): Can these Operand constructors be implicit?
-  __ Mov(x2, Operand(Smi::FromInt(expr->literal_index())));
+  __ Mov(x2, Smi::FromInt(expr->literal_index()));
   __ Mov(x1, Operand(constant_elements));
   if (has_fast_elements && constant_elements_values->map() ==
       isolate()->heap()->fixed_cow_array_map()) {
     FastCloneShallowArrayStub stub(
         FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS,
         allocation_site_mode,
         length);
     __ CallStub(&stub);
     __ IncrementCounter(
         isolate()->counters()->cow_arrays_created_stub(), 1, x10, x11);
   } else if ((expr->depth() > 1) || Serializer::enabled() ||
              length > FastCloneShallowArrayStub::kMaximumClonedLength) {
-    __ Mov(x0, Operand(Smi::FromInt(flags)));
+    __ Mov(x0, Smi::FromInt(flags));
     __ Push(x3, x2, x1, x0);
     __ CallRuntime(Runtime::kCreateArrayLiteral, 4);
   } else {
     ASSERT(IsFastSmiOrObjectElementsKind(constant_elements_kind) ||
            FLAG_smi_only_arrays);
     FastCloneShallowArrayStub::Mode mode =
         FastCloneShallowArrayStub::CLONE_ANY_ELEMENTS;
 
     if (has_fast_elements) {
       mode = FastCloneShallowArrayStub::CLONE_ELEMENTS;
@@ skipping 23 matching lines @@
     if (IsFastObjectElementsKind(constant_elements_kind)) {
       int offset = FixedArray::kHeaderSize + (i * kPointerSize);
       __ Peek(x6, kPointerSize);  // Copy of array literal.
       __ Ldr(x1, FieldMemOperand(x6, JSObject::kElementsOffset));
       __ Str(result_register(), FieldMemOperand(x1, offset));
       // Update the write barrier for the array store.
       __ RecordWriteField(x1, offset, result_register(), x10,
                           kLRHasBeenSaved, kDontSaveFPRegs,
                           EMIT_REMEMBERED_SET, INLINE_SMI_CHECK);
     } else {
-      __ Mov(x3, Operand(Smi::FromInt(i)));
+      __ Mov(x3, Smi::FromInt(i));
       StoreArrayLiteralElementStub stub;
       __ CallStub(&stub);
     }
 
     PrepareForBailoutForId(expr->GetIdForElement(i), NO_REGISTERS);
   }
 
   if (result_saved) {
     __ Drop(1);   // literal index
     context()->PlugTOS();
@@ skipping 302 matching lines @@
     int offset = Context::SlotOffset(var->index());
     __ RecordWriteContextSlot(
         x1, offset, x10, x11, kLRHasBeenSaved, kDontSaveFPRegs);
   }
 }
 
 
 void FullCodeGenerator::EmitCallStoreContextSlot(
     Handle<String> name, StrictMode strict_mode) {
   __ Mov(x11, Operand(name));
-  __ Mov(x10, Operand(Smi::FromInt(strict_mode)));
+  __ Mov(x10, Smi::FromInt(strict_mode));
   // jssp[0]  : mode.
   // jssp[8]  : name.
   // jssp[16] : context.
   // jssp[24] : value.
   __ Push(x0, cp, x11, x10);
   __ CallRuntime(Runtime::kStoreContextSlot, 4);
 }
 
 
 void FullCodeGenerator::EmitVariableAssignment(Variable* var,
@@ skipping 229 matching lines @@
       VisitForStackValue(args->at(i));
     }
   }
   // Record source position for debugger.
   SetSourcePosition(expr->position());
 
   Handle<Object> uninitialized =
       TypeFeedbackInfo::UninitializedSentinel(isolate());
   StoreFeedbackVectorSlot(expr->CallFeedbackSlot(), uninitialized);
   __ LoadObject(x2, FeedbackVector());
-  __ Mov(x3, Operand(Smi::FromInt(expr->CallFeedbackSlot())));
+  __ Mov(x3, Smi::FromInt(expr->CallFeedbackSlot()));
 
   // Record call targets in unoptimized code.
   CallFunctionStub stub(arg_count, RECORD_CALL_TARGET);
   __ Peek(x1, (arg_count + 1) * kXRegSize);
   __ CallStub(&stub);
   RecordJSReturnSite(expr);
   // Restore context register.
   __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   context()->DropAndPlug(1, x0);
 }
@@ skipping 10 matching lines @@
   }
 
   // Prepare to push the receiver of the enclosing function.
   int receiver_offset = 2 + info_->scope()->num_parameters();
   __ Ldr(x11, MemOperand(fp, receiver_offset * kPointerSize));
 
   // Push.
   __ Push(x10, x11);
 
   // Prepare to push the language mode.
-  __ Mov(x10, Operand(Smi::FromInt(strict_mode())));
+  __ Mov(x10, Smi::FromInt(strict_mode()));
   // Prepare to push the start position of the scope the calls resides in.
-  __ Mov(x11, Operand(Smi::FromInt(scope()->start_position())));
+  __ Mov(x11, Smi::FromInt(scope()->start_position()));
 
   // Push.
   __ Push(x10, x11);
 
   // Do the runtime call.
   __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
 }
 
 
 void FullCodeGenerator::VisitCall(Call* expr) {
@@ skipping 152 matching lines @@
       TypeFeedbackInfo::UninitializedSentinel(isolate());
   StoreFeedbackVectorSlot(expr->CallNewFeedbackSlot(), uninitialized);
   if (FLAG_pretenuring_call_new) {
     StoreFeedbackVectorSlot(expr->AllocationSiteFeedbackSlot(),
                             isolate()->factory()->NewAllocationSite());
     ASSERT(expr->AllocationSiteFeedbackSlot() ==
            expr->CallNewFeedbackSlot() + 1);
   }
 
   __ LoadObject(x2, FeedbackVector());
-  __ Mov(x3, Operand(Smi::FromInt(expr->CallNewFeedbackSlot())));
+  __ Mov(x3, Smi::FromInt(expr->CallNewFeedbackSlot()));
 
   CallConstructStub stub(RECORD_CALL_TARGET);
   __ Call(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL);
   PrepareForBailoutForId(expr->ReturnId(), TOS_REG);
   context()->Plug(x0);
 }
 
 
 void FullCodeGenerator::EmitIsSmi(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
@@ skipping 318 matching lines @@
   Label* fall_through = NULL;
   context()->PrepareTest(&materialize_true, &materialize_false,
                          &if_true, &if_false, &fall_through);
 
   // Get the frame pointer for the calling frame.
   __ Ldr(x2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
 
   // Skip the arguments adaptor frame if it exists.
   Label check_frame_marker;
   __ Ldr(x1, MemOperand(x2, StandardFrameConstants::kContextOffset));
-  __ Cmp(x1, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+  __ Cmp(x1, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   __ B(ne, &check_frame_marker);
   __ Ldr(x2, MemOperand(x2, StandardFrameConstants::kCallerFPOffset));
 
   // Check the marker in the calling frame.
   __ Bind(&check_frame_marker);
   __ Ldr(x1, MemOperand(x2, StandardFrameConstants::kMarkerOffset));
-  __ Cmp(x1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
+  __ Cmp(x1, Smi::FromInt(StackFrame::CONSTRUCT));
   PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
   Split(eq, if_true, if_false, fall_through);
 
   context()->Plug(if_true, if_false);
 }
 
 
 void FullCodeGenerator::EmitObjectEquals(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   ASSERT(args->length() == 2);
@@ skipping 18 matching lines @@
 }
 
 
 void FullCodeGenerator::EmitArguments(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   ASSERT(args->length() == 1);
 
   // ArgumentsAccessStub expects the key in x1.
   VisitForAccumulatorValue(args->at(0));
   __ Mov(x1, x0);
-  __ Mov(x0, Operand(Smi::FromInt(info_->scope()->num_parameters())));
+  __ Mov(x0, Smi::FromInt(info_->scope()->num_parameters()));
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_ELEMENT);
   __ CallStub(&stub);
   context()->Plug(x0);
 }
 
 
 void FullCodeGenerator::EmitArgumentsLength(CallRuntime* expr) {
   ASSERT(expr->arguments()->length() == 0);
   Label exit;
   // Get the number of formal parameters.
-  __ Mov(x0, Operand(Smi::FromInt(info_->scope()->num_parameters())));
+  __ Mov(x0, Smi::FromInt(info_->scope()->num_parameters()));
 
   // Check if the calling frame is an arguments adaptor frame.
   __ Ldr(x12, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ Ldr(x13, MemOperand(x12, StandardFrameConstants::kContextOffset));
-  __ Cmp(x13, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+  __ Cmp(x13, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   __ B(ne, &exit);
 
   // Arguments adaptor case: Read the arguments length from the
   // adaptor frame.
   __ Ldr(x0, MemOperand(x12, ArgumentsAdaptorFrameConstants::kLengthOffset));
 
   __ Bind(&exit);
   context()->Plug(x0);
 }
 
@@ skipping 145 matching lines @@
 
   __ JumpIfSmi(object, &not_date_object);
   __ JumpIfNotObjectType(object, x10, x10, JS_DATE_TYPE, &not_date_object);
 
   if (index->value() == 0) {
     __ Ldr(result, FieldMemOperand(object, JSDate::kValueOffset));
     __ B(&done);
   } else {
     if (index->value() < JSDate::kFirstUncachedField) {
       ExternalReference stamp = ExternalReference::date_cache_stamp(isolate());
-      __ Mov(x10, Operand(stamp));
+      __ Mov(x10, stamp);
       __ Ldr(stamp_addr, MemOperand(x10));
       __ Ldr(stamp_cache, FieldMemOperand(object, JSDate::kCacheStampOffset));
       __ Cmp(stamp_addr, stamp_cache);
       __ B(ne, &runtime);
       __ Ldr(result, FieldMemOperand(object, JSDate::kValueOffset +
                                              kPointerSize * index->value()));
       __ B(&done);
     }
 
     __ Bind(&runtime);
-    __ Mov(x1, Operand(index));
+    __ Mov(x1, index);
     __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
     __ B(&done);
   }
 
   __ Bind(&not_date_object);
   __ CallRuntime(Runtime::kThrowNotDateError, 0);
   __ Bind(&done);
   context()->Plug(x0);
 }
 
@@ skipping 207 matching lines @@
   __ B(&done);
 
   __ Bind(&index_out_of_range);
   // When the index is out of range, the spec requires us to return
   // the empty string.
   __ LoadRoot(result, Heap::kempty_stringRootIndex);
   __ B(&done);
 
   __ Bind(&need_conversion);
   // Move smi zero into the result register, which will trigger conversion.
-  __ Mov(result, Operand(Smi::FromInt(0)));
+  __ Mov(result, Smi::FromInt(0));
   __ B(&done);
 
   NopRuntimeCallHelper call_helper;
   generator.GenerateSlow(masm_, call_helper);
 
   __ Bind(&done);
   context()->Plug(result);
 }
 
 
@@ skipping 232 matching lines @@
   __ Add(elements_end, element, Operand(array_length, LSL, kPointerSizeLog2));
   // Loop condition: while (element < elements_end).
   // Live values in registers:
   //   elements: Fixed array of strings.
   //   array_length: Length of the fixed array of strings (not smi)
   //   separator: Separator string
   //   string_length: Accumulated sum of string lengths (not smi).
   //   element: Current array element.
   //   elements_end: Array end.
   if (FLAG_debug_code) {
-    __ Cmp(array_length, Operand(0));
+    __ Cmp(array_length, 0);
     __ Assert(gt, kNoEmptyArraysHereInEmitFastAsciiArrayJoin);
   }
   __ Bind(&loop);
   __ Ldr(string, MemOperand(element, kPointerSize, PostIndex));
   __ JumpIfSmi(string, &bailout);
   __ Ldr(scratch1, FieldMemOperand(string, HeapObject::kMapOffset));
   __ Ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
   __ JumpIfInstanceTypeIsNotSequentialAscii(scratch1, scratch2, &bailout);
   __ Ldrsw(scratch1,
            UntagSmiFieldMemOperand(string, SeqOneByteString::kLengthOffset));
@@ skipping 192 matching lines @@
 void FullCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::DELETE: {
       Comment cmnt(masm_, "[ UnaryOperation (DELETE)");
       Property* property = expr->expression()->AsProperty();
       VariableProxy* proxy = expr->expression()->AsVariableProxy();
 
       if (property != NULL) {
         VisitForStackValue(property->obj());
         VisitForStackValue(property->key());
-        __ Mov(x10, Operand(Smi::FromInt(strict_mode())));
+        __ Mov(x10, Smi::FromInt(strict_mode()));
         __ Push(x10);
         __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
         context()->Plug(x0);
       } else if (proxy != NULL) {
         Variable* var = proxy->var();
         // Delete of an unqualified identifier is disallowed in strict mode
         // but "delete this" is allowed.
         ASSERT(strict_mode() == SLOPPY || var->is_this());
         if (var->IsUnallocated()) {
           __ Ldr(x12, GlobalObjectMemOperand());
           __ Mov(x11, Operand(var->name()));
-          __ Mov(x10, Operand(Smi::FromInt(SLOPPY)));
+          __ Mov(x10, Smi::FromInt(SLOPPY));
           __ Push(x12, x11, x10);
           __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
           context()->Plug(x0);
         } else if (var->IsStackAllocated() || var->IsContextSlot()) {
           // Result of deleting non-global, non-dynamic variables is false.
           // The subexpression does not have side effects.
           context()->Plug(var->is_this());
         } else {
           // Non-global variable.  Call the runtime to try to delete from the
           // context where the variable was introduced.
@@ skipping 147 matching lines @@
           case NAMED_PROPERTY:
             __ Poke(x0, kPointerSize);
             break;
           case KEYED_PROPERTY:
             __ Poke(x0, kPointerSize * 2);
             break;
         }
       }
     }
 
-    __ Adds(x0, x0, Operand(Smi::FromInt(count_value)));
+    __ Adds(x0, x0, Smi::FromInt(count_value));
     __ B(vc, &done);
     // Call stub. Undo operation first.
-    __ Sub(x0, x0, Operand(Smi::FromInt(count_value)));
+    __ Sub(x0, x0, Smi::FromInt(count_value));
     __ B(&stub_call);
     __ Bind(&slow);
   }
   ToNumberStub convert_stub;
   __ CallStub(&convert_stub);
 
   // Save result for postfix expressions.
   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(x0);
           break;
         case NAMED_PROPERTY:
           __ Poke(x0, kXRegSize);
           break;
         case KEYED_PROPERTY:
           __ Poke(x0, 2 * kXRegSize);
           break;
       }
     }
   }
 
   __ Bind(&stub_call);
   __ Mov(x1, x0);
-  __ Mov(x0, Operand(Smi::FromInt(count_value)));
+  __ Mov(x0, Smi::FromInt(count_value));
 
   // Record position before stub call.
   SetSourcePosition(expr->position());
 
   {
     Assembler::BlockPoolsScope scope(masm_);
     BinaryOpICStub stub(Token::ADD, NO_OVERWRITE);
     CallIC(stub.GetCode(isolate()), expr->CountBinOpFeedbackId());
     patch_site.EmitPatchInfo();
   }
@@ skipping 313 matching lines @@
 
       // TODO(jbramley): This label is bound here because the following code
       // looks at its pos(). Is it possible to do something more efficient here,
       // perhaps using Adr?
       __ Bind(&continuation);
       __ B(&resume);
 
       __ Bind(&suspend);
       VisitForAccumulatorValue(expr->generator_object());
       ASSERT((continuation.pos() > 0) && Smi::IsValid(continuation.pos()));
-      __ Mov(x1, Operand(Smi::FromInt(continuation.pos())));
+      __ Mov(x1, Smi::FromInt(continuation.pos()));
       __ Str(x1, FieldMemOperand(x0, JSGeneratorObject::kContinuationOffset));
       __ Str(cp, FieldMemOperand(x0, JSGeneratorObject::kContextOffset));
       __ Mov(x1, cp);
       __ RecordWriteField(x0, JSGeneratorObject::kContextOffset, x1, x2,
                           kLRHasBeenSaved, kDontSaveFPRegs);
       __ Add(x1, fp, StandardFrameConstants::kExpressionsOffset);
       __ Cmp(__ StackPointer(), x1);
       __ B(eq, &post_runtime);
       __ Push(x0);  // generator object
       __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
       __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
       __ Bind(&post_runtime);
       __ Pop(result_register());
       EmitReturnSequence();
 
       __ Bind(&resume);
       context()->Plug(result_register());
       break;
     }
 
     case Yield::FINAL: {
       VisitForAccumulatorValue(expr->generator_object());
-      __ Mov(x1, Operand(Smi::FromInt(JSGeneratorObject::kGeneratorClosed)));
+      __ Mov(x1, Smi::FromInt(JSGeneratorObject::kGeneratorClosed));
       __ Str(x1, FieldMemOperand(result_register(),
                                  JSGeneratorObject::kContinuationOffset));
       // Pop value from top-of-stack slot, box result into result register.
       EmitCreateIteratorResult(true);
       EmitUnwindBeforeReturn();
       EmitReturnSequence();
       break;
     }
 
     case Yield::DELEGATING: {
@@ skipping 31 matching lines @@
       // looks at its pos(). Is it possible to do something more efficient here,
       // perhaps using Adr?
       __ Bind(&l_continuation);
       __ B(&l_resume);
 
       __ Bind(&l_suspend);
       const int generator_object_depth = kPointerSize + handler_size;
       __ Peek(x0, generator_object_depth);
       __ Push(x0);                                       // g
       ASSERT((l_continuation.pos() > 0) && Smi::IsValid(l_continuation.pos()));
-      __ Mov(x1, Operand(Smi::FromInt(l_continuation.pos())));
+      __ Mov(x1, Smi::FromInt(l_continuation.pos()));
       __ Str(x1, FieldMemOperand(x0, JSGeneratorObject::kContinuationOffset));
       __ Str(cp, FieldMemOperand(x0, JSGeneratorObject::kContextOffset));
       __ Mov(x1, cp);
       __ RecordWriteField(x0, JSGeneratorObject::kContextOffset, x1, x2,
                           kLRHasBeenSaved, kDontSaveFPRegs);
       __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
       __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
       __ Pop(x0);                                        // result
       EmitReturnSequence();
       __ Bind(&l_resume);                                // received in x0
@@ skipping 57 matching lines @@
   VisitForStackValue(generator);
   VisitForAccumulatorValue(value);
   __ Pop(generator_object);
 
   // Check generator state.
   Label wrong_state, closed_state, done;
   __ Ldr(x10, FieldMemOperand(generator_object,
                               JSGeneratorObject::kContinuationOffset));
   STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
   STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
-  __ CompareAndBranch(x10, Operand(Smi::FromInt(0)), eq, &closed_state);
-  __ CompareAndBranch(x10, Operand(Smi::FromInt(0)), lt, &wrong_state);
+  __ CompareAndBranch(x10, Smi::FromInt(0), eq, &closed_state);
+  __ CompareAndBranch(x10, Smi::FromInt(0), lt, &wrong_state);
 
   // Load suspended function and context.
   __ Ldr(cp, FieldMemOperand(generator_object,
                              JSGeneratorObject::kContextOffset));
   __ Ldr(function, FieldMemOperand(generator_object,
                                    JSGeneratorObject::kFunctionOffset));
 
   // Load receiver and store as the first argument.
   __ Ldr(x10, FieldMemOperand(generator_object,
                               JSGeneratorObject::kReceiverOffset));
@@ skipping 33 matching lines @@
   // If we are sending a value and there is no operand stack, we can jump back
   // in directly.
   if (resume_mode == JSGeneratorObject::NEXT) {
     Label slow_resume;
     __ Cbnz(operand_stack_size, &slow_resume);
     __ Ldr(x10, FieldMemOperand(function, JSFunction::kCodeEntryOffset));
     __ Ldrsw(x11,
              UntagSmiFieldMemOperand(generator_object,
                                      JSGeneratorObject::kContinuationOffset));
     __ Add(x10, x10, x11);
-    __ Mov(x12, Operand(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting)));
+    __ Mov(x12, Smi::FromInt(JSGeneratorObject::kGeneratorExecuting));
     __ Str(x12, FieldMemOperand(generator_object,
                                 JSGeneratorObject::kContinuationOffset));
     __ Br(x10);
 
     __ Bind(&slow_resume);
   }
 
   // Otherwise, we push holes for the operand stack and call the runtime to fix
   // up the stack and the handlers.
   __ PushMultipleTimes(the_hole, operand_stack_size);
 
-  __ Mov(x10, Operand(Smi::FromInt(resume_mode)));
+  __ Mov(x10, Smi::FromInt(resume_mode));
   __ Push(generator_object, result_register(), x10);
   __ CallRuntime(Runtime::kResumeJSGeneratorObject, 3);
   // Not reached: the runtime call returns elsewhere.
   __ Unreachable();
 
   // Reach here when generator is closed.
   __ Bind(&closed_state);
   if (resume_mode == JSGeneratorObject::NEXT) {
     // Return completed iterator result when generator is closed.
     __ LoadRoot(x10, Heap::kUndefinedValueRootIndex);
@@ skipping 123 matching lines @@
   ASSERT(!result_register().is(x10));
   // Preserve the result register while executing finally block.
   // Also cook the return address in lr to the stack (smi encoded Code* delta).
   __ Sub(x10, lr, Operand(masm_->CodeObject()));
   __ SmiTag(x10);
   __ Push(result_register(), x10);
 
   // Store pending message while executing finally block.
   ExternalReference pending_message_obj =
       ExternalReference::address_of_pending_message_obj(isolate());
-  __ Mov(x10, Operand(pending_message_obj));
+  __ Mov(x10, pending_message_obj);
   __ Ldr(x10, MemOperand(x10));
 
   ExternalReference has_pending_message =
       ExternalReference::address_of_has_pending_message(isolate());
-  __ Mov(x11, Operand(has_pending_message));
+  __ Mov(x11, has_pending_message);
   __ Ldr(x11, MemOperand(x11));
   __ SmiTag(x11);
 
   __ Push(x10, x11);
 
   ExternalReference pending_message_script =
       ExternalReference::address_of_pending_message_script(isolate());
-  __ Mov(x10, Operand(pending_message_script));
+  __ Mov(x10, pending_message_script);
   __ Ldr(x10, MemOperand(x10));
   __ Push(x10);
 }
 
 
 void FullCodeGenerator::ExitFinallyBlock() {
   ASM_LOCATION("FullCodeGenerator::ExitFinallyBlock");
   ASSERT(!result_register().is(x10));
 
   // Restore pending message from stack.
   __ Pop(x10, x11, x12);
   ExternalReference pending_message_script =
       ExternalReference::address_of_pending_message_script(isolate());
-  __ Mov(x13, Operand(pending_message_script));
+  __ Mov(x13, pending_message_script);
   __ Str(x10, MemOperand(x13));
 
   __ SmiUntag(x11);
   ExternalReference has_pending_message =
       ExternalReference::address_of_has_pending_message(isolate());
-  __ Mov(x13, Operand(has_pending_message));
+  __ Mov(x13, has_pending_message);
   __ Str(x11, MemOperand(x13));
 
   ExternalReference pending_message_obj =
       ExternalReference::address_of_pending_message_obj(isolate());
-  __ Mov(x13, Operand(pending_message_obj));
+  __ Mov(x13, pending_message_obj);
   __ Str(x12, MemOperand(x13));
 
   // Restore result register and cooked return address from the stack.
   __ Pop(x10, result_register());
 
   // Uncook the return address (see EnterFinallyBlock).
   __ SmiUntag(x10);
   __ Add(x11, x10, Operand(masm_->CodeObject()));
   __ Br(x11);
 }
@@ skipping 123 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64