[turbofan, arm64] Fix native stack parameters on arm64.

src/compiler/arm64/code-generator-arm64.cc

 // Copyright 2014 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/compiler/code-generator.h"
 
 #include "src/arm64/frames-arm64.h"
 #include "src/arm64/macro-assembler-arm64.h"
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
@@ skipping 859 matching lines @@
     case kArm64CompareAndBranch32:
       // Pseudo instruction turned into cbz/cbnz in AssembleArchBranch.
       break;
     case kArm64ClaimForCallArguments: {
       __ Claim(i.InputInt32(0));
       frame_access_state()->IncreaseSPDelta(i.InputInt32(0));
       break;
     }
     case kArm64Poke: {
       Operand operand(i.InputInt32(1) * kPointerSize);
-      __ Poke(i.InputRegister(0), operand);
+      if (instr->InputAt(0)->IsDoubleRegister()) {
+        __ Poke(i.InputFloat64Register(0), operand);
+      } else {
+        __ Poke(i.InputRegister(0), operand);
+      }
       break;
     }
     case kArm64PokePair: {
       int slot = i.InputInt32(2) - 1;
-      __ PokePair(i.InputRegister(1), i.InputRegister(0), slot * kPointerSize);
+      if (instr->InputAt(0)->IsDoubleRegister()) {
+        __ PokePair(i.InputFloat64Register(1), i.InputFloat64Register(0),

[jbramley, 2015/12/03 11:22:34]

Consider: DCHECK(instr->InputAt(1)->IsDoubleRegister());

Also, the reverse in the "else" case.

[ahaas, 2015/12/03 15:25:06]

I didn't add this DCHECK because i.InputFloat64Register(1) in the next line
crashes anyways if the DCHECK would fail. 

+                    slot * kPointerSize);
+      } else {
+        __ PokePair(i.InputRegister(1), i.InputRegister(0),
+                    slot * kPointerSize);
+      }
       break;
     }
     case kArm64Clz:
       __ Clz(i.OutputRegister64(), i.InputRegister64(0));
       break;
     case kArm64Clz32:
       __ Clz(i.OutputRegister32(), i.InputRegister32(0));
       break;
     case kArm64Cmp:
       __ Cmp(i.InputOrZeroRegister64(0), i.InputOperand(1));
@@ skipping 389 matching lines @@
   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
   if (descriptor->IsCFunctionCall()) {
     __ SetStackPointer(csp);
     __ Push(lr, fp);
     __ Mov(fp, csp);
   } else if (descriptor->IsJSFunctionCall()) {
     CompilationInfo* info = this->info();
     __ SetStackPointer(jssp);
     __ Prologue(info->IsCodePreAgingActive());
   } else if (frame()->needs_frame()) {
-    __ SetStackPointer(jssp);
+    if (descriptor->UseNativeStack()) {
+      __ SetStackPointer(csp);
+    } else {
+      __ SetStackPointer(jssp);
+    }
     __ StubPrologue();
   } else {
+    if (descriptor->UseNativeStack()) {
+      __ SetStackPointer(csp);

[jbramley, 2015/12/03 11:22:34]

Is it jssp by default? (I can't remember.) If it is jssp by default, then surely
we don't need to SetStackPointer(jssp) in the needs_frame() case above.

[titzer, 2015/12/03 11:31:59]

Actually, I think it's best to be explicit in both of these cases.

[ahaas, 2015/12/03 15:25:06]

Done, I made it explicit in both cases.

+    }
     frame()->SetElidedFrameSizeInSlots(0);
   }
   frame_access_state()->SetFrameAccessToDefault();
 
   int stack_shrink_slots = frame()->GetSpillSlotCount();
   if (info()->is_osr()) {
     // TurboFan OSR-compiled functions cannot be entered directly.
     __ Abort(kShouldNotDirectlyEnterOsrFunction);
 
     // Unoptimized code jumps directly to this entrypoint while the unoptimized
     // frame is still on the stack. Optimized code uses OSR values directly from
     // the unoptimized frame. Thus, all that needs to be done is to allocate the
     // remaining stack slots.
     if (FLAG_code_comments) __ RecordComment("-- OSR entrypoint --");
     osr_pc_offset_ = __ pc_offset();
     // TODO(titzer): cannot address target function == local #-1
     __ ldr(x1, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
     stack_shrink_slots -= OsrHelper(info()).UnoptimizedFrameSlots();
   }
 
-  if (csp.Is(masm()->StackPointer())) {
+  if (csp.Is(masm()->StackPointer()) && !descriptor->UseNativeStack()) {

[jbramley, 2015/12/03 11:22:34]

Why not for the UseNativeStack() case?

In particular, if csp is left without 16-byte alignment, subsequent stack
operations will fail. (The restriction is more severe than described in the
comment.)

[ahaas, 2015/12/03 15:25:06]

The additional condition is required because AlignSavedCalleeRegisterSlots sets
frame()->needs_frame() to true, which causes problems later in AssembleReturn.

I changed the condition to "if (csp.Is(masm()->StackPointer()) &&
frame()->needs_frame())" now. This is correct, because when
frame()->needs_frame() is false, then the call to AlignSavedCalleeRegisterSlots
is guaranteed to return 0.

     // The system stack pointer requires 16-byte alignment at function call
     // boundaries.
+
     stack_shrink_slots += frame()->AlignSavedCalleeRegisterSlots();
   }
   __ Claim(stack_shrink_slots);
 
   // Save FP registers.
   CPURegList saves_fp = CPURegList(CPURegister::kFPRegister, kDRegSizeInBits,
                                    descriptor->CalleeSavedFPRegisters());
   int saved_count = saves_fp.Count();
   if (saved_count != 0) {
     DCHECK(saves_fp.list() == CPURegList::GetCalleeSavedFP().list());
@@ skipping 36 matching lines @@
   if (descriptor->IsCFunctionCall()) {
     __ Mov(csp, fp);
     __ Pop(fp, lr);
   } else if (frame()->needs_frame()) {
     // Canonicalize JSFunction return sites for now.
     if (return_label_.is_bound()) {
       __ B(&return_label_);
       return;
     } else {
       __ Bind(&return_label_);
-      __ Mov(jssp, fp);
+      if (descriptor->UseNativeStack()) {
+        __ Mov(csp, fp);
+      } else {
+        __ Mov(jssp, fp);
+      }
       __ Pop(fp, lr);
     }
+  } else if (descriptor->UseNativeStack()) {
+    bool pop_count_uneven = pop_count & 1;
+    if (pop_count_uneven) {
+      pop_count++;
+    }

[jbramley, 2015/12/03 11:22:34]

Why not just "pop_count += (pop_count & 1)"?

[ahaas, 2015/12/03 15:25:06]

Done.

   }
   __ Drop(pop_count);
   __ Ret();
 }
 
 
 void CodeGenerator::AssembleMove(InstructionOperand* source,
                                  InstructionOperand* destination) {
   Arm64OperandConverter g(this, NULL);
   // Dispatch on the source and destination operand kinds.  Not all
@@ skipping 175 matching lines @@
       padding_size -= kInstructionSize;
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8