Rename A64 port to ARM64 port

src/arm64/regexp-macro-assembler-arm64.cc

Index: src/arm64/regexp-macro-assembler-arm64.cc
diff --git a/src/a64/regexp-macro-assembler-a64.cc b/src/arm64/regexp-macro-assembler-arm64.cc
similarity index 90%
rename from src/a64/regexp-macro-assembler-a64.cc
rename to src/arm64/regexp-macro-assembler-arm64.cc
index 0b6ade8509f1510f0216182016f961a59c0c392f..536580ab55200599cfa7544478798a8981cd411a 100644
--- a/src/a64/regexp-macro-assembler-a64.cc
+++ b/src/arm64/regexp-macro-assembler-arm64.cc
@@ -27,7 +27,7 @@
 
 #include "v8.h"
 
-#if V8_TARGET_ARCH_A64
+#if V8_TARGET_ARCH_ARM64
 
 #include "cpu-profiler.h"
 #include "unicode.h"
@@ -36,7 +36,7 @@
 #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 {
@@ -124,7 +124,7 @@ namespace internal {
  *              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
@@ -133,7 +133,7 @@ namespace internal {
 
 #define __ ACCESS_MASM(masm_)
 
-RegExpMacroAssemblerA64::RegExpMacroAssemblerA64(
+RegExpMacroAssemblerARM64::RegExpMacroAssemblerARM64(
     Mode mode,
     int registers_to_save,
     Zone* zone)
@@ -157,7 +157,7 @@ RegExpMacroAssemblerA64::RegExpMacroAssemblerA64(
 }
 
 
-RegExpMacroAssemblerA64::~RegExpMacroAssemblerA64() {
+RegExpMacroAssemblerARM64::~RegExpMacroAssemblerARM64() {
   delete masm_;
   // Unuse labels in case we throw away the assembler without calling GetCode.
   entry_label_.Unuse();
@@ -169,12 +169,12 @@ RegExpMacroAssemblerA64::~RegExpMacroAssemblerA64() {
   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());
@@ -182,7 +182,7 @@ void RegExpMacroAssemblerA64::AdvanceCurrentPosition(int by) {
 }
 
 
-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;
@@ -210,7 +210,7 @@ void RegExpMacroAssemblerA64::AdvanceRegister(int reg, int by) {
 }
 
 
-void RegExpMacroAssemblerA64::Backtrack() {
+void RegExpMacroAssemblerARM64::Backtrack() {
   CheckPreemption();
   Pop(w10);
   __ Add(x10, code_pointer(), Operand(w10, UXTW));
@@ -218,22 +218,23 @@ void RegExpMacroAssemblerA64::Backtrack() {
 }
 
 
-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);
@@ -245,7 +246,7 @@ void RegExpMacroAssemblerA64::CheckAtStart(Label* on_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?
@@ -255,12 +256,12 @@ void RegExpMacroAssemblerA64::CheckNotAtStart(Label* 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) {
@@ -292,7 +293,7 @@ void RegExpMacroAssemblerA64::CheckCharacters(Vector<const uc16> str,
 }
 
 
-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);
@@ -301,7 +302,7 @@ void RegExpMacroAssemblerA64::CheckGreedyLoop(Label* on_equal) {
   BranchOrBacktrack(eq, on_equal);
 }
 
-void RegExpMacroAssemblerA64::CheckNotBackReferenceIgnoreCase(
+void RegExpMacroAssemblerARM64::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
@@ -428,7 +429,7 @@ void RegExpMacroAssemblerA64::CheckNotBackReferenceIgnoreCase(
   __ Bind(&fallthrough);
 }
 
-void RegExpMacroAssemblerA64::CheckNotBackReference(
+void RegExpMacroAssemblerARM64::CheckNotBackReference(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
@@ -490,29 +491,29 @@ void RegExpMacroAssemblerA64::CheckNotBackReference(
 }
 
 
-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,
@@ -524,7 +525,7 @@ void RegExpMacroAssemblerA64::CheckNotCharacterAfterMinusAnd(
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterInRange(
+void RegExpMacroAssemblerARM64::CheckCharacterInRange(
     uc16 from,
     uc16 to,
     Label* on_in_range) {
@@ -534,7 +535,7 @@ void RegExpMacroAssemblerA64::CheckCharacterInRange(
 }
 
 
-void RegExpMacroAssemblerA64::CheckCharacterNotInRange(
+void RegExpMacroAssemblerARM64::CheckCharacterNotInRange(
     uc16 from,
     uc16 to,
     Label* on_not_in_range) {
@@ -544,7 +545,7 @@ void RegExpMacroAssemblerA64::CheckCharacterNotInRange(
 }
 
 
-void RegExpMacroAssemblerA64::CheckBitInTable(
+void RegExpMacroAssemblerARM64::CheckBitInTable(
     Handle<ByteArray> table,
     Label* on_bit_set) {
   __ Mov(x11, Operand(table));
@@ -559,8 +560,8 @@ void RegExpMacroAssemblerA64::CheckBitInTable(
 }
 
 
-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) {
@@ -663,13 +664,13 @@ bool RegExpMacroAssemblerA64::CheckSpecialCharacterClass(uc16 type,
 }
 
 
-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.
@@ -1065,43 +1066,40 @@ Handle<HeapObject> RegExpMacroAssemblerA64::GetCode(Handle<String> source) {
 }
 
 
-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.
@@ -1114,18 +1112,18 @@ void RegExpMacroAssemblerA64::LoadCurrentCharacter(int cp_offset,
 }
 
 
-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);
@@ -1143,20 +1141,20 @@ void RegExpMacroAssemblerA64::PushBacktrack(Label* label) {
 }
 
 
-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) {
@@ -1178,14 +1176,14 @@ void RegExpMacroAssemblerA64::ReadCurrentPositionFromRegister(int reg) {
 }
 
 
-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);
@@ -1198,7 +1196,7 @@ void RegExpMacroAssemblerA64::SetCurrentPositionFromEnd(int by) {
 }
 
 
-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) {
@@ -1209,14 +1207,14 @@ void RegExpMacroAssemblerA64::SetRegister(int register_index, int 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;
@@ -1226,7 +1224,7 @@ void RegExpMacroAssemblerA64::WriteCurrentPositionToRegister(int reg,
 }
 
 
-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;
 
@@ -1287,7 +1285,7 @@ void RegExpMacroAssemblerA64::ClearRegisters(int reg_from, int reg_to) {
 }
 
 
-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()) {
@@ -1306,7 +1304,7 @@ static T& frame_entry(Address re_frame, int frame_offset) {
 }
 
 
-int RegExpMacroAssemblerA64::CheckStackGuardState(Address* return_address,
+int RegExpMacroAssemblerARM64::CheckStackGuardState(Address* return_address,
                                                   Code* re_code,
                                                   Address re_frame,
                                                   int start_offset,
@@ -1406,8 +1404,8 @@ int RegExpMacroAssemblerA64::CheckStackGuardState(Address* return_address,
 }
 
 
-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,
@@ -1415,7 +1413,7 @@ void RegExpMacroAssemblerA64::CheckPosition(int cp_offset,
 }
 
 
-bool RegExpMacroAssemblerA64::CanReadUnaligned() {
+bool RegExpMacroAssemblerARM64::CanReadUnaligned() {
   // TODO(pielan): See whether or not we should disable unaligned accesses.
   return !slow_safe();
 }
@@ -1423,7 +1421,7 @@ bool RegExpMacroAssemblerA64::CanReadUnaligned() {
 
 // 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.
@@ -1470,8 +1468,8 @@ void RegExpMacroAssemblerA64::CallCheckStackGuardState(Register scratch) {
   __ 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();
@@ -1491,10 +1489,10 @@ void RegExpMacroAssemblerA64::BranchOrBacktrack(Condition condition,
   __ 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_;
@@ -1515,7 +1513,7 @@ void RegExpMacroAssemblerA64::CompareAndBranchOrBacktrack(Register reg,
 }
 
 
-void RegExpMacroAssemblerA64::CheckPreemption() {
+void RegExpMacroAssemblerARM64::CheckPreemption() {
   // Check for preemption.
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
@@ -1527,7 +1525,7 @@ void RegExpMacroAssemblerA64::CheckPreemption() {
 }
 
 
-void RegExpMacroAssemblerA64::CheckStackLimit() {
+void RegExpMacroAssemblerARM64::CheckStackLimit() {
   ExternalReference stack_limit =
       ExternalReference::address_of_regexp_stack_limit(isolate());
   __ Mov(x10, stack_limit);
@@ -1537,7 +1535,7 @@ void RegExpMacroAssemblerA64::CheckStackLimit() {
 }
 
 
-void RegExpMacroAssemblerA64::Push(Register source) {
+void RegExpMacroAssemblerARM64::Push(Register source) {
   ASSERT(source.Is32Bits());
   ASSERT(!source.is(backtrack_stackpointer()));
   __ Str(source,
@@ -1547,7 +1545,7 @@ void RegExpMacroAssemblerA64::Push(Register source) {
 }
 
 
-void RegExpMacroAssemblerA64::Pop(Register target) {
+void RegExpMacroAssemblerARM64::Pop(Register target) {
   ASSERT(target.Is32Bits());
   ASSERT(!target.is(backtrack_stackpointer()));
   __ Ldr(target,
@@ -1555,14 +1553,14 @@ void RegExpMacroAssemblerA64::Pop(Register target) {
 }
 
 
-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) {
@@ -1592,8 +1590,8 @@ Register RegExpMacroAssemblerA64::GetRegister(int register_index,
 }
 
 
-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) {
@@ -1623,7 +1621,7 @@ void RegExpMacroAssemblerA64::StoreRegister(int register_index,
 }
 
 
-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);
@@ -1631,21 +1629,21 @@ void RegExpMacroAssemblerA64::CallIf(Label* to, Condition condition) {
 }
 
 
-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) {
@@ -1656,7 +1654,7 @@ MemOperand RegExpMacroAssemblerA64::register_location(int register_index) {
   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_);
@@ -1674,8 +1672,8 @@ MemOperand RegExpMacroAssemblerA64::capture_location(int register_index,
   }
 }
 
-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
@@ -1727,4 +1725,4 @@ void RegExpMacroAssemblerA64::LoadCurrentCharacterUnchecked(int cp_offset,
 
 }}  // namespace v8::internal
 
-#endif  // V8_TARGET_ARCH_A64
+#endif  // V8_TARGET_ARCH_ARM64