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

src/a64/ic-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 123 matching lines @@
                                                    scratch1,
                                                    scratch2);
 
   // If probing finds an entry check that the value is a normal property.
   __ Bind(&done);
 
   static const int kElementsStartOffset = NameDictionary::kHeaderSize +
       NameDictionary::kElementsStartIndex * kPointerSize;
   static const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;
   __ Ldr(scratch1, FieldMemOperand(scratch2, kDetailsOffset));
-  __ Tst(scratch1, Operand(Smi::FromInt(PropertyDetails::TypeField::kMask)));
+  __ Tst(scratch1, Smi::FromInt(PropertyDetails::TypeField::kMask));
   __ B(ne, miss);
 
   // Get the value at the masked, scaled index and return.
   __ Ldr(result,
          FieldMemOperand(scratch2, kElementsStartOffset + 1 * kPointerSize));
 }
 
 
 // Helper function used from StoreIC::GenerateNormal.
 //
@@ skipping 214 matching lines @@
   __ Tbnz(key, kXSignBit, slow_case);
 
   // Load the elements object and check its map.
   Handle<Map> arguments_map(heap->sloppy_arguments_elements_map());
   __ Ldr(map, FieldMemOperand(object, JSObject::kElementsOffset));
   __ CheckMap(map, scratch1, arguments_map, slow_case, DONT_DO_SMI_CHECK);
 
   // Check if element is in the range of mapped arguments. If not, jump
   // to the unmapped lookup.
   __ Ldr(scratch1, FieldMemOperand(map, FixedArray::kLengthOffset));
-  __ Sub(scratch1, scratch1, Operand(Smi::FromInt(2)));
+  __ Sub(scratch1, scratch1, Smi::FromInt(2));
   __ Cmp(key, scratch1);
   __ B(hs, unmapped_case);
 
   // Load element index and check whether it is the hole.
   static const int offset =
       FixedArray::kHeaderSize + 2 * kPointerSize - kHeapObjectTag;
 
   __ Add(scratch1, map, offset);
   __ SmiUntag(scratch2, key);
   __ Ldr(scratch1, MemOperand(scratch1, scratch2, LSL, kPointerSizeLog2));
@@ skipping 305 matching lines @@
   __ And(scratch2, scratch2, mask);
 
   // Load the key (consisting of map and unique name) from the cache and
   // check for match.
   Label load_in_object_property;
   static const int kEntriesPerBucket = KeyedLookupCache::kEntriesPerBucket;
   Label hit_on_nth_entry[kEntriesPerBucket];
   ExternalReference cache_keys =
       ExternalReference::keyed_lookup_cache_keys(isolate);
 
