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

src/a64/regexp-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 390 matching lines @@
     //   w2: size_t byte_length - length of capture in bytes(!)
     //   x3: Isolate* isolate
 
     // Address of start of capture.
     __ Add(x0, input_end(), Operand(capture_start_offset, SXTW));
     // Length of capture.
     __ Mov(w2, capture_length);
     // Address of current input position.
     __ Add(x1, input_end(), Operand(current_input_offset(), SXTW));
     // Isolate.
-    __ Mov(x3, Operand(ExternalReference::isolate_address(isolate())));
+    __ Mov(x3, ExternalReference::isolate_address(isolate()));
 
     {
       AllowExternalCallThatCantCauseGC scope(masm_);
       ExternalReference function =
           ExternalReference::re_case_insensitive_compare_uc16(isolate());
       __ CallCFunction(function, argument_count);
     }
 
     // Check if function returned non-zero for success or zero for failure.
     CompareAndBranchOrBacktrack(x0, 0, eq, on_no_match);
@@ skipping 205 matching lines @@
       BranchOrBacktrack(ne, on_no_match);
     }
     return true;
   }
   case 'w': {
     if (mode_ != ASCII) {
       // Table is 128 entries, so all ASCII characters can be tested.
       CompareAndBranchOrBacktrack(current_character(), 'z', hi, on_no_match);
     }
     ExternalReference map = ExternalReference::re_word_character_map();
-    __ Mov(x10, Operand(map));
+    __ Mov(x10, map);
     __ Ldrb(w10, MemOperand(x10, current_character(), UXTW));
     CompareAndBranchOrBacktrack(w10, 0, eq, on_no_match);
     return true;
   }
   case 'W': {
     Label done;
     if (mode_ != ASCII) {
       // Table is 128 entries, so all ASCII characters can be tested.
       __ Cmp(current_character(), 'z');
       __ B(hi, &done);
     }
     ExternalReference map = ExternalReference::re_word_character_map();
-    __ Mov(x10, Operand(map));
+    __ Mov(x10, map);
     __ Ldrb(w10, MemOperand(x10, current_character(), UXTW));
     CompareAndBranchOrBacktrack(w10, 0, ne, on_no_match);
     __ Bind(&done);
     return true;
   }
   case '*':
     // Match any character.
     return true;
   // No custom implementation (yet): s(UC16), S(UC16).
   default:
@@ skipping 68 matching lines @@
   ASSERT_EQ(alignment % 16, 0);
   int align_mask = (alignment / kWRegSize) - 1;
   num_wreg_to_allocate = (num_wreg_to_allocate + align_mask) & ~align_mask;
 
   // Check if we have space on the stack.
   Label stack_limit_hit;
   Label stack_ok;
 
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
-  __ Mov(x10, Operand(stack_limit));
+  __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
   __ Subs(x10, csp, x10);
 
   // Handle it if the stack pointer is already below the stack limit.
   __ B(ls, &stack_limit_hit);
 
   // Check if there is room for the variable number of registers above
   // the stack limit.
   __ Cmp(x10, num_wreg_to_allocate * kWRegSize);
   __ B(hs, &stack_ok);
@@ skipping 274 matching lines @@
     RestoreLinkRegister();
     __ Ret();
   }
 
   if (stack_overflow_label_.is_linked()) {
     __ Bind(&stack_overflow_label_);
     SaveLinkRegister();
     // The cached registers need to be retained.
     __ PushCPURegList(cached_registers);
     // Call GrowStack(backtrack_stackpointer(), &stack_base)
-    __ Mov(x2, Operand(ExternalReference::isolate_address(isolate())));
+    __ Mov(x2, ExternalReference::isolate_address(isolate()));
     __ Add(x1, frame_pointer(), kStackBase);
     __ Mov(x0, backtrack_stackpointer());
     ExternalReference grow_stack =
         ExternalReference::re_grow_stack(isolate());
     __ CallCFunction(grow_stack, 3);
     // If return NULL, we have failed to grow the stack, and
     // must exit with a stack-overflow exception.
     // Returning from the regexp code restores the stack (csp <- fp)
     // so we don't need to drop the link register from it before exiting.
     __ Cbz(w0, &exit_with_exception);
@@ skipping 403 matching lines @@
   // Code* of self.
   __ Mov(x1, Operand(masm_->CodeObject()));
 
   // We need to pass a pointer to the return address as first argument.
   // The DirectCEntry stub will place the return address on the stack before
   // calling so the stack pointer will point to it.
   __ Mov(x0, csp);
 
   ExternalReference check_stack_guard_state =
       ExternalReference::re_check_stack_guard_state(isolate());
-  __ Mov(scratch, Operand(check_stack_guard_state));
+  __ Mov(scratch, check_stack_guard_state);
   DirectCEntryStub stub;
   stub.GenerateCall(masm_, scratch);
 
   // The input string may have been moved in memory, we need to reload it.
   __ Peek(input_start(), kPointerSize);
   __ Peek(input_end(), 2 * kPointerSize);
 
   ASSERT(csp.Is(__ StackPointer()));
   __ Drop(xreg_to_claim);
 
@@ skipping 43 matching lines @@
     __ Cmp(reg, immediate);
     BranchOrBacktrack(condition, to);
   }
 }
 
 
 void RegExpMacroAssemblerA64::CheckPreemption() {
   // Check for preemption.
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
-  __ Mov(x10, Operand(stack_limit));
+  __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
   ASSERT(csp.Is(__ StackPointer()));
   __ Cmp(csp, x10);
   CallIf(&check_preempt_label_, ls);
 }
 
 
 void RegExpMacroAssemblerA64::CheckStackLimit() {
   ExternalReference stack_limit =
       ExternalReference::address_of_regexp_stack_limit(isolate());
-  __ Mov(x10, Operand(stack_limit));
+  __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
   __ Cmp(backtrack_stackpointer(), x10);
   CallIf(&stack_overflow_label_, ls);
 }
 
 
 void RegExpMacroAssemblerA64::Push(Register source) {
   ASSERT(source.Is32Bits());
   ASSERT(!source.is(backtrack_stackpointer()));
   __ Str(source,
@@ skipping 177 matching lines @@
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64