Reland "ARM64: Add NEON support"

src/arm64/code-stubs-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/api-arguments.h"
 #include "src/arm64/assembler-arm64-inl.h"
 #include "src/arm64/frames-arm64.h"
 #include "src/arm64/macro-assembler-arm64-inl.h"
@@ skipping 129 matching lines @@
     __ Pop(double_scratch);
   }
   __ Pop(scratch2, scratch1);
   __ Ret();
 }
 
 
 // See call site for description.
 static void EmitIdenticalObjectComparison(MacroAssembler* masm, Register left,
                                           Register right, Register scratch,
-                                          FPRegister double_scratch,
-                                          Label* slow, Condition cond) {
+                                          VRegister double_scratch, Label* slow,
+                                          Condition cond) {
   DCHECK(!AreAliased(left, right, scratch));
   Label not_identical, return_equal, heap_number;
   Register result = x0;
 
   __ Cmp(right, left);
   __ B(ne, &not_identical);
 
   // Test for NaN. Sadly, we can't just compare to factory::nan_value(),
   // so we do the second best thing - test it ourselves.
   // They are both equal and they are not both Smis so both of them are not
@@ skipping 123 matching lines @@
   // same object. We have already tested that case, so if left and right are
   // both internalized strings, they cannot be equal.
   STATIC_ASSERT((kInternalizedTag == 0) && (kStringTag == 0));
   __ Orr(scratch, left_type, right_type);
   __ TestAndBranchIfAllClear(
       scratch, kIsNotStringMask | kIsNotInternalizedMask, &return_not_equal);
 }
 
 
 // See call site for description.
-static void EmitSmiNonsmiComparison(MacroAssembler* masm,
-                                    Register left,
-                                    Register right,
-                                    FPRegister left_d,
-                                    FPRegister right_d,
-                                    Label* slow,
+static void EmitSmiNonsmiComparison(MacroAssembler* masm, Register left,
+                                    Register right, VRegister left_d,
+                                    VRegister right_d, Label* slow,
                                     bool strict) {
   DCHECK(!AreAliased(left_d, right_d));
   DCHECK((left.is(x0) && right.is(x1)) ||
          (right.is(x0) && left.is(x1)));
   Register result = x0;
 
   Label right_is_smi, done;
   __ JumpIfSmi(right, &right_is_smi);
 
   // Left is the smi. Check whether right is a heap number.
@@ skipping 158 matching lines @@
   __ JumpIfBothNotSmi(lhs, rhs, &not_smis);
 
   // Exactly one operand is a smi. EmitSmiNonsmiComparison generates code that
   // can:
   //  1) Return the answer.
   //  2) Branch to the slow case.
   //  3) Fall through to both_loaded_as_doubles.
   // In case 3, we have found out that we were dealing with a number-number
   // comparison. The double values of the numbers have been loaded, right into
   // rhs_d, left into lhs_d.
-  FPRegister rhs_d = d0;
-  FPRegister lhs_d = d1;
+  VRegister rhs_d = d0;
+  VRegister lhs_d = d1;
   EmitSmiNonsmiComparison(masm, lhs, rhs, lhs_d, rhs_d, &slow, strict());
 
   __ Bind(&both_loaded_as_doubles);
   // The arguments have been converted to doubles and stored in rhs_d and
   // lhs_d.
   Label nan;
   __ Fcmp(lhs_d, rhs_d);
   __ B(vs, &nan);  // Overflow flag set if either is NaN.
   STATIC_ASSERT((LESS == -1) && (EQUAL == 0) && (GREATER == 1));
   __ Cset(result, gt);  // gt => 1, otherwise (lt, eq) => 0 (EQUAL).
@@ skipping 115 matching lines @@
     __ TailCallRuntime(Runtime::kCompare);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
   CPURegList saved_regs = kCallerSaved;
-  CPURegList saved_fp_regs = kCallerSavedFP;
+  CPURegList saved_fp_regs = kCallerSavedV;
 
   // We don't allow a GC during a store buffer overflow so there is no need to
   // store the registers in any particular way, but we do have to store and
   // restore them.
 
   // We don't care if MacroAssembler scratch registers are corrupted.
   saved_regs.Remove(*(masm->TmpList()));
   saved_fp_regs.Remove(*(masm->FPTmpList()));
 
   __ PushCPURegList(saved_regs);
@@ skipping 52 matching lines @@
   // jssp[0]: Exponent (as a tagged value).
   // jssp[1]: Base (as a tagged value).
   //
   // The (tagged) result will be returned in x0, as a heap number.
 
   Register exponent_tagged = MathPowTaggedDescriptor::exponent();
   DCHECK(exponent_tagged.is(x11));
   Register exponent_integer = MathPowIntegerDescriptor::exponent();
   DCHECK(exponent_integer.is(x12));
   Register saved_lr = x19;
-  FPRegister result_double = d0;
-  FPRegister base_double = d0;
-  FPRegister exponent_double = d1;
-  FPRegister base_double_copy = d2;
-  FPRegister scratch1_double = d6;
-  FPRegister scratch0_double = d7;
+  VRegister result_double = d0;
+  VRegister base_double = d0;
+  VRegister exponent_double = d1;
+  VRegister base_double_copy = d2;
+  VRegister scratch1_double = d6;
+  VRegister scratch0_double = d7;
 
   // A fast-path for integer exponents.
   Label exponent_is_smi, exponent_is_integer;
   // Allocate a heap number for the result, and return it.
   Label done;
 
   // Unpack the inputs.
   if (exponent_type() == TAGGED) {
     __ JumpIfSmi(exponent_tagged, &exponent_is_smi);
     __ Ldr(exponent_double,
@@ skipping 937 matching lines @@
   DCHECK(state() == CompareICState::NUMBER);
   ASM_LOCATION("CompareICStub[HeapNumbers]");
 
   Label unordered, maybe_undefined1, maybe_undefined2;
   Label miss, handle_lhs, values_in_d_regs;
   Label untag_rhs, untag_lhs;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
-  FPRegister rhs_d = d0;
-  FPRegister lhs_d = d1;
+  VRegister rhs_d = d0;
+  VRegister lhs_d = d1;
 
   if (left() == CompareICState::SMI) {
     __ JumpIfNotSmi(lhs, &miss);
   }
   if (right() == CompareICState::SMI) {
     __ JumpIfNotSmi(rhs, &miss);
   }
 
   __ SmiUntagToDouble(rhs_d, rhs, kSpeculativeUntag);
   __ SmiUntagToDouble(lhs_d, lhs, kSpeculativeUntag);
@@ skipping 438 matching lines @@
   __ TailCallStub(&stub);
 }
 
 RecordWriteStub::RegisterAllocation::RegisterAllocation(Register object,
                                                         Register address,
                                                         Register scratch)
     : object_(object),
       address_(address),
       scratch0_(scratch),
       saved_regs_(kCallerSaved),
-      saved_fp_regs_(kCallerSavedFP) {
+      saved_fp_regs_(kCallerSavedV) {
   DCHECK(!AreAliased(scratch, object, address));
 
   // The SaveCallerSaveRegisters method needs to save caller-saved
   // registers, but we don't bother saving MacroAssembler scratch registers.
   saved_regs_.Remove(MacroAssembler::DefaultTmpList());
   saved_fp_regs_.Remove(MacroAssembler::DefaultFPTmpList());
 
   // We would like to require more scratch registers for this stub,
   // but the number of registers comes down to the ones used in
   // FullCodeGen::SetVar(), which is architecture independent.
@@ skipping 1107 matching lines @@
                            kStackUnwindSpace, NULL, spill_offset,
                            return_value_operand, NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64