A64: Synchronize with r15545.

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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
-#if defined(V8_TARGET_ARCH_A64)
+#if V8_TARGET_ARCH_A64
 
+#include "cpu-profiler.h"
 #include "unicode.h"
 #include "log.h"
 #include "code-stubs.h"
 #include "regexp-stack.h"
 #include "macro-assembler.h"
 #include "regexp-macro-assembler.h"
 #include "a64/regexp-macro-assembler-a64.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 106 matching lines @@
       exit_label_() {
   __ SetStackPointer(csp);
   ASSERT_EQ(0, registers_to_save % 2);
   // We can cache at most 16 W registers in x0-x7.
   STATIC_ASSERT(kNumCachedRegisters <= 16);
   STATIC_ASSERT((kNumCachedRegisters % 2) == 0);
   __ B(&entry_label_);   // We'll write the entry code later.
   __ Bind(&start_label_);  // And then continue from here.
 }
 
+
 RegExpMacroAssemblerA64::~RegExpMacroAssemblerA64() {
   delete masm_;
   // Unuse labels in case we throw away the assembler without calling GetCode.
   entry_label_.Unuse();
   start_label_.Unuse();
   success_label_.Unuse();
   backtrack_label_.Unuse();
   exit_label_.Unuse();
   check_preempt_label_.Unuse();
   stack_overflow_label_.Unuse();
 }
 
 int RegExpMacroAssemblerA64::stack_limit_slack()  {
   return RegExpStack::kStackLimitSlack;
 }
 
+
 void RegExpMacroAssemblerA64::AdvanceCurrentPosition(int by) {
   if (by != 0) {
     __ Add(current_input_offset(),
            current_input_offset(), by * char_size());
   }
 }
 
+
 void RegExpMacroAssemblerA64::AdvanceRegister(int reg, int by) {
   ASSERT((reg >= 0) && (reg < num_registers_));
   if (by != 0) {
     Register to_advance;
     RegisterState register_state = GetRegisterState(reg);
     switch (register_state) {
       case STACKED:
         __ Ldr(w10, register_location(reg));
         __ Add(w10, w10, by);
         __ Str(w10, register_location(reg));
         break;
       case CACHED_LSW:
         to_advance = GetCachedRegister(reg);
         __ Add(to_advance, to_advance, by);
         break;
       case CACHED_MSW:
         to_advance = GetCachedRegister(reg);
         __ Add(to_advance, to_advance, static_cast<int64_t>(by) << kWRegSize);
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
+
 void RegExpMacroAssemblerA64::Backtrack() {
   CheckPreemption();
   Pop(w10);
   __ Add(x10, code_pointer(), Operand(w10, UXTW));
   __ Br(x10);
 }
 
+
 void RegExpMacroAssemblerA64::Bind(Label* label) {
   __ Bind(label);
 }
 
 
 void RegExpMacroAssemblerA64::CheckCharacter(uint32_t c, Label* on_equal) {
   CompareAndBranchOrBacktrack(current_character(), c, eq, on_equal);
 }
 
 
@@ skipping 888 matching lines @@
 void RegExpMacroAssemblerA64::PopCurrentPosition() {
   Pop(current_input_offset());
 }
 
 
 void RegExpMacroAssemblerA64::PopRegister(int register_index) {
   Pop(w10);
   StoreRegister(register_index, w10);
 }
 
+
 void RegExpMacroAssemblerA64::PushBacktrack(Label* label) {
   if (label->is_bound()) {
     int target = label->pos();
     __ Mov(w10, target + Code::kHeaderSize - kHeapObjectTag);
   } else {
     __ Adr(x10, label);
     __ Sub(x10, x10, code_pointer());
     if (masm_->emit_debug_code()) {
       __ Cmp(x10, kWRegMask);
       __ Check(ls, "The code offset needs to fit in a W register.");
@@ skipping 151 matching lines @@
 void RegExpMacroAssemblerA64::WriteStackPointerToRegister(int reg) {
   __ Ldr(x10, MemOperand(frame_pointer(), kStackBase));
   __ Sub(x10, backtrack_stackpointer(), x10);
   if (masm_->emit_debug_code()) {
     __ Cmp(x10, Operand(w10, SXTW));
     __ Check(eq, "Offset from the stack base needs to fit in a W register.");
   }
   StoreRegister(reg, w10);
 }
 
+
 // Helper function for reading a value out of a stack frame.
 template <typename T>
 static T& frame_entry(Address re_frame, int frame_offset) {
   return *reinterpret_cast<T*>(re_frame + frame_offset);
 }
 
+
 int RegExpMacroAssemblerA64::CheckStackGuardState(Address* return_address,
                                                   Code* re_code,
                                                   Address re_frame,
                                                   int start_offset,
                                                   const byte** input_start,
                                                   const byte** input_end) {
   Isolate* isolate = frame_entry<Isolate*>(re_frame, kIsolate);
   ASSERT(isolate == Isolate::Current());
   if (isolate->stack_guard()->IsStackOverflow()) {
     isolate->StackOverflow();
@@ skipping 80 matching lines @@
   } else if (frame_entry<const String*>(re_frame, kInput) != *subject) {
     // Subject string might have been a ConsString that underwent
     // short-circuiting during GC. That will not change start_address but
     // will change pointer inside the subject handle.
     frame_entry<const String*>(re_frame, kInput) = *subject;
   }
 
   return 0;
 }
 
+
 void RegExpMacroAssemblerA64::CheckPosition(int cp_offset,
                                             Label* on_outside_input) {
   CompareAndBranchOrBacktrack(current_input_offset(),
                               -cp_offset * char_size(),
                               ge,
                               on_outside_input);
 }
 
+
 bool RegExpMacroAssemblerA64::CanReadUnaligned() {
   // TODO(pielan): See whether or not we should disable unaligned accesses.
   return !slow_safe();
 }
 
+
 // Private methods:
 
 void RegExpMacroAssemblerA64::CallCheckStackGuardState(Register scratch) {
   // Allocate space on the stack to store the return address. The
   // CheckStackGuardState C++ function will override it if the code
   // moved. Allocate extra space for 2 arguments passed by pointers.
   // AAPCS64 requires the stack to be 16 byte aligned.
   int alignment = masm_->ActivationFrameAlignment();
   ASSERT_EQ(alignment % 16, 0);
   int align_mask = (alignment / kXRegSizeInBytes) - 1;
@@ skipping 85 matching lines @@
   // Check for preemption.
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
   __ Mov(x10, Operand(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));
   __ 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,
          MemOperand(backtrack_stackpointer(),
                     -static_cast<int>(kWRegSizeInBytes),
                     PreIndex));
 }
 
+
 void RegExpMacroAssemblerA64::Pop(Register target) {
   ASSERT(target.Is32Bits());
   ASSERT(!target.is(backtrack_stackpointer()));
   __ Ldr(target,
          MemOperand(backtrack_stackpointer(), kWRegSizeInBytes, PostIndex));
 }
 
 
 Register RegExpMacroAssemblerA64::GetCachedRegister(int register_index) {
   ASSERT(register_index < kNumCachedRegisters);
@@ skipping 159 matching lines @@
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64