Rename A64 port to ARM64 port

src/arm64/instructions-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_INSTRUCTIONS_A64_H_
-#define V8_A64_INSTRUCTIONS_A64_H_
+#ifndef V8_ARM64_INSTRUCTIONS_ARM64_H_
+#define V8_ARM64_INSTRUCTIONS_ARM64_H_
 
 #include "globals.h"
 #include "utils.h"
-#include "a64/constants-a64.h"
-#include "a64/utils-a64.h"
+#include "arm64/constants-arm64.h"
+#include "arm64/utils-arm64.h"
 
 namespace v8 {
 namespace internal {
 
 
 // ISA constants. --------------------------------------------------------------
 
 typedef uint32_t Instr;
 
 // The following macros initialize a float/double variable with a bit pattern
-// without using static initializers: If A64_DEFINE_FP_STATICS is defined, the
+// without using static initializers: If ARM64_DEFINE_FP_STATICS is defined, the
 // symbol is defined as uint32_t/uint64_t initialized with the desired bit
 // pattern. Otherwise, the same symbol is declared as an external float/double.
-#if defined(A64_DEFINE_FP_STATICS)
+#if defined(ARM64_DEFINE_FP_STATICS)
 #define DEFINE_FLOAT(name, value) extern const uint32_t name = value
 #define DEFINE_DOUBLE(name, value) extern const uint64_t name = value
 #else
 #define DEFINE_FLOAT(name, value) extern const float name
 #define DEFINE_DOUBLE(name, value) extern const double name
-#endif  // defined(A64_DEFINE_FP_STATICS)
+#endif  // defined(ARM64_DEFINE_FP_STATICS)
 
 DEFINE_FLOAT(kFP32PositiveInfinity, 0x7f800000);
 DEFINE_FLOAT(kFP32NegativeInfinity, 0xff800000);
 DEFINE_DOUBLE(kFP64PositiveInfinity, 0x7ff0000000000000UL);
 DEFINE_DOUBLE(kFP64NegativeInfinity, 0xfff0000000000000UL);
 
 // This value is a signalling NaN as both a double and as a float (taking the
 // least-significant word).
 DEFINE_DOUBLE(kFP64SignallingNaN, 0x7ff000007f800001);
 DEFINE_FLOAT(kFP32SignallingNaN, 0x7f800001);
@@ skipping 350 matching lines @@
 // Indicate to the Debugger that the instruction is a redirected call.
 const Instr kImmExceptionIsRedirectedCall = 0xca11;
 
 // Represent unreachable code. This is used as a guard in parts of the code that
 // should not be reachable, such as in data encoded inline in the instructions.
 const Instr kImmExceptionIsUnreachable = 0xdebf;
 
 // A pseudo 'printf' instruction. The arguments will be passed to the platform
 // printf method.
 const Instr kImmExceptionIsPrintf = 0xdeb1;
-// Parameters are stored in A64 registers as if the printf pseudo-instruction
+// Parameters are stored in ARM64 registers as if the printf pseudo-instruction
 // was a call to the real printf method:
 //
 // x0: The format string, then either of:
 //   x1-x7: Optional arguments.
 //   d0-d7: Optional arguments.
 //
 // Floating-point and integer arguments are passed in separate sets of
 // registers in AAPCS64 (even for varargs functions), so it is not possible to
 // determine the type of location of each arguments without some information
 // about the values that were passed in. This information could be retrieved
@@ skipping 55 matching lines @@
   // Trace control.
   TRACE_ENABLE   = 1 << 6,
   TRACE_DISABLE  = 2 << 6,
   TRACE_OVERRIDE = 3 << 6
 };
 
 
 } }  // namespace v8::internal
 
 
-#endif  // V8_A64_INSTRUCTIONS_A64_H_
+#endif  // V8_ARM64_INSTRUCTIONS_ARM64_H_