Revert "Reland "ARM64: Add NEON support""

src/crankshaft/arm64/lithium-codegen-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.
 
 #include "src/crankshaft/arm64/lithium-codegen-arm64.h"
 
 #include "src/arm64/frames-arm64.h"
 #include "src/arm64/macro-assembler-arm64-inl.h"
 #include "src/base/bits.h"
 #include "src/builtins/builtins-constructor.h"
@@ skipping 161 matching lines @@
  private:
   Condition cond_;
   const Register& value_;
   uint64_t mask_;
 };
 
 
 // Test the input and branch if it is non-zero and not a NaN.
 class BranchIfNonZeroNumber : public BranchGenerator {
  public:
-  BranchIfNonZeroNumber(LCodeGen* codegen, const VRegister& value,
-                        const VRegister& scratch)
-      : BranchGenerator(codegen), value_(value), scratch_(scratch) {}
+  BranchIfNonZeroNumber(LCodeGen* codegen, const FPRegister& value,
+                        const FPRegister& scratch)
+    : BranchGenerator(codegen), value_(value), scratch_(scratch) { }
 
   virtual void Emit(Label* label) const {
     __ Fabs(scratch_, value_);
     // Compare with 0.0. Because scratch_ is positive, the result can be one of
     // nZCv (equal), nzCv (greater) or nzCV (unordered).
     __ Fcmp(scratch_, 0.0);
     __ B(gt, label);
   }
 
   virtual void EmitInverted(Label* label) const {
     __ Fabs(scratch_, value_);
     __ Fcmp(scratch_, 0.0);
     __ B(le, label);
   }
 
  private:
-  const VRegister& value_;
-  const VRegister& scratch_;
+  const FPRegister& value_;
+  const FPRegister& scratch_;
 };
 
 
 // Test the input and branch if it is a heap number.
 class BranchIfHeapNumber : public BranchGenerator {
  public:
   BranchIfHeapNumber(LCodeGen* codegen, const Register& value)
       : BranchGenerator(codegen), value_(value) { }
 
   virtual void Emit(Label* label) const {
@@ skipping 327 matching lines @@
 void LCodeGen::SaveCallerDoubles() {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Save clobbered callee double registers");
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator iterator(doubles);
   int count = 0;
   while (!iterator.Done()) {
     // TODO(all): Is this supposed to save just the callee-saved doubles? It
     // looks like it's saving all of them.
-    VRegister value = VRegister::from_code(iterator.Current());
+    FPRegister value = FPRegister::from_code(iterator.Current());
     __ Poke(value, count * kDoubleSize);
     iterator.Advance();
     count++;
   }
 }
 
 
 void LCodeGen::RestoreCallerDoubles() {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Restore clobbered callee double registers");
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator iterator(doubles);
   int count = 0;
   while (!iterator.Done()) {
     // TODO(all): Is this supposed to restore just the callee-saved doubles? It
     // looks like it's restoring all of them.
-    VRegister value = VRegister::from_code(iterator.Current());
+    FPRegister value = FPRegister::from_code(iterator.Current());
     __ Peek(value, count * kDoubleSize);
     iterator.Advance();
     count++;
   }
 }
 
 
 bool LCodeGen::GeneratePrologue() {
   DCHECK(is_generating());
 
@@ skipping 549 matching lines @@
     //   references the end of the double registers and not the end of the stack
     //   slots.
     // In both of the cases above, we _could_ add the tracking information
     // required so that we can use jssp here, but in practice it isn't worth it.
     if ((stack_mode == kCanUseStackPointer) &&
         !info()->saves_caller_doubles()) {
       int jssp_offset_to_fp =
           (pushed_arguments_ + GetTotalFrameSlotCount()) * kPointerSize -
           StandardFrameConstants::kFixedFrameSizeAboveFp;
       int jssp_offset = fp_offset + jssp_offset_to_fp;
-      if (masm()->IsImmLSScaled(jssp_offset, kPointerSizeLog2)) {
+      if (masm()->IsImmLSScaled(jssp_offset, LSDoubleWord)) {
         return MemOperand(masm()->StackPointer(), jssp_offset);
       }
     }
     return MemOperand(fp, fp_offset);
   } else {
     // Retrieve parameter without eager stack-frame relative to the
     // stack-pointer.
     return MemOperand(masm()->StackPointer(),
                       ArgumentsOffsetWithoutFrame(op->index()));
   }
@@ skipping 118 matching lines @@
 template<class InstrType>
 void LCodeGen::EmitTestAndBranch(InstrType instr,
                                  Condition condition,
                                  const Register& value,
                                  uint64_t mask) {
   DCHECK((condition != al) && (condition != nv));
   TestAndBranch branch(this, condition, value, mask);
   EmitBranchGeneric(instr, branch);
 }
 
-template <class InstrType>
+
+template<class InstrType>
 void LCodeGen::EmitBranchIfNonZeroNumber(InstrType instr,
-                                         const VRegister& value,
-                                         const VRegister& scratch) {
+                                         const FPRegister& value,
+                                         const FPRegister& scratch) {
   BranchIfNonZeroNumber branch(this, value, scratch);
   EmitBranchGeneric(instr, branch);
 }
 
 
 template<class InstrType>
 void LCodeGen::EmitBranchIfHeapNumber(InstrType instr,
                                       const Register& value) {
   BranchIfHeapNumber branch(this, value);
   EmitBranchGeneric(instr, branch);
@@ skipping 980 matching lines @@
   // The name in the constructor is internalized because of the way the context
   // is booted. This routine isn't expected to work for random API-created
   // classes and it doesn't have to because you can't access it with natives
   // syntax. Since both sides are internalized it is sufficient to use an
   // identity comparison.
   EmitCompareAndBranch(instr, eq, scratch1, Operand(class_name));
 }
 
 void LCodeGen::DoCmpHoleAndBranchD(LCmpHoleAndBranchD* instr) {
   DCHECK(instr->hydrogen()->representation().IsDouble());
-  VRegister object = ToDoubleRegister(instr->object());
+  FPRegister object = ToDoubleRegister(instr->object());
   Register temp = ToRegister(instr->temp());
 
   // If we don't have a NaN, we don't have the hole, so branch now to avoid the
   // (relatively expensive) hole-NaN check.
   __ Fcmp(object, object);
   __ B(vc, instr->FalseLabel(chunk_));
 
   // We have a NaN, but is it the hole?
   __ Fmov(temp, object);
   EmitCompareAndBranch(instr, eq, temp, kHoleNanInt64);
@@ skipping 976 matching lines @@
   Register object = ToRegister(instr->object());
 
   if (access.IsExternalMemory()) {
     Register result = ToRegister(instr->result());
     __ Load(result, MemOperand(object, offset), access.representation());
     return;
   }
 
   if (instr->hydrogen()->representation().IsDouble()) {
     DCHECK(access.IsInobject());
-    VRegister result = ToDoubleRegister(instr->result());
+    FPRegister result = ToDoubleRegister(instr->result());
     __ Ldr(result, FieldMemOperand(object, offset));
     return;
   }
 
   Register result = ToRegister(instr->result());
   Register source;
   if (access.IsInobject()) {
     source = object;
   } else {
     // Load the properties array, using result as a scratch register.
@@ skipping 139 matching lines @@
   // never get set by the negation. This is therefore the same as the Integer32
   // case in DoMathAbs, except that it operates on 64-bit values.
   STATIC_ASSERT((kSmiValueSize == 32) && (kSmiShift == 32) && (kSmiTag == 0));
 
   __ JumpIfNotSmi(input, deferred->entry());
 
   __ Abs(result, input, NULL, &done);
 
   // The result is the magnitude (abs) of the smallest value a smi can
   // represent, encoded as a double.
-  __ Mov(result_bits, bit_cast<uint64_t>(static_cast<double>(0x80000000)));
+  __ Mov(result_bits, double_to_rawbits(0x80000000));
   __ B(deferred->allocation_entry());
 
   __ Bind(deferred->exit());
   __ Str(result_bits, FieldMemOperand(result, HeapNumber::kValueOffset));
 
   __ Bind(&done);
 }
 
 void LCodeGen::DoMathCos(LMathCos* instr) {
   DCHECK(instr->IsMarkedAsCall());
@@ skipping 1521 matching lines @@
     __ Store(value, MemOperand(object, offset), representation);
     return;
   }
 
   __ AssertNotSmi(object);
 
   if (!FLAG_unbox_double_fields && representation.IsDouble()) {
     DCHECK(access.IsInobject());
     DCHECK(!instr->hydrogen()->has_transition());
     DCHECK(!instr->hydrogen()->NeedsWriteBarrier());
-    VRegister value = ToDoubleRegister(instr->value());
+    FPRegister value = ToDoubleRegister(instr->value());
     __ Str(value, FieldMemOperand(object, offset));
     return;
   }
 
   DCHECK(!representation.IsSmi() ||
          !instr->value()->IsConstantOperand() ||
          IsInteger32Constant(LConstantOperand::cast(instr->value())));
 
   if (instr->hydrogen()->has_transition()) {
     Handle<Map> transition = instr->hydrogen()->transition_map();
@@ skipping 17 matching lines @@
   if (access.IsInobject()) {
     destination = object;
   } else {
     Register temp0 = ToRegister(instr->temp0());
     __ Ldr(temp0, FieldMemOperand(object, JSObject::kPropertiesOffset));
     destination = temp0;
   }
 
   if (FLAG_unbox_double_fields && representation.IsDouble()) {
     DCHECK(access.IsInobject());
-    VRegister value = ToDoubleRegister(instr->value());
+    FPRegister value = ToDoubleRegister(instr->value());
     __ Str(value, FieldMemOperand(object, offset));
   } else if (representation.IsSmi() &&
              instr->hydrogen()->value()->representation().IsInteger32()) {
     DCHECK(instr->hydrogen()->store_mode() == STORE_TO_INITIALIZED_ENTRY);
 #ifdef DEBUG
     Register temp0 = ToRegister(instr->temp0());
     __ Ldr(temp0, FieldMemOperand(destination, offset));
     __ AssertSmi(temp0);
     // If destination aliased temp0, restore it to the address calculated
     // earlier.
@@ skipping 553 matching lines @@
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(deferred->exit());
   __ Bind(&done);
 }
 
 }  // namespace internal
 }  // namespace v8