-  __ Mov(scratch3, Operand(cache_keys));
+  __ Mov(scratch3, cache_keys);
   __ Add(scratch3, scratch3, Operand(scratch2, LSL, kPointerSizeLog2 + 1));
 
   for (int i = 0; i < kEntriesPerBucket - 1; i++) {
     Label try_next_entry;
     // Load map and make scratch3 pointing to the next entry.
     __ Ldr(scratch4, MemOperand(scratch3, kPointerSize * 2, PostIndex));
     __ Cmp(receiver_map, scratch4);
     __ B(ne, &try_next_entry);
     __ Ldr(scratch4, MemOperand(scratch3, -kPointerSize));  // Load name
     __ Cmp(key, scratch4);
     __ B(eq, &hit_on_nth_entry[i]);
     __ Bind(&try_next_entry);
   }
 
   // Last entry.
   __ Ldr(scratch4, MemOperand(scratch3, kPointerSize, PostIndex));
   __ Cmp(receiver_map, scratch4);
   __ B(ne, slow);
   __ Ldr(scratch4, MemOperand(scratch3));
   __ Cmp(key, scratch4);
   __ B(ne, slow);
 
   // Get field offset.
   ExternalReference cache_field_offsets =
       ExternalReference::keyed_lookup_cache_field_offsets(isolate);
 
   // Hit on nth entry.
   for (int i = kEntriesPerBucket - 1; i >= 0; i--) {
     __ Bind(&hit_on_nth_entry[i]);
-    __ Mov(scratch3, Operand(cache_field_offsets));
+    __ Mov(scratch3, cache_field_offsets);
     if (i != 0) {
       __ Add(scratch2, scratch2, i);
     }
     __ Ldr(scratch4.W(), MemOperand(scratch3, scratch2, LSL, 2));
     __ Ldrb(scratch5,
             FieldMemOperand(receiver_map, Map::kInObjectPropertiesOffset));
     __ Subs(scratch4, scratch4, scratch5);
     __ B(ge, &property_array_property);
     if (i != 0) {
       __ B(&load_in_object_property);
@@ skipping 186 matching lines @@
   //  -- x1     : key
   //  -- x2     : receiver
   //  -- lr     : return address
   // -----------------------------------
 
   // Push receiver, key and value for runtime call.
   __ Push(x2, x1, x0);
 
   // Push PropertyAttributes(NONE) and strict_mode for runtime call.
   STATIC_ASSERT(NONE == 0);
-  __ Mov(x10, Operand(Smi::FromInt(strict_mode)));
+  __ Mov(x10, Smi::FromInt(strict_mode));
   __ Push(xzr, x10);
 
   __ TailCallRuntime(Runtime::kSetProperty, 5, 1);
 }
 
 
 static void KeyedStoreGenerateGenericHelper(
     MacroAssembler* masm,
     Label* fast_object,
     Label* fast_double,
@@ skipping 36 matching lines @@
 
   // Smi stores don't require further checks.
   __ JumpIfSmi(value, &finish_store);
 
   // Escape to elements kind transition case.
   __ CheckFastObjectElements(receiver_map, x10, &transition_smi_elements);
 
   __ Bind(&finish_store);
   if (increment_length == kIncrementLength) {
     // Add 1 to receiver->length.
-    __ Add(x10, key, Operand(Smi::FromInt(1)));
+    __ Add(x10, key, Smi::FromInt(1));
     __ Str(x10, FieldMemOperand(receiver, JSArray::kLengthOffset));
   }
 
   Register address = x11;
   __ Add(address, elements, FixedArray::kHeaderSize - kHeapObjectTag);
   __ Add(address, address, Operand::UntagSmiAndScale(key, kPointerSizeLog2));
   __ Str(value, MemOperand(address));
 
   Label dont_record_write;
   __ JumpIfSmi(value, &dont_record_write);
@@ skipping 31 matching lines @@
   __ Bind(&fast_double_without_map_check);
   __ StoreNumberToDoubleElements(value,
                                  key,
                                  elements,
                                  x10,
                                  d0,
                                  d1,
                                  &transition_double_elements);
   if (increment_length == kIncrementLength) {
     // Add 1 to receiver->length.
-    __ Add(x10, key, Operand(Smi::FromInt(1)));
+    __ Add(x10, key, Smi::FromInt(1));
     __ Str(x10, FieldMemOperand(receiver, JSArray::kLengthOffset));
   }
   __ Ret();
 
 
   __ Bind(&transition_smi_elements);
   // Transition the array appropriately depending on the value type.
   __ Ldr(x10, FieldMemOperand(value, HeapObject::kMapOffset));
   __ JumpIfNotRoot(x10, Heap::kHeapNumberMapRootIndex, &non_double_value);
 
@@ skipping 216 matching lines @@
   ASM_LOCATION("StoreIC::GenerateRuntimeSetProperty");
   // ----------- S t a t e -------------
   //  -- x0    : value
   //  -- x1    : receiver
   //  -- x2    : name
   //  -- lr    : return address
   // -----------------------------------
 
   __ Push(x1, x2, x0);
 
-  __ Mov(x11, Operand(Smi::FromInt(NONE)));  // PropertyAttributes
-  __ Mov(x10, Operand(Smi::FromInt(strict_mode)));
+  __ Mov(x11, Smi::FromInt(NONE));  // PropertyAttributes
+  __ Mov(x10, Smi::FromInt(strict_mode));
   __ Push(x11, x10);
 
   // Do tail-call to runtime routine.
   __ TailCallRuntime(Runtime::kSetProperty, 5, 1);
 }
 
 
 void StoreIC::GenerateSlow(MacroAssembler* masm) {
   // ---------- S t a t e --------------
   //  -- x0     : value
@@ skipping 98 matching lines @@
     ASSERT(to_patch->Mask(TestBranchMask) == TBNZ);
     // This is JumpIfSmi(smi_reg, branch_imm).
     patcher.tbz(smi_reg, 0, branch_imm);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64