PPC/s390: [turbofan] Avoid allocating rest parameters for spread calls.

src/builtins/ppc/builtins-ppc.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_PPC
 
 #include "src/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 2180 matching lines @@
 
   // Dispatch to Call or Construct depending on whether new.target is undefined.
   {
     __ CompareRoot(r6, 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) {
+void Builtins::Generate_ForwardVarargs(MacroAssembler* masm,
+                                       Handle<Code> code) {
   // ----------- S t a t e -------------
-  //  -- r4    : the target to call (can be any Object)
-  //  -- r5    : start index (to support rest parameters)
-  //  -- lr    : return address.
-  //  -- sp[0] : thisArgument
+  //  -- r3 : the number of arguments (not including the receiver)
+  //  -- r6 : the new.target (for [[Construct]] calls)
+  //  -- r4 : the target to call (can be any Object)
+  //  -- r5 : start index (to support rest parameters)
   // -----------------------------------
 
   // Check if we have an arguments adaptor frame below the function frame.
   Label arguments_adaptor, arguments_done;
-  __ LoadP(r6, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-  __ LoadP(ip, MemOperand(r6, CommonFrameConstants::kContextOrFrameTypeOffset));
+  __ LoadP(r7, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  __ LoadP(ip, MemOperand(r7, CommonFrameConstants::kContextOrFrameTypeOffset));
   __ cmpi(ip, Operand(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)));
   __ beq(&arguments_adaptor);
   {
-    __ LoadP(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
-    __ LoadP(r3, FieldMemOperand(r3, JSFunction::kSharedFunctionInfoOffset));
+    __ LoadP(r8, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+    __ LoadP(r8, FieldMemOperand(r8, JSFunction::kSharedFunctionInfoOffset));
     __ LoadWordArith(
-        r3,
-        FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset));
-    __ mr(r6, fp);
+        r8,
+        FieldMemOperand(r8, SharedFunctionInfo::kFormalParameterCountOffset));
+    __ mr(r7, fp);
   }
   __ b(&arguments_done);
   __ bind(&arguments_adaptor);
   {
     // Load the length from the ArgumentsAdaptorFrame.
-    __ LoadP(r3, MemOperand(r6, ArgumentsAdaptorFrameConstants::kLengthOffset));
+    __ LoadP(r8, MemOperand(r7, ArgumentsAdaptorFrameConstants::kLengthOffset));
 #if V8_TARGET_ARCH_PPC64
-    __ SmiUntag(r3);
+    __ SmiUntag(r8);
 #endif
   }
   __ bind(&arguments_done);
 
-  Label stack_empty, stack_done, stack_overflow;
+  Label stack_done, stack_overflow;
 #if !V8_TARGET_ARCH_PPC64
-  __ SmiUntag(r3);
+  __ SmiUntag(r8);
 #endif
-  __ sub(r3, r3, r5);
-  __ cmpi(r3, Operand::Zero());
-  __ ble(&stack_empty);
+  __ sub(r8, r8, r5);
+  __ cmpi(r8, Operand::Zero());
+  __ ble(&stack_done);
   {
     // Check for stack overflow.
-    Generate_StackOverflowCheck(masm, r3, r5, &stack_overflow);
+    Generate_StackOverflowCheck(masm, r8, r5, &stack_overflow);
 
     // Forward the arguments from the caller frame.
     {
       Label loop;
-      __ addi(r6, r6, Operand(kPointerSize));
-      __ mr(r5, r3);
+      __ addi(r7, r7, Operand(kPointerSize));
+      __ add(r3, r3, r8);
       __ bind(&loop);
       {
-        __ ShiftLeftImm(ip, r5, Operand(kPointerSizeLog2));
-        __ LoadPX(ip, MemOperand(r6, ip));
+        __ ShiftLeftImm(ip, r8, Operand(kPointerSizeLog2));
+        __ LoadPX(ip, MemOperand(r7, ip));
         __ push(ip);
-        __ subi(r5, r5, Operand(1));
-        __ cmpi(r5, Operand::Zero());
+        __ subi(r8, r8, Operand(1));
+        __ cmpi(r8, Operand::Zero());
         __ 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(r3, Operand::Zero());
-  }
   __ bind(&stack_done);
 
+  // Tail-call to the {code} handler.
   __ 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
 //
@@ skipping 853 matching lines @@
   }
   // Now jump to the instructions of the returned code object.
   __ Jump(r11);
 }
 
 #undef __
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_PPC