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

src/a64/lithium-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 783 matching lines @@
               code->instr()->Mnemonic());
 
       __ Bind(code->entry());
 
       if (NeedsDeferredFrame()) {
         Comment(";;; Build frame");
         ASSERT(!frame_is_built_);
         ASSERT(info()->IsStub());
         frame_is_built_ = true;
         __ Push(lr, fp, cp);
-        __ Mov(fp, Operand(Smi::FromInt(StackFrame::STUB)));
+        __ Mov(fp, Smi::FromInt(StackFrame::STUB));
         __ Push(fp);
         __ Add(fp, __ StackPointer(),
                StandardFrameConstants::kFixedFrameSizeFromFp);
         Comment(";;; Deferred code");
       }
 
       code->Generate();
 
       if (NeedsDeferredFrame()) {
         Comment(";;; Destroy frame");
@@ skipping 33 matching lines @@
     } else {
       Comment(";;; jump table entry %d: deoptimization bailout %d.", i, id);
     }
     if (deopt_jump_table_[i]->needs_frame) {
       ASSERT(!info()->saves_caller_doubles());
 
       UseScratchRegisterScope temps(masm());
       Register stub_deopt_entry = temps.AcquireX();
       Register stub_marker = temps.AcquireX();
 
-      __ Mov(stub_deopt_entry,
-             Operand(ExternalReference::ForDeoptEntry(entry)));
+      __ Mov(stub_deopt_entry, ExternalReference::ForDeoptEntry(entry));
       if (needs_frame.is_bound()) {
         __ B(&needs_frame);
       } else {
         __ Bind(&needs_frame);
         // This variant of deopt can only be used with stubs. Since we don't
         // have a function pointer to install in the stack frame that we're
         // building, install a special marker there instead.
         ASSERT(info()->IsStub());
-        __ Mov(stub_marker, Operand(Smi::FromInt(StackFrame::STUB)));
+        __ Mov(stub_marker, Smi::FromInt(StackFrame::STUB));
         __ Push(lr, fp, cp, stub_marker);
         __ Add(fp, __ StackPointer(), 2 * kPointerSize);
         __ Call(stub_deopt_entry);
       }
     } else {
       if (info()->saves_caller_doubles()) {
         ASSERT(info()->IsStub());
         RestoreCallerDoubles();
       }
       __ Call(entry, RelocInfo::RUNTIME_ENTRY);
@@ skipping 119 matching lines @@
   if (entry == NULL) {
     Abort(kBailoutWasNotPrepared);
   }
 
   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
     Label not_zero;
     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
 
     __ Push(x0, x1, x2);
     __ Mrs(x2, NZCV);
-    __ Mov(x0, Operand(count));
+    __ Mov(x0, count);
     __ Ldr(w1, MemOperand(x0));
     __ Subs(x1, x1, 1);
     __ B(gt, &not_zero);
     __ Mov(w1, FLAG_deopt_every_n_times);
     __ Str(w1, MemOperand(x0));
     __ Pop(x2, x1, x0);
     ASSERT(frame_is_built_);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     __ Unreachable();
 
@@ skipping 526 matching lines @@
   } else {
     ASSERT(instr->temp3() == NULL);
   }
 }
 
 
 void LCodeGen::DoDeferredAllocate(LAllocate* instr) {
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
-  __ Mov(ToRegister(instr->result()), Operand(Smi::FromInt(0)));
+  __ Mov(ToRegister(instr->result()), Smi::FromInt(0));
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
   // We're in a SafepointRegistersScope so we can use any scratch registers.
   Register size = x0;
   if (instr->size()->IsConstantOperand()) {
-    __ Mov(size, Operand(ToSmi(LConstantOperand::cast(instr->size()))));
+    __ Mov(size, ToSmi(LConstantOperand::cast(instr->size())));
   } else {
     __ SmiTag(size, ToRegister32(instr->size()).X());
   }
   int flags = AllocateDoubleAlignFlag::encode(
       instr->hydrogen()->MustAllocateDoubleAligned());
   if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
     ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     flags = AllocateTargetSpace::update(flags, OLD_POINTER_SPACE);
   } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     flags = AllocateTargetSpace::update(flags, OLD_DATA_SPACE);
   } else {
     flags = AllocateTargetSpace::update(flags, NEW_SPACE);
   }
