Rename A64 port to ARM64 port

src/arm64/assembler-arm64.h

 // 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.
 
-#ifndef V8_A64_ASSEMBLER_A64_H_
-#define V8_A64_ASSEMBLER_A64_H_
+#ifndef V8_ARM64_ASSEMBLER_ARM64_H_
+#define V8_ARM64_ASSEMBLER_ARM64_H_
 
 #include <list>
 #include <map>
 
 #include "globals.h"
 #include "utils.h"
 #include "assembler.h"
 #include "serialize.h"
-#include "a64/instructions-a64.h"
-#include "a64/cpu-a64.h"
+#include "arm64/instructions-arm64.h"
+#include "arm64/cpu-arm64.h"
 
 
 namespace v8 {
 namespace internal {
 
 
 // -----------------------------------------------------------------------------
 // Registers.
 #define REGISTER_CODE_LIST(R)                                                  \
 R(0)  R(1)  R(2)  R(3)  R(4)  R(5)  R(6)  R(7)                                 \
@@ skipping 275 matching lines @@
     return FPRegister::Create(code, kDRegSizeInBits);
   }
   // End of V8 compatibility section -----------------------
 };
 
 
 STATIC_ASSERT(sizeof(CPURegister) == sizeof(Register));
 STATIC_ASSERT(sizeof(CPURegister) == sizeof(FPRegister));
 
 
-#if defined(A64_DEFINE_REG_STATICS)
+#if defined(ARM64_DEFINE_REG_STATICS)
 #define INITIALIZE_REGISTER(register_class, name, code, size, type)      \
   const CPURegister init_##register_class##_##name = {code, size, type}; \
   const register_class& name = *reinterpret_cast<const register_class*>( \
                                     &init_##register_class##_##name)
 #define ALIAS_REGISTER(register_class, alias, name)                       \
   const register_class& alias = *reinterpret_cast<const register_class*>( \
                                      &init_##register_class##_##name)
 #else
 #define INITIALIZE_REGISTER(register_class, name, code, size, type) \
   extern const register_class& name
 #define ALIAS_REGISTER(register_class, alias, name) \
   extern const register_class& alias
-#endif  // defined(A64_DEFINE_REG_STATICS)
+#endif  // defined(ARM64_DEFINE_REG_STATICS)
 
 // No*Reg is used to indicate an unused argument, or an error case. Note that
 // these all compare equal (using the Is() method). The Register and FPRegister
 // variants are provided for convenience.
 INITIALIZE_REGISTER(Register, NoReg, 0, 0, CPURegister::kNoRegister);
 INITIALIZE_REGISTER(FPRegister, NoFPReg, 0, 0, CPURegister::kNoRegister);
 INITIALIZE_REGISTER(CPURegister, NoCPUReg, 0, 0, CPURegister::kNoRegister);
 
 // v8 compatibility.
 INITIALIZE_REGISTER(Register, no_reg, 0, 0, CPURegister::kNoRegister);
@@ skipping 1297 matching lines @@
     EmitData(string, len);
     // Pad with NULL characters until pc_ is aligned.
     const char pad[] = {'\0', '\0', '\0', '\0'};
     STATIC_ASSERT(sizeof(pad) == kInstructionSize);
     byte* next_pc = AlignUp(pc_, kInstructionSize);
     EmitData(&pad, next_pc - pc_);
   }
 
   // Pseudo-instructions ------------------------------------------------------
 
-  // Parameters are described in a64/instructions-a64.h.
+  // Parameters are described in arm64/instructions-arm64.h.
   void debug(const char* message, uint32_t code, Instr params = BREAK);
 
   // Required by V8.
   void dd(uint32_t data) { dc32(data); }
   void db(uint8_t data) { dc8(data); }
 
   // Code generation helpers --------------------------------------------------
 
   unsigned num_pending_reloc_info() const { return num_pending_reloc_info_; }
 
@@ skipping 536 matching lines @@
 
 class EnsureSpace BASE_EMBEDDED {
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 } }  // namespace v8::internal
 
-#endif  // V8_A64_ASSEMBLER_A64_H_
+#endif  // V8_ARM64_ASSEMBLER_ARM64_H_