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

src/a64/stub-cache-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 107 matching lines @@
   uintptr_t map_off_addr = reinterpret_cast<uintptr_t>(map_offset.address());
 
   Label miss;
 
   ASSERT(!AreAliased(name, offset, scratch, scratch2, scratch3));
 
   // Multiply by 3 because there are 3 fields per entry.
   __ Add(scratch3, offset, Operand(offset, LSL, 1));
 
   // Calculate the base address of the entry.
-  __ Mov(scratch, Operand(key_offset));
+  __ Mov(scratch, key_offset);
   __ Add(scratch, scratch, Operand(scratch3, LSL, kPointerSizeLog2));
 
   // Check that the key in the entry matches the name.
   __ Ldr(scratch2, MemOperand(scratch));
   __ Cmp(name, scratch2);
   __ B(ne, &miss);
 
   // Check the map matches.
   __ Ldr(scratch2, MemOperand(scratch, map_off_addr - key_off_addr));
   __ Ldr(scratch3, FieldMemOperand(receiver, HeapObject::kMapOffset));
@@ skipping 615 matching lines @@
   } else {
     __ LoadObject(call_data, call_data_obj);
   }
 
   // Put api_function_address in place.
   Address function_address = v8::ToCData<Address>(api_call_info->callback());
   ApiFunction fun(function_address);
   ExternalReference ref = ExternalReference(&fun,
                                             ExternalReference::DIRECT_API_CALL,
                                             masm->isolate());
-  __ Mov(api_function_address, Operand(ref));
+  __ Mov(api_function_address, ref);
 
   // Jump to stub.
   CallApiFunctionStub stub(is_store, call_data_undefined, argc);
   __ TailCallStub(&stub);
 }
 
 
 void StubCompiler::GenerateTailCall(MacroAssembler* masm, Handle<Code> code) {
   __ Jump(code, RelocInfo::CODE_TARGET);
 }
@@ skipping 240 matching lines @@
     __ Mov(scratch3(), Operand(callback));
     __ Ldr(scratch3(), FieldMemOperand(scratch3(),
                                        ExecutableAccessorInfo::kDataOffset));
   } else {
     __ Mov(scratch3(), Operand(Handle<Object>(callback->data(), isolate())));
   }
   // TODO(jbramley): Find another scratch register and combine the pushes
   // together. Can we use scratch1() here?
   __ LoadRoot(scratch4(), Heap::kUndefinedValueRootIndex);
   __ Push(scratch3(), scratch4());
-  __ Mov(scratch3(), Operand(ExternalReference::isolate_address(isolate())));
+  __ Mov(scratch3(), ExternalReference::isolate_address(isolate()));
   __ Push(scratch4(), scratch3(), reg, name());
 
   Register args_addr = scratch2();
   __ Add(args_addr, __ StackPointer(), kPointerSize);
 
   // Stack at this point:
   //              sp[40] callback data
   //              sp[32] undefined
   //              sp[24] undefined
   //              sp[16] isolate
   // args_addr -> sp[8]  reg
   //              sp[0]  name
 
   // Abi for CallApiGetter.
   Register getter_address_reg = x2;
 
   // Set up the call.
   Address getter_address = v8::ToCData<Address>(callback->getter());
   ApiFunction fun(getter_address);
   ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL;
   ExternalReference ref = ExternalReference(&fun, type, isolate());
-  __ Mov(getter_address_reg, Operand(ref));
+  __ Mov(getter_address_reg, ref);
 
   CallApiGetterStub stub;
   __ TailCallStub(&stub);
 }
 
 
 void LoadStubCompiler::GenerateLoadInterceptor(
     Register holder_reg,
     Handle<Object> object,
     Handle<JSObject> interceptor_holder,
@@ skipping 441 matching lines @@
 
   // Miss case, call the runtime.
   __ Bind(&miss);
   TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Miss);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64