-  __ Mov(x10, Operand(Smi::FromInt(flags)));
+  __ Mov(x10, Smi::FromInt(flags));
   __ Push(size, x10);
 
   CallRuntimeFromDeferred(
       Runtime::kAllocateInTargetSpace, 2, instr, instr->context());
   __ StoreToSafepointRegisterSlot(x0, ToRegister(instr->result()));
 }
 
 
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   Register receiver = ToRegister(instr->receiver());
@@ skipping 59 matching lines @@
     ASSERT(masm()->StackPointer().Is(jssp));
     __ Sub(result, jssp, 2 * kPointerSize);
   } else {
     ASSERT(instr->temp() != NULL);
     Register previous_fp = ToRegister(instr->temp());
 
     __ Ldr(previous_fp,
            MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
     __ Ldr(result,
            MemOperand(previous_fp, StandardFrameConstants::kContextOffset));
-    __ Cmp(result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+    __ Cmp(result, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
     __ Csel(result, fp, previous_fp, ne);
   }
 }
 
 
 void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
   Register elements = ToRegister(instr->elements());
   Register result = ToRegister32(instr->result());
   Label done;
 
@@ skipping 104 matching lines @@
   if (instr->hydrogen()->skip_check()) return;
 
   ASSERT(instr->hydrogen()->length()->representation().IsInteger32());
   Register length = ToRegister32(instr->length());
 
   if (instr->index()->IsConstantOperand()) {
     int constant_index =
         ToInteger32(LConstantOperand::cast(instr->index()));
 
     if (instr->hydrogen()->length()->representation().IsSmi()) {
-      __ Cmp(length, Operand(Smi::FromInt(constant_index)));
+      __ Cmp(length, Smi::FromInt(constant_index));
     } else {
-      __ Cmp(length, Operand(constant_index));
+      __ Cmp(length, constant_index);
     }
   } else {
   ASSERT(instr->hydrogen()->index()->representation().IsInteger32());
     __ Cmp(length, ToRegister32(instr->index()));
   }
   Condition condition = instr->hydrogen()->allow_equality() ? lo : ls;
   ApplyCheckIf(condition, instr);
 }
 
 
@@ skipping 17 matching lines @@
     ASSERT(r.IsTagged());
     Register value = ToRegister(instr->value());
     HType type = instr->hydrogen()->value()->type();
 
     if (type.IsBoolean()) {
       ASSERT(!info()->IsStub());
       __ CompareRoot(value, Heap::kTrueValueRootIndex);
       EmitBranch(instr, eq);
     } else if (type.IsSmi()) {
       ASSERT(!info()->IsStub());
-      EmitCompareAndBranch(instr, ne, value, Operand(Smi::FromInt(0)));
+      EmitCompareAndBranch(instr, ne, value, Smi::FromInt(0));
     } else if (type.IsJSArray()) {
       ASSERT(!info()->IsStub());
       EmitGoto(instr->TrueDestination(chunk()));
     } else if (type.IsHeapNumber()) {
       ASSERT(!info()->IsStub());
       __ Ldr(double_scratch(), FieldMemOperand(value,
                                                HeapNumber::kValueOffset));
       // Test the double value. Zero and NaN are false.
       EmitBranchIfNonZeroNumber(instr, double_scratch(), double_scratch());
     } else if (type.IsString()) {
@@ skipping 1189 matching lines @@
   {
     // Below we use Factory::the_hole_value() on purpose instead of loading from
     // the root array to force relocation and later be able to patch with a
     // custom value.
     InstructionAccurateScope scope(masm(), 5);
     __ bind(&map_check);
     // Will be patched with the cached map.
     Handle<Cell> cell = factory()->NewCell(factory()->the_hole_value());
     __ LoadRelocated(scratch, Operand(Handle<Object>(cell)));
     __ ldr(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
-    __ cmp(map, Operand(scratch));
+    __ cmp(map, scratch);
     __ b(&cache_miss, ne);
     // The address of this instruction is computed relative to the map check
     // above, so check the size of the code generated.
     ASSERT(masm()->InstructionsGeneratedSince(&map_check) == 4);
     // Will be patched with the cached result.
     __ LoadRelocated(result, Operand(factory()->the_hole_value()));
   }
   __ B(&done);
 
   // The inlined call site cache did not match.
@@ skipping 91 matching lines @@
 void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
 
   // Get the frame pointer for the calling frame.
   __ Ldr(temp1, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
 
   // Skip the arguments adaptor frame if it exists.
   Label check_frame_marker;
   __ Ldr(temp2, MemOperand(temp1, StandardFrameConstants::kContextOffset));
-  __ Cmp(temp2, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+  __ Cmp(temp2, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   __ B(ne, &check_frame_marker);
   __ Ldr(temp1, MemOperand(temp1, StandardFrameConstants::kCallerFPOffset));
 
   // Check the marker in the calling frame.
   __ Bind(&check_frame_marker);
   __ Ldr(temp1, MemOperand(temp1, StandardFrameConstants::kMarkerOffset));
 
   EmitCompareAndBranch(
       instr, eq, temp1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
 }
@@ skipping 973 matching lines @@
   // indicate that positive dividends are heavily favored, so the branching
   // version performs better.
   HMod* hmod = instr->hydrogen();
   int32_t mask = divisor < 0 ? -(divisor + 1) : (divisor - 1);
   Label dividend_is_not_negative, done;
   if (hmod->CheckFlag(HValue::kLeftCanBeNegative)) {
     __ Cmp(dividend, 0);
     __ B(pl, &dividend_is_not_negative);
     // Note that this is correct even for kMinInt operands.
     __ Neg(dividend, dividend);
-    __ And(dividend, dividend, Operand(mask));
+    __ And(dividend, dividend, mask);
     __ Negs(dividend, dividend);
     if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
       DeoptimizeIf(eq, instr->environment());
     }
     __ B(&done);
   }
 
   __ bind(&dividend_is_not_negative);
-  __ And(dividend, dividend, Operand(mask));
+  __ And(dividend, dividend, mask);
   __ bind(&done);
 }
 
 
 void LCodeGen::DoModByConstI(LModByConstI* instr) {
   Register dividend = ToRegister32(instr->dividend());
   int32_t divisor = instr->divisor();
   Register result = ToRegister32(instr->result());
   Register temp = ToRegister32(instr->temp());
   ASSERT(!AreAliased(dividend, result, temp));
@@ skipping 709 matching lines @@
 void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
   Register scratch1 = x5;
   Register scratch2 = x6;
   ASSERT(instr->IsMarkedAsCall());
 
   ASM_UNIMPLEMENTED_BREAK("DoDeclareGlobals");
   // TODO(all): if Mov could handle object in new space then it could be used
   // here.
   __ LoadHeapObject(scratch1, instr->hydrogen()->pairs());
-  __ Mov(scratch2, Operand(Smi::FromInt(instr->hydrogen()->flags())));
+  __ Mov(scratch2, Smi::FromInt(instr->hydrogen()->flags()));
   __ Push(cp, scratch1, scratch2);  // The context is the first argument.
   CallRuntime(Runtime::kDeclareGlobals, 3, instr);
 }
 
 
 void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
   LoadContextFromDeferred(instr->context());
   __ CallRuntimeSaveDoubles(Runtime::kStackGuard);
   RecordSafepointWithLazyDeopt(
@@ skipping 692 matching lines @@
   __ Mov(x1, x0);
 
   __ Bind(&materialized);
   int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
   Label allocated, runtime_allocate;
 
   __ Allocate(size, x0, x10, x11, &runtime_allocate, TAG_OBJECT);
   __ B(&allocated);
 
   __ Bind(&runtime_allocate);
-  __ Mov(x0, Operand(Smi::FromInt(size)));
+  __ Mov(x0, Smi::FromInt(size));
   __ Push(x1, x0);
   CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
   __ Pop(x1);
 
   __ Bind(&allocated);
   // Copy the content into the newly allocated memory.
   __ CopyFields(x0, x1, CPURegList(x10, x11, x12), size / kPointerSize);
 }
 
 
@@ skipping 213 matching lines @@
 
 
 void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
   Register object = ToRegister(instr->object());
   Register index = ToRegister(instr->index());
   Register result = ToRegister(instr->result());
 
   __ AssertSmi(index);
 
   Label out_of_object, done;
-  __ Cmp(index, Operand(Smi::FromInt(0)));
+  __ Cmp(index, Smi::FromInt(0));
   __ B(lt, &out_of_object);
 
   STATIC_ASSERT(kPointerSizeLog2 > kSmiTagSize);
   __ Add(result, object, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result, JSObject::kHeaderSize));
 
   __ B(&done);
 
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal