PPC/s390: [turbofan] Introduce JSCallForwardVarargs operator.

src/builtins/s390/builtins-s390.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.
 
 #if V8_TARGET_ARCH_S390
 
 #include "src/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 2297 matching lines @@
   }
 
   // Dispatch to Call or Construct depending on whether new.target is undefined.
   {
     __ CompareRoot(r5, Heap::kUndefinedValueRootIndex);
     __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET, eq);
     __ Jump(masm->isolate()->builtins()->Construct(), RelocInfo::CODE_TARGET);
   }
 }
 
+// static
+void Builtins::Generate_CallForwardVarargs(MacroAssembler* masm,
+                                           Handle<Code> code) {
+  // ----------- S t a t e -------------
+  //  -- r3    : the target to call (can be any Object)
+  //  -- r4    : start index (to support rest parameters)
+  //  -- lr    : return address.
+  //  -- sp[0] : thisArgument
+  // -----------------------------------
+
+  // Check if we have an arguments adaptor frame below the function frame.
+  Label arguments_adaptor, arguments_done;
+  __ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  __ LoadP(ip, MemOperand(r5, CommonFrameConstants::kContextOrFrameTypeOffset));
+  __ CmpSmiLiteral(ip, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);

[john.yan, 2017/04/26 16:48:19]

ip was pointer size (LoadP) here. Maybe try to use LoadSmiLiteral + CmpP here?

+  __ beq(&arguments_adaptor);
+  {
+    __ LoadP(r2, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+    __ LoadP(r2, FieldMemOperand(r2, JSFunction::kSharedFunctionInfoOffset));
+    __ LoadW(r2, FieldMemOperand(
+                     r2, SharedFunctionInfo::kFormalParameterCountOffset));
+    __ LoadRR(r5, fp);
+  }
+  __ b(&arguments_done);
+  __ bind(&arguments_adaptor);
+  {
+    // Load the length from the ArgumentsAdaptorFrame.
+    __ LoadP(r2, MemOperand(r5, ArgumentsAdaptorFrameConstants::kLengthOffset));
+  }
+  __ bind(&arguments_done);
+
+  Label stack_empty, stack_done, stack_overflow;
+  __ SmiUntag(r2);
+  __ SubP(r2, r2, r4);
+  __ CmpP(r2, Operand::Zero());

[john.yan, 2017/04/26 16:48:19]

CmpP isn't necessary here since SubP sets CC implicitly.

+  __ ble(&stack_empty);
+  {
+    // Check for stack overflow.
+    Generate_StackOverflowCheck(masm, r2, r4, &stack_overflow);
+
+    // Forward the arguments from the caller frame.
+    {
+      Label loop;
+      __ AddP(r5, r5, Operand(kPointerSize));
+      __ LoadRR(r4, r2);
+      __ bind(&loop);
+      {
+        __ ShiftLeftP(ip, r4, Operand(kPointerSizeLog2));
+        __ LoadP(ip, MemOperand(r5, ip));
+        __ push(ip);
+        __ SubP(r4, r4, Operand(1));
+        __ CmpP(r4, Operand::Zero());

[john.yan, 2017/04/26 16:48:19]

Same as above.

+        __ bne(&loop);
+      }
+    }
+  }
+  __ b(&stack_done);
+  __ bind(&stack_overflow);
+  __ TailCallRuntime(Runtime::kThrowStackOverflow);
+  __ bind(&stack_empty);
+  {
+    // We just pass the receiver, which is already on the stack.
+    __ mov(r2, Operand::Zero());
+  }
+  __ bind(&stack_done);
+
+  __ Jump(code, RelocInfo::CODE_TARGET);
+}
+
 namespace {
 
 // Drops top JavaScript frame and an arguments adaptor frame below it (if
 // present) preserving all the arguments prepared for current call.
 // Does nothing if debugger is currently active.
 // ES6 14.6.3. PrepareForTailCall
 //
 // Stack structure for the function g() tail calling f():
 //
 // ------- Caller frame: -------
@@ skipping 796 matching lines @@
     __ bkpt(0);
   }
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_S390