Rename A64 port to ARM64 port

src/arm64/codegen-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 "codegen.h"
 #include "macro-assembler.h"
-#include "simulator-a64.h"
+#include "simulator-arm64.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm)
 
 #if defined(USE_SIMULATOR)
-byte* fast_exp_a64_machine_code = NULL;
+byte* fast_exp_arm64_machine_code = NULL;
 double fast_exp_simulator(double x) {
   Simulator * simulator = Simulator::current(Isolate::Current());
   Simulator::CallArgument args[] = {
       Simulator::CallArgument(x),
       Simulator::CallArgument::End()
   };
-  return simulator->CallDouble(fast_exp_a64_machine_code, args);
+  return simulator->CallDouble(fast_exp_arm64_machine_code, args);
 }
 #endif
 
 
 UnaryMathFunction CreateExpFunction() {
   if (!FLAG_fast_math) return &std::exp;
 
   // Use the Math.exp implemetation in MathExpGenerator::EmitMathExp() to create
   // an AAPCS64-compliant exp() function. This will be faster than the C
   // library's exp() function, but probably less accurate.
@@ skipping 25 matching lines @@
   CodeDesc desc;
   masm.GetCode(&desc);
   ASSERT(!RelocInfo::RequiresRelocation(desc));
 
   CPU::FlushICache(buffer, actual_size);
   OS::ProtectCode(buffer, actual_size);
 
 #if !defined(USE_SIMULATOR)
   return FUNCTION_CAST<UnaryMathFunction>(buffer);
 #else
-  fast_exp_a64_machine_code = buffer;
+  fast_exp_arm64_machine_code = buffer;
   return &fast_exp_simulator;
 #endif
 }
 
 
 UnaryMathFunction CreateSqrtFunction() {
   return &std::sqrt;
 }
 
 
@@ skipping 433 matching lines @@
   //  NZCV
   //  1000      -708.4 < input < 709.8    result = exp(input)
   //  0110      input == 709.8            result = +infinity
   //  0010      input > 709.8             result = +infinity
   //  0011      input is NaN              result = input
   //  0000      input <= -708.4           result = +0.0
 
   // Continue the common case first. 'mi' tests N == 1.
   __ B(&result_is_finite_non_zero, mi);
 
-  // TODO(jbramley): Consider adding a +infinity register for A64.
+  // TODO(jbramley): Consider adding a +infinity register for ARM64.
   __ Ldr(double_temp2, ExpConstant(constants, 2));    // Synthesize +infinity.
 
   // Select between +0.0 and +infinity. 'lo' tests C == 0.
   __ Fcsel(result, fp_zero, double_temp2, lo);
   // Select between {+0.0 or +infinity} and input. 'vc' tests V == 0.
   __ Fcsel(result, result, input, vc);
   __ B(&done);
 
   // The rest is magic, as described in InitializeMathExpData().
   __ Bind(&result_is_finite_non_zero);
@@ skipping 45 matching lines @@
 
   __ Fmul(result, double_temp3, double_temp1);
 
   __ Bind(&done);
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
-#endif  // V8_TARGET_ARCH_A64
+#endif  // V8_TARGET_ARCH_ARM64