Rename A64 port to ARM64 port

src/arm64/regexp-macro-assembler-arm64.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 V8_TARGET_ARCH_A64
+#if V8_TARGET_ARCH_ARM64
 
 #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"
+#include "arm64/regexp-macro-assembler-arm64.h"
 
 namespace v8 {
 namespace internal {
 
 #ifndef V8_INTERPRETED_REGEXP
 /*
  * This assembler uses the following register assignment convention:
  * - w19     : Used to temporarely store a value before a call to C code.
  *             See CheckNotBackReferenceIgnoreCase.
  * - x20     : Pointer to the current code object (Code*),
@@ skipping 67 matching lines @@
  *              Address input_start,
  *              Address input_end,
  *              int* output,
  *              int output_size,
  *              Address stack_base,
  *              bool direct_call = false,
  *              Address secondary_return_address,  // Only used by native call.
  *              Isolate* isolate)
  * The call is performed by NativeRegExpMacroAssembler::Execute()
  * (in regexp-macro-assembler.cc) via the CALL_GENERATED_REGEXP_CODE macro
- * in a64/simulator-a64.h.
+ * in arm64/simulator-arm64.h.
  * When calling as a non-direct call (i.e., from C++ code), the return address
  * area is overwritten with the LR register by the RegExp code. When doing a
  * direct call from generated code, the return address is placed there by
  * the calling code, as in a normal exit frame.
  */
 
 #define __ ACCESS_MASM(masm_)
 
-RegExpMacroAssemblerA64::RegExpMacroAssemblerA64(
+RegExpMacroAssemblerARM64::RegExpMacroAssemblerARM64(
     Mode mode,
     int registers_to_save,
     Zone* zone)
     : NativeRegExpMacroAssembler(zone),
       masm_(new MacroAssembler(zone->isolate(), NULL, kRegExpCodeSize)),
       mode_(mode),
       num_registers_(registers_to_save),
       num_saved_registers_(registers_to_save),
       entry_label_(),
       start_label_(),
       success_label_(),
       backtrack_label_(),
       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() {
+RegExpMacroAssemblerARM64::~RegExpMacroAssemblerARM64() {
   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()  {
+int RegExpMacroAssemblerARM64::stack_limit_slack()  {
   return RegExpStack::kStackLimitSlack;
 }
 
 
-void RegExpMacroAssemblerA64::AdvanceCurrentPosition(int by) {
+void RegExpMacroAssemblerARM64::AdvanceCurrentPosition(int by) {
   if (by != 0) {
     __ Add(current_input_offset(),
            current_input_offset(), by * char_size());
   }
 }
 
 
-void RegExpMacroAssemblerA64::AdvanceRegister(int reg, int by) {
+void RegExpMacroAssemblerARM64::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) << kWRegSizeInBits);
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
-void RegExpMacroAssemblerA64::Backtrack() {
+void RegExpMacroAssemblerARM64::Backtrack() {
   CheckPreemption();
   Pop(w10);
   __ Add(x10, code_pointer(), Operand(w10, UXTW));
   __ Br(x10);
 }
 
 
-void RegExpMacroAssemblerA64::Bind(Label* label) {
+void RegExpMacroAssemblerARM64::Bind(Label* label) {
   __ Bind(label);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacter(uint32_t c, Label* on_equal) {
+void RegExpMacroAssemblerARM64::CheckCharacter(uint32_t c, Label* on_equal) {
   CompareAndBranchOrBacktrack(current_character(), c, eq, on_equal);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterGT(uc16 limit, Label* on_greater) {
+void RegExpMacroAssemblerARM64::CheckCharacterGT(uc16 limit,
+                                                 Label* on_greater) {
   CompareAndBranchOrBacktrack(current_character(), limit, hi, on_greater);
 }
 
 
-void RegExpMacroAssemblerA64::CheckAtStart(Label* on_at_start) {
+void RegExpMacroAssemblerARM64::CheckAtStart(Label* on_at_start) {
   Label not_at_start;
   // Did we start the match at the start of the input string?
   CompareAndBranchOrBacktrack(start_offset(), 0, ne, &not_at_start);
   // If we did, are we still at the start of the input string?
   __ Add(x10, input_end(), Operand(current_input_offset(), SXTW));
   __ Cmp(x10, input_start());
   BranchOrBacktrack(eq, on_at_start);
   __ Bind(&not_at_start);
 }
 
 
-void RegExpMacroAssemblerA64::CheckNotAtStart(Label* on_not_at_start) {
+void RegExpMacroAssemblerARM64::CheckNotAtStart(Label* on_not_at_start) {
   // Did we start the match at the start of the input string?
   CompareAndBranchOrBacktrack(start_offset(), 0, ne, on_not_at_start);
   // If we did, are we still at the start of the input string?
   __ Add(x10, input_end(), Operand(current_input_offset(), SXTW));
   __ Cmp(x10, input_start());
   BranchOrBacktrack(ne, on_not_at_start);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterLT(uc16 limit, Label* on_less) {
+void RegExpMacroAssemblerARM64::CheckCharacterLT(uc16 limit, Label* on_less) {
   CompareAndBranchOrBacktrack(current_character(), limit, lo, on_less);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacters(Vector<const uc16> str,
+void RegExpMacroAssemblerARM64::CheckCharacters(Vector<const uc16> str,
                                               int cp_offset,
                                               Label* on_failure,
                                               bool check_end_of_string) {
   // This method is only ever called from the cctests.
 
   if (check_end_of_string) {
     // Is last character of required match inside string.
     CheckPosition(cp_offset + str.length() - 1, on_failure);
   }
 
@@ skipping 11 matching lines @@
       __ Ldrb(w10, MemOperand(characters_address, 1, PostIndex));
       ASSERT(str[i] <= String::kMaxOneByteCharCode);
     } else {
       __ Ldrh(w10, MemOperand(characters_address, 2, PostIndex));
     }
     CompareAndBranchOrBacktrack(w10, str[i], ne, on_failure);
   }
 }
 
 
-void RegExpMacroAssemblerA64::CheckGreedyLoop(Label* on_equal) {
+void RegExpMacroAssemblerARM64::CheckGreedyLoop(Label* on_equal) {
   __ Ldr(w10, MemOperand(backtrack_stackpointer()));
   __ Cmp(current_input_offset(), w10);
   __ Cset(x11, eq);
   __ Add(backtrack_stackpointer(),
          backtrack_stackpointer(), Operand(x11, LSL, kWRegSizeLog2));
   BranchOrBacktrack(eq, on_equal);
 }
 
-void RegExpMacroAssemblerA64::CheckNotBackReferenceIgnoreCase(
+void RegExpMacroAssemblerARM64::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
 
   Register capture_start_offset = w10;
   // Save the capture length in a callee-saved register so it will
   // be preserved if we call a C helper.
   Register capture_length = w19;
   ASSERT(kCalleeSaved.IncludesAliasOf(capture_length));
 
@@ skipping 106 matching lines @@
     CompareAndBranchOrBacktrack(x0, 0, eq, on_no_match);
     // On success, increment position by length of capture.
     __ Add(current_input_offset(), current_input_offset(), capture_length);
     // Reset the cached registers.
     __ PopCPURegList(cached_registers);
   }
 
   __ Bind(&fallthrough);
 }
 
-void RegExpMacroAssemblerA64::CheckNotBackReference(
+void RegExpMacroAssemblerARM64::CheckNotBackReference(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
 
   Register capture_start_address = x12;
   Register capture_end_address = x13;
   Register current_position_address = x14;
   Register capture_length = w15;
 
   // Find length of back-referenced capture.
@@ skipping 41 matching lines @@
   if (masm_->emit_debug_code()) {
     __ Cmp(current_input_offset().X(), Operand(current_input_offset(), SXTW));
     __ Ccmp(current_input_offset(), 0, NoFlag, eq);
     // The current input offset should be <= 0, and fit in a W register.
     __ Check(le, kOffsetOutOfRange);
   }
   __ Bind(&fallthrough);
 }
 
 
-void RegExpMacroAssemblerA64::CheckNotCharacter(unsigned c,
-                                                Label* on_not_equal) {
+void RegExpMacroAssemblerARM64::CheckNotCharacter(unsigned c,
+                                                  Label* on_not_equal) {
   CompareAndBranchOrBacktrack(current_character(), c, ne, on_not_equal);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterAfterAnd(uint32_t c,
-                                                     uint32_t mask,
-                                                     Label* on_equal) {
+void RegExpMacroAssemblerARM64::CheckCharacterAfterAnd(uint32_t c,
+                                                       uint32_t mask,
+                                                       Label* on_equal) {
   __ And(w10, current_character(), mask);
   CompareAndBranchOrBacktrack(w10, c, eq, on_equal);
 }
 
 
-void RegExpMacroAssemblerA64::CheckNotCharacterAfterAnd(unsigned c,
-                                                        unsigned mask,
-                                                        Label* on_not_equal) {
+void RegExpMacroAssemblerARM64::CheckNotCharacterAfterAnd(unsigned c,
+                                                          unsigned mask,
+                                                          Label* on_not_equal) {
   __ And(w10, current_character(), mask);
   CompareAndBranchOrBacktrack(w10, c, ne, on_not_equal);
 }
 
 
-void RegExpMacroAssemblerA64::CheckNotCharacterAfterMinusAnd(
+void RegExpMacroAssemblerARM64::CheckNotCharacterAfterMinusAnd(
     uc16 c,
     uc16 minus,
     uc16 mask,
     Label* on_not_equal) {
   ASSERT(minus < String::kMaxUtf16CodeUnit);
   __ Sub(w10, current_character(), minus);
   __ And(w10, w10, mask);
   CompareAndBranchOrBacktrack(w10, c, ne, on_not_equal);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterInRange(
+void RegExpMacroAssemblerARM64::CheckCharacterInRange(
     uc16 from,
     uc16 to,
     Label* on_in_range) {
   __ Sub(w10, current_character(), from);
   // Unsigned lower-or-same condition.
   CompareAndBranchOrBacktrack(w10, to - from, ls, on_in_range);
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterNotInRange(
+void RegExpMacroAssemblerARM64::CheckCharacterNotInRange(
     uc16 from,
     uc16 to,
     Label* on_not_in_range) {
   __ Sub(w10, current_character(), from);
   // Unsigned higher condition.
   CompareAndBranchOrBacktrack(w10, to - from, hi, on_not_in_range);
 }
 
 
-void RegExpMacroAssemblerA64::CheckBitInTable(
+void RegExpMacroAssemblerARM64::CheckBitInTable(
     Handle<ByteArray> table,
     Label* on_bit_set) {
   __ Mov(x11, Operand(table));
   if ((mode_ != ASCII) || (kTableMask != String::kMaxOneByteCharCode)) {
     __ And(w10, current_character(), kTableMask);
     __ Add(w10, w10, ByteArray::kHeaderSize - kHeapObjectTag);
   } else {
     __ Add(w10, current_character(), ByteArray::kHeaderSize - kHeapObjectTag);
   }
   __ Ldrb(w11, MemOperand(x11, w10, UXTW));
   CompareAndBranchOrBacktrack(w11, 0, ne, on_bit_set);
 }
 
 
-bool RegExpMacroAssemblerA64::CheckSpecialCharacterClass(uc16 type,
-                                                         Label* on_no_match) {
+bool RegExpMacroAssemblerARM64::CheckSpecialCharacterClass(uc16 type,
+                                                           Label* on_no_match) {
   // Range checks (c in min..max) are generally implemented by an unsigned
   // (c - min) <= (max - min) check
   switch (type) {
   case 's':
     // Match space-characters
     if (mode_ == ASCII) {
       // One byte space characters are '\t'..'\r', ' ' and \u00a0.
       Label success;
       // Check for ' ' or 0x00a0.
       __ Cmp(current_character(), ' ');
@@ skipping 82 matching lines @@
   case '*':
     // Match any character.
     return true;
   // No custom implementation (yet): s(UC16), S(UC16).
   default:
     return false;
   }
 }
 
 
-void RegExpMacroAssemblerA64::Fail() {
+void RegExpMacroAssemblerARM64::Fail() {
   __ Mov(w0, FAILURE);
   __ B(&exit_label_);
 }
 
 
-Handle<HeapObject> RegExpMacroAssemblerA64::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerARM64::GetCode(Handle<String> source) {
   Label return_w0;
   // Finalize code - write the entry point code now we know how many
   // registers we need.
 
   // Entry code:
   __ Bind(&entry_label_);
 
   // Arguments on entry:
   // x0:  String*  input
   // x1:  int      start_offset
@@ skipping 375 matching lines @@
 
   CodeDesc code_desc;
   masm_->GetCode(&code_desc);
   Handle<Code> code = isolate()->factory()->NewCode(
       code_desc, Code::ComputeFlags(Code::REGEXP), masm_->CodeObject());
   PROFILE(masm_->isolate(), RegExpCodeCreateEvent(*code, *source));
   return Handle<HeapObject>::cast(code);
 }
 
 
-void RegExpMacroAssemblerA64::GoTo(Label* to) {
+void RegExpMacroAssemblerARM64::GoTo(Label* to) {
   BranchOrBacktrack(al, to);
 }
 
-void RegExpMacroAssemblerA64::IfRegisterGE(int reg,
-                                           int comparand,
-                                           Label* if_ge) {
+void RegExpMacroAssemblerARM64::IfRegisterGE(int reg, int comparand,
+                                             Label* if_ge) {
   Register to_compare = GetRegister(reg, w10);
   CompareAndBranchOrBacktrack(to_compare, comparand, ge, if_ge);
 }
 
 
-void RegExpMacroAssemblerA64::IfRegisterLT(int reg,
-                                           int comparand,
-                                           Label* if_lt) {
+void RegExpMacroAssemblerARM64::IfRegisterLT(int reg, int comparand,
+                                             Label* if_lt) {
   Register to_compare = GetRegister(reg, w10);
   CompareAndBranchOrBacktrack(to_compare, comparand, lt, if_lt);
 }
 
 
-void RegExpMacroAssemblerA64::IfRegisterEqPos(int reg,
-                                              Label* if_eq) {
+void RegExpMacroAssemblerARM64::IfRegisterEqPos(int reg, Label* if_eq) {
   Register to_compare = GetRegister(reg, w10);
   __ Cmp(to_compare, current_input_offset());
   BranchOrBacktrack(eq, if_eq);
 }
 
 RegExpMacroAssembler::IrregexpImplementation
-    RegExpMacroAssemblerA64::Implementation() {
-  return kA64Implementation;
+    RegExpMacroAssemblerARM64::Implementation() {
+  return kARM64Implementation;
 }
 
 
-void RegExpMacroAssemblerA64::LoadCurrentCharacter(int cp_offset,
-                                                   Label* on_end_of_input,
-                                                   bool check_bounds,
-                                                   int characters) {
+void RegExpMacroAssemblerARM64::LoadCurrentCharacter(int cp_offset,
+                                                     Label* on_end_of_input,
+                                                     bool check_bounds,
+                                                     int characters) {
   // TODO(pielan): Make sure long strings are caught before this, and not
   // just asserted in debug mode.
   ASSERT(cp_offset >= -1);      // ^ and \b can look behind one character.
   // Be sane! (And ensure that an int32_t can be used to index the string)
   ASSERT(cp_offset < (1<<30));
   if (check_bounds) {
     CheckPosition(cp_offset + characters - 1, on_end_of_input);
   }
   LoadCurrentCharacterUnchecked(cp_offset, characters);
 }
 
 
-void RegExpMacroAssemblerA64::PopCurrentPosition() {
+void RegExpMacroAssemblerARM64::PopCurrentPosition() {
   Pop(current_input_offset());
 }
 
 
-void RegExpMacroAssemblerA64::PopRegister(int register_index) {
+void RegExpMacroAssemblerARM64::PopRegister(int register_index) {
   Pop(w10);
   StoreRegister(register_index, w10);
 }
 
 
-void RegExpMacroAssemblerA64::PushBacktrack(Label* label) {
+void RegExpMacroAssemblerARM64::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);
       // The code offset has to fit in a W register.
       __ Check(ls, kOffsetOutOfRange);
     }
   }
   Push(w10);
   CheckStackLimit();
 }
 
 
-void RegExpMacroAssemblerA64::PushCurrentPosition() {
+void RegExpMacroAssemblerARM64::PushCurrentPosition() {
   Push(current_input_offset());
 }
 
 
-void RegExpMacroAssemblerA64::PushRegister(int register_index,
-                                           StackCheckFlag check_stack_limit) {
+void RegExpMacroAssemblerARM64::PushRegister(int register_index,
+                                             StackCheckFlag check_stack_limit) {
   Register to_push = GetRegister(register_index, w10);
   Push(to_push);
   if (check_stack_limit) CheckStackLimit();
 }
 
 
-void RegExpMacroAssemblerA64::ReadCurrentPositionFromRegister(int reg) {
+void RegExpMacroAssemblerARM64::ReadCurrentPositionFromRegister(int reg) {
   Register cached_register;
   RegisterState register_state = GetRegisterState(reg);
   switch (register_state) {
     case STACKED:
       __ Ldr(current_input_offset(), register_location(reg));
       break;
     case CACHED_LSW:
       cached_register = GetCachedRegister(reg);
       __ Mov(current_input_offset(), cached_register.W());
       break;
     case CACHED_MSW:
       cached_register = GetCachedRegister(reg);
       __ Lsr(current_input_offset().X(), cached_register, kWRegSizeInBits);
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
-void RegExpMacroAssemblerA64::ReadStackPointerFromRegister(int reg) {
+void RegExpMacroAssemblerARM64::ReadStackPointerFromRegister(int reg) {
   Register read_from = GetRegister(reg, w10);
   __ Ldr(x11, MemOperand(frame_pointer(), kStackBase));
   __ Add(backtrack_stackpointer(), x11, Operand(read_from, SXTW));
 }
 
 
-void RegExpMacroAssemblerA64::SetCurrentPositionFromEnd(int by) {
+void RegExpMacroAssemblerARM64::SetCurrentPositionFromEnd(int by) {
   Label after_position;
   __ Cmp(current_input_offset(), -by * char_size());
   __ B(ge, &after_position);
   __ Mov(current_input_offset(), -by * char_size());
   // On RegExp code entry (where this operation is used), the character before
   // the current position is expected to be already loaded.
   // We have advanced the position, so it's safe to read backwards.
   LoadCurrentCharacterUnchecked(-1, 1);
   __ Bind(&after_position);
 }
 
 
-void RegExpMacroAssemblerA64::SetRegister(int register_index, int to) {
+void RegExpMacroAssemblerARM64::SetRegister(int register_index, int to) {
   ASSERT(register_index >= num_saved_registers_);  // Reserved for positions!
   Register set_to = wzr;
   if (to != 0) {
     set_to = w10;
     __ Mov(set_to, to);
   }
   StoreRegister(register_index, set_to);
 }
 
 
-bool RegExpMacroAssemblerA64::Succeed() {
+bool RegExpMacroAssemblerARM64::Succeed() {
   __ B(&success_label_);
   return global();
 }
 
 
-void RegExpMacroAssemblerA64::WriteCurrentPositionToRegister(int reg,
-                                                             int cp_offset) {
+void RegExpMacroAssemblerARM64::WriteCurrentPositionToRegister(int reg,
+                                                               int cp_offset) {
   Register position = current_input_offset();
   if (cp_offset != 0) {
     position = w10;
     __ Add(position, current_input_offset(), cp_offset * char_size());
   }
   StoreRegister(reg, position);
 }
 
 
-void RegExpMacroAssemblerA64::ClearRegisters(int reg_from, int reg_to) {
+void RegExpMacroAssemblerARM64::ClearRegisters(int reg_from, int reg_to) {
   ASSERT(reg_from <= reg_to);
   int num_registers = reg_to - reg_from + 1;
 
   // If the first capture register is cached in a hardware register but not
   // aligned on a 64-bit one, we need to clear the first one specifically.
   if ((reg_from < kNumCachedRegisters) && ((reg_from % 2) != 0)) {
     StoreRegister(reg_from, non_position_value());
     num_registers--;
     reg_from++;
   }
@@ skipping 40 matching lines @@
       for (int i = reg_from; i <= reg_to; i += 2) {
         __ Str(twice_non_position_value(),
                MemOperand(frame_pointer(), base_offset));
         base_offset -= kWRegSize * 2;
       }
     }
   }
 }
 
 
-void RegExpMacroAssemblerA64::WriteStackPointerToRegister(int reg) {
+void RegExpMacroAssemblerARM64::WriteStackPointerToRegister(int reg) {
   __ Ldr(x10, MemOperand(frame_pointer(), kStackBase));
   __ Sub(x10, backtrack_stackpointer(), x10);
   if (masm_->emit_debug_code()) {
     __ Cmp(x10, Operand(w10, SXTW));
     // The stack offset needs to fit in a W register.
     __ Check(eq, kOffsetOutOfRange);
   }
   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,
+int RegExpMacroAssemblerARM64::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);
   if (isolate->stack_guard()->IsStackOverflow()) {
     isolate->StackOverflow();
     return EXCEPTION;
   }
@@ skipping 79 matching lines @@
     // 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) {
+void RegExpMacroAssemblerARM64::CheckPosition(int cp_offset,
+                                              Label* on_outside_input) {
   CompareAndBranchOrBacktrack(current_input_offset(),
                               -cp_offset * char_size(),
                               ge,
                               on_outside_input);
 }
 
 
-bool RegExpMacroAssemblerA64::CanReadUnaligned() {
+bool RegExpMacroAssemblerARM64::CanReadUnaligned() {
   // TODO(pielan): See whether or not we should disable unaligned accesses.
   return !slow_safe();
 }
 
 
 // Private methods:
 
-void RegExpMacroAssemblerA64::CallCheckStackGuardState(Register scratch) {
+void RegExpMacroAssemblerARM64::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 / kXRegSize) - 1;
   int xreg_to_claim = (3 + align_mask) & ~align_mask;
 
   ASSERT(csp.Is(__ StackPointer()));
@@ skipping 26 matching lines @@
   __ Peek(input_start(), kPointerSize);
   __ Peek(input_end(), 2 * kPointerSize);
 
   ASSERT(csp.Is(__ StackPointer()));
   __ Drop(xreg_to_claim);
 
   // Reload the Code pointer.
   __ Mov(code_pointer(), Operand(masm_->CodeObject()));
 }
 
-void RegExpMacroAssemblerA64::BranchOrBacktrack(Condition condition,
-                                                Label* to) {
+void RegExpMacroAssemblerARM64::BranchOrBacktrack(Condition condition,
+                                                  Label* to) {
   if (condition == al) {  // Unconditional.
     if (to == NULL) {
       Backtrack();
       return;
     }
     __ B(to);
     return;
   }
   if (to == NULL) {
     to = &backtrack_label_;
   }
   // TODO(ulan): do direct jump when jump distance is known and fits in imm19.
   Condition inverted_condition = InvertCondition(condition);
   Label no_branch;
   __ B(inverted_condition, &no_branch);
   __ B(to);
   __ Bind(&no_branch);
 }
 
-void RegExpMacroAssemblerA64::CompareAndBranchOrBacktrack(Register reg,
-                                                          int immediate,
-                                                          Condition condition,
-                                                          Label* to) {
+void RegExpMacroAssemblerARM64::CompareAndBranchOrBacktrack(Register reg,
+                                                            int immediate,
+                                                            Condition condition,
+                                                            Label* to) {
   if ((immediate == 0) && ((condition == eq) || (condition == ne))) {
     if (to == NULL) {
       to = &backtrack_label_;
     }
     // TODO(ulan): do direct jump when jump distance is known and fits in imm19.
     Label no_branch;
     if (condition == eq) {
       __ Cbnz(reg, &no_branch);
     } else {
       __ Cbz(reg, &no_branch);
     }
     __ B(to);
     __ Bind(&no_branch);
   } else {
     __ Cmp(reg, immediate);
     BranchOrBacktrack(condition, to);
   }
 }
 
 
-void RegExpMacroAssemblerA64::CheckPreemption() {
+void RegExpMacroAssemblerARM64::CheckPreemption() {
   // Check for preemption.
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
   __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
   ASSERT(csp.Is(__ StackPointer()));
   __ Cmp(csp, x10);
   CallIf(&check_preempt_label_, ls);
 }
 
 
-void RegExpMacroAssemblerA64::CheckStackLimit() {
+void RegExpMacroAssemblerARM64::CheckStackLimit() {
   ExternalReference stack_limit =
       ExternalReference::address_of_regexp_stack_limit(isolate());
   __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
   __ Cmp(backtrack_stackpointer(), x10);
   CallIf(&stack_overflow_label_, ls);
 }
 
 
-void RegExpMacroAssemblerA64::Push(Register source) {
+void RegExpMacroAssemblerARM64::Push(Register source) {
   ASSERT(source.Is32Bits());
   ASSERT(!source.is(backtrack_stackpointer()));
   __ Str(source,
          MemOperand(backtrack_stackpointer(),
                     -static_cast<int>(kWRegSize),
                     PreIndex));
 }
 
 
-void RegExpMacroAssemblerA64::Pop(Register target) {
+void RegExpMacroAssemblerARM64::Pop(Register target) {
   ASSERT(target.Is32Bits());
   ASSERT(!target.is(backtrack_stackpointer()));
   __ Ldr(target,
          MemOperand(backtrack_stackpointer(), kWRegSize, PostIndex));
 }
 
 
-Register RegExpMacroAssemblerA64::GetCachedRegister(int register_index) {
+Register RegExpMacroAssemblerARM64::GetCachedRegister(int register_index) {
   ASSERT(register_index < kNumCachedRegisters);
   return Register::Create(register_index / 2, kXRegSizeInBits);
 }
 
 
-Register RegExpMacroAssemblerA64::GetRegister(int register_index,
-                                              Register maybe_result) {
+Register RegExpMacroAssemblerARM64::GetRegister(int register_index,
+                                                Register maybe_result) {
   ASSERT(maybe_result.Is32Bits());
   ASSERT(register_index >= 0);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   Register result;
   RegisterState register_state = GetRegisterState(register_index);
   switch (register_state) {
     case STACKED:
       __ Ldr(maybe_result, register_location(register_index));
       result = maybe_result;
       break;
     case CACHED_LSW:
       result = GetCachedRegister(register_index).W();
       break;
     case CACHED_MSW:
       __ Lsr(maybe_result.X(), GetCachedRegister(register_index),
              kWRegSizeInBits);
       result = maybe_result;
       break;
     default:
       UNREACHABLE();
       break;
   }
   ASSERT(result.Is32Bits());
   return result;
 }
 
 
-void RegExpMacroAssemblerA64::StoreRegister(int register_index,
-                                            Register source) {
+void RegExpMacroAssemblerARM64::StoreRegister(int register_index,
+                                              Register source) {
   ASSERT(source.Is32Bits());
   ASSERT(register_index >= 0);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
 
   Register cached_register;
   RegisterState register_state = GetRegisterState(register_index);
   switch (register_state) {
     case STACKED:
       __ Str(source, register_location(register_index));
       break;
     case CACHED_LSW:
       cached_register = GetCachedRegister(register_index);
       if (!source.Is(cached_register.W())) {
         __ Bfi(cached_register, source.X(), 0, kWRegSizeInBits);
       }
       break;
     case CACHED_MSW:
       cached_register = GetCachedRegister(register_index);
       __ Bfi(cached_register, source.X(), kWRegSizeInBits, kWRegSizeInBits);
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
-void RegExpMacroAssemblerA64::CallIf(Label* to, Condition condition) {
+void RegExpMacroAssemblerARM64::CallIf(Label* to, Condition condition) {
   Label skip_call;
   if (condition != al) __ B(&skip_call, InvertCondition(condition));
   __ Bl(to);
   __ Bind(&skip_call);
 }
 
 
-void RegExpMacroAssemblerA64::RestoreLinkRegister() {
+void RegExpMacroAssemblerARM64::RestoreLinkRegister() {
   ASSERT(csp.Is(__ StackPointer()));
   __ Pop(lr, xzr);
   __ Add(lr, lr, Operand(masm_->CodeObject()));
 }
 
 
-void RegExpMacroAssemblerA64::SaveLinkRegister() {
+void RegExpMacroAssemblerARM64::SaveLinkRegister() {
   ASSERT(csp.Is(__ StackPointer()));
   __ Sub(lr, lr, Operand(masm_->CodeObject()));
   __ Push(xzr, lr);
 }
 
 
-MemOperand RegExpMacroAssemblerA64::register_location(int register_index) {
+MemOperand RegExpMacroAssemblerARM64::register_location(int register_index) {
   ASSERT(register_index < (1<<30));
   ASSERT(register_index >= kNumCachedRegisters);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   register_index -= kNumCachedRegisters;
   int offset = kFirstRegisterOnStack - register_index * kWRegSize;
   return MemOperand(frame_pointer(), offset);
 }
 
-MemOperand RegExpMacroAssemblerA64::capture_location(int register_index,
+MemOperand RegExpMacroAssemblerARM64::capture_location(int register_index,
                                                      Register scratch) {
   ASSERT(register_index < (1<<30));
   ASSERT(register_index < num_saved_registers_);
   ASSERT(register_index >= kNumCachedRegisters);
   ASSERT_EQ(register_index % 2, 0);
   register_index -= kNumCachedRegisters;
   int offset = kFirstCaptureOnStack - register_index * kWRegSize;
   // capture_location is used with Stp instructions to load/store 2 registers.
   // The immediate field in the encoding is limited to 7 bits (signed).
   if (is_int7(offset)) {
     return MemOperand(frame_pointer(), offset);
   } else {
     __ Add(scratch, frame_pointer(), offset);
     return MemOperand(scratch);
   }
 }
 
-void RegExpMacroAssemblerA64::LoadCurrentCharacterUnchecked(int cp_offset,
-                                                            int characters) {
+void RegExpMacroAssemblerARM64::LoadCurrentCharacterUnchecked(int cp_offset,
+                                                              int characters) {
   Register offset = current_input_offset();
 
   // The ldr, str, ldrh, strh instructions can do unaligned accesses, if the CPU
   // and the operating system running on the target allow it.
   // If unaligned load/stores are not supported then this function must only
   // be used to load a single character at a time.
 
   // ARMv8 supports unaligned accesses but V8 or the kernel can decide to
   // disable it.
   // TODO(pielan): See whether or not we should disable unaligned accesses.
@@ skipping 31 matching lines @@
       ASSERT(characters == 1);
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
-#endif  // V8_TARGET_ARCH_A64
+#endif  // V8_TARGET_ARCH_ARM64