Rename A64 port to ARM64 port

src/arm64/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
@@ skipping 10 matching lines @@
 // 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
 
-#define A64_DEFINE_REG_STATICS
+#define ARM64_DEFINE_REG_STATICS
 
-#include "a64/assembler-a64-inl.h"
+#include "arm64/assembler-arm64-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 // -----------------------------------------------------------------------------
 // CpuFeatures utilities (for V8 compatibility).
 
 ExternalReference ExternalReference::cpu_features() {
   return ExternalReference(&CpuFeatures::supported_);
@@ skipping 102 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // Implementation of RelocInfo
 
 const int RelocInfo::kApplyMask = 0;
 
 
 bool RelocInfo::IsCodedSpecially() {
   // The deserializer needs to know whether a pointer is specially coded. Being
-  // specially coded on A64 means that it is a movz/movk sequence. We don't
+  // specially coded on ARM64 means that it is a movz/movk sequence. We don't
   // generate those for relocatable pointers.
   return false;
 }
 
 
 bool RelocInfo::IsInConstantPool() {
   Instruction* instr = reinterpret_cast<Instruction*>(pc_);
   return instr->IsLdrLiteralX();
 }
 
@@ skipping 1768 matching lines @@
 #ifdef DEBUG
     Serializer::TooLateToEnableNow();
 #endif
     // The arguments to the debug marker need to be contiguous in memory, so
     // make sure we don't try to emit pools.
     BlockPoolsScope scope(this);
 
     Label start;
     bind(&start);
 
-    // Refer to instructions-a64.h for a description of the marker and its
+    // Refer to instructions-arm64.h for a description of the marker and its
     // arguments.
     hlt(kImmExceptionIsDebug);
     ASSERT(SizeOfCodeGeneratedSince(&start) == kDebugCodeOffset);
     dc32(code);
     ASSERT(SizeOfCodeGeneratedSince(&start) == kDebugParamsOffset);
     dc32(params);
     ASSERT(SizeOfCodeGeneratedSince(&start) == kDebugMessageOffset);
     EmitStringData(message);
     hlt(kImmExceptionIsUnreachable);
 
@@ skipping 629 matching lines @@
     // Emit jump over constant pool if necessary.
     Label after_pool;
     if (require_jump) {
       b(&after_pool);
     }
 
     // Emit a constant pool header. The header has two goals:
     //  1) Encode the size of the constant pool, for use by the disassembler.
     //  2) Terminate the program, to try to prevent execution from accidentally
     //     flowing into the constant pool.
-    // The header is therefore made of two a64 instructions:
+    // The header is therefore made of two arm64 instructions:
     //   ldr xzr, #<size of the constant pool in 32-bit words>
     //   blr xzr
     // If executed the code will likely segfault and lr will point to the
     // beginning of the constant pool.
     // TODO(all): currently each relocated constant is 64 bits, consider adding
     // support for 32-bit entries.
     ConstantPoolMarker(2 * num_pending_reloc_info_);
     ConstantPoolGuard();
 
     // Emit constant pool entries.
@@ skipping 195 matching lines @@
 
 
 void Assembler::PopulateConstantPool(ConstantPoolArray* constant_pool) {
   // No out-of-line constant pool support.
   UNREACHABLE();
 }
 
 
 } }  // namespace v8::internal
 
-#endif  // V8_TARGET_ARCH_A64
+#endif  // V8_TARGET_ARCH_ARM64