[runtime] TailCallRuntime and CallRuntime should use default argument counts

src/arm64/builtins-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/arm64/frames-arm64.h"
 #include "src/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
@@ skipping 171 matching lines @@
   __ Bind(&to_string);
   {
     ToStringStub stub(masm->isolate());
     __ TailCallStub(&stub);
   }
 
   // 3b. Convert symbol in x0 to a string.
   __ Bind(&symbol_descriptive_string);
   {
     __ Push(x0);
-    __ TailCallRuntime(Runtime::kSymbolDescriptiveString, 1);
+    __ TailCallRuntime(Runtime::kSymbolDescriptiveString);
   }
 }
 
 
 // static
 void Builtins::Generate_StringConstructor_ConstructStub(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x0                     : number of arguments
   //  -- x1                     : constructor function
   //  -- x3                     : new target
@@ skipping 60 matching lines @@
     __ Str(x2, FieldMemOperand(x0, JSValue::kValueOffset));
     STATIC_ASSERT(JSValue::kSize == 4 * kPointerSize);
     __ Ret();
   }
 
   // 5. Fallback to the runtime to create new object.
   __ bind(&new_object);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(x2, x1, x3);  // first argument, constructor, new target
-    __ CallRuntime(Runtime::kNewObject, 2);
+    __ CallRuntime(Runtime::kNewObject);
     __ Pop(x2);
   }
   __ Str(x2, FieldMemOperand(x0, JSValue::kValueOffset));
   __ Ret();
 }
 
 
 static void CallRuntimePassFunction(MacroAssembler* masm,
                                     Runtime::FunctionId function_id) {
   // ----------- S t a t e -------------
@@ skipping 180 matching lines @@
           // Fill the remaining fields with one pointer filler map.
           __ LoadRoot(filler, Heap::kOnePointerFillerMapRootIndex);
           __ InitializeFieldsWithFiller(write_address, next_obj, filler);
 
           __ Cmp(constructon_count, Operand(Map::kSlackTrackingCounterEnd));
           __ B(ne, &allocated);
 
           // Push the constructor, new_target and the object to the stack,
           // and then the initial map as an argument to the runtime call.
           __ Push(constructor, new_target, new_obj, init_map);
-          __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
+          __ CallRuntime(Runtime::kFinalizeInstanceSize);
           __ Pop(new_obj, new_target, constructor);
 
           // Continue with JSObject being successfully allocated.
           __ B(&allocated);
 
           __ bind(&no_inobject_slack_tracking);
         }
 
         __ InitializeFieldsWithFiller(write_address, next_obj, filler);
 
         // Continue with JSObject being successfully allocated.
         __ B(&allocated);
       }
 
       // Allocate the new receiver object using the runtime call.
       // x1: constructor function
       // x3: new target
       __ Bind(&rt_call);
 
       // Push the constructor and new_target twice, second pair as arguments
       // to the runtime call.
       __ Push(constructor, new_target, constructor, new_target);
-      __ CallRuntime(Runtime::kNewObject, 2);
+      __ CallRuntime(Runtime::kNewObject);
       __ Mov(x4, x0);
       __ Pop(new_target, constructor);
 
       // Receiver for constructor call allocated.
       // x1: constructor function
       // x3: new target
       // x4: JSObject
       __ Bind(&allocated);
 
       // Reload the number of arguments from the stack.
@@ skipping 122 matching lines @@
 
 
 void Builtins::Generate_JSBuiltinsConstructStub(MacroAssembler* masm) {
   Generate_JSConstructStubHelper(masm, false, false);
 }
 
 
 void Builtins::Generate_ConstructedNonConstructable(MacroAssembler* masm) {
   FrameScope scope(masm, StackFrame::INTERNAL);
   __ Push(x1);
-  __ CallRuntime(Runtime::kThrowConstructedNonConstructable, 1);
+  __ CallRuntime(Runtime::kThrowConstructedNonConstructable);
 }
 
 
 enum IsTagged { kArgcIsSmiTagged, kArgcIsUntaggedInt };
 
 
 // Clobbers x10, x15; preserves all other registers.
 static void Generate_CheckStackOverflow(MacroAssembler* masm, Register argc,
                                         IsTagged argc_is_tagged) {
   // Check the stack for overflow.
   // We are not trying to catch interruptions (e.g. debug break and
   // preemption) here, so the "real stack limit" is checked.
   Label enough_stack_space;
   __ LoadRoot(x10, Heap::kRealStackLimitRootIndex);
   // Make x10 the space we have left. The stack might already be overflowed
   // here which will cause x10 to become negative.
   // TODO(jbramley): Check that the stack usage here is safe.
   __ Sub(x10, jssp, x10);
   // Check if the arguments will overflow the stack.
   if (argc_is_tagged == kArgcIsSmiTagged) {
     __ Cmp(x10, Operand::UntagSmiAndScale(argc, kPointerSizeLog2));
   } else {
     DCHECK(argc_is_tagged == kArgcIsUntaggedInt);
     __ Cmp(x10, Operand(argc, LSL, kPointerSizeLog2));
   }
   __ B(gt, &enough_stack_space);
-  __ CallRuntime(Runtime::kThrowStackOverflow, 0);
+  __ CallRuntime(Runtime::kThrowStackOverflow);
   // We should never return from the APPLY_OVERFLOW builtin.
   if (__ emit_debug_code()) {
     __ Unreachable();
   }
 
   __ Bind(&enough_stack_space);
 }
 
 
 // Input:
@@ skipping 149 matching lines @@
     // Load frame size from the BytecodeArray object.
     __ Ldr(w11, FieldMemOperand(kInterpreterBytecodeArrayRegister,
                                 BytecodeArray::kFrameSizeOffset));
 
     // Do a stack check to ensure we don't go over the limit.
     Label ok;
     DCHECK(jssp.Is(__ StackPointer()));
     __ Sub(x10, jssp, Operand(x11));
     __ CompareRoot(x10, Heap::kRealStackLimitRootIndex);
     __ B(hs, &ok);
-    __ CallRuntime(Runtime::kThrowStackOverflow, 0);
+    __ CallRuntime(Runtime::kThrowStackOverflow);
     __ Bind(&ok);
 
     // If ok, push undefined as the initial value for all register file entries.
     // Note: there should always be at least one stack slot for the return
     // register in the register file.
     Label loop_header;
     __ LoadRoot(x10, Heap::kUndefinedValueRootIndex);
     // TODO(rmcilroy): Ensure we always have an even number of registers to
     // allow stack to be 16 bit aligned (and remove need for jssp).
     __ Lsr(x11, x11, kPointerSizeLog2);
     __ PushMultipleTimes(x10, x11);
     __ Bind(&loop_header);
   }
 
   // TODO(rmcilroy): List of things not currently dealt with here but done in
   // fullcodegen's prologue:
   //  - Support profiler (specifically profiling_counter).
   //  - Call ProfileEntryHookStub when isolate has a function_entry_hook.
   //  - Allow simulator stop operations if FLAG_stop_at is set.
   //  - Code aging of the BytecodeArray object.
 
   // Perform stack guard check.
   {
     Label ok;
     __ CompareRoot(jssp, Heap::kStackLimitRootIndex);
     __ B(hs, &ok);
     __ Push(kInterpreterBytecodeArrayRegister);
-    __ CallRuntime(Runtime::kStackGuard, 0);
+    __ CallRuntime(Runtime::kStackGuard);
     __ Pop(kInterpreterBytecodeArrayRegister);
     __ Bind(&ok);
   }
 
   // Load accumulator, register file, bytecode offset, dispatch table into
   // registers.
   __ LoadRoot(kInterpreterAccumulatorRegister, Heap::kUndefinedValueRootIndex);
   __ Add(kInterpreterRegisterFileRegister, fp,
          Operand(InterpreterFrameConstants::kRegisterFilePointerFromFp));
   __ Mov(kInterpreterBytecodeOffsetRegister,
@@ skipping 38 matching lines @@
 static void Generate_InterpreterNotifyDeoptimizedHelper(
     MacroAssembler* masm, Deoptimizer::BailoutType type) {
   // Enter an internal frame.
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(kInterpreterAccumulatorRegister);  // Save accumulator register.
 
     // Pass the deoptimization type to the runtime system.
     __ Mov(x1, Operand(Smi::FromInt(static_cast<int>(type))));
     __ Push(x1);
-    __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
+    __ CallRuntime(Runtime::kNotifyDeoptimized);
 
     __ Pop(kInterpreterAccumulatorRegister);  // Restore accumulator register.
     // Tear down internal frame.
   }
 
   // Drop state (we don't use these for interpreter deopts) and push PC at top
   // of stack (to simulate initial call to bytecode handler in interpreter entry
   // trampoline).
   __ Pop(x1);
   __ Drop(1);
@@ skipping 173 matching lines @@
     FrameScope scope(masm, StackFrame::INTERNAL);
 
     // Preserve registers across notification, this is important for compiled
     // stubs that tail call the runtime on deopts passing their parameters in
     // registers.
     // TODO(jbramley): Is it correct (and appropriate) to use safepoint
     // registers here? According to the comment above, we should only need to
     // preserve the registers with parameters.
     __ PushXRegList(kSafepointSavedRegisters);
     // Pass the function and deoptimization type to the runtime system.
-    __ CallRuntime(Runtime::kNotifyStubFailure, 0, save_doubles);
+    __ CallRuntime(Runtime::kNotifyStubFailure, save_doubles);
     __ PopXRegList(kSafepointSavedRegisters);
   }
 
   // Ignore state (pushed by Deoptimizer::EntryGenerator::Generate).
   __ Drop(1);
 
   // Jump to the miss handler. Deoptimizer::EntryGenerator::Generate loads this
   // into lr before it jumps here.
   __ Br(lr);
 }
 
 
 void Builtins::Generate_NotifyStubFailure(MacroAssembler* masm) {
   Generate_NotifyStubFailureHelper(masm, kDontSaveFPRegs);
 }
 
 
 void Builtins::Generate_NotifyStubFailureSaveDoubles(MacroAssembler* masm) {
   Generate_NotifyStubFailureHelper(masm, kSaveFPRegs);
 }
 
 
 static void Generate_NotifyDeoptimizedHelper(MacroAssembler* masm,
                                              Deoptimizer::BailoutType type) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     // Pass the deoptimization type to the runtime system.
     __ Mov(x0, Smi::FromInt(static_cast<int>(type)));
     __ Push(x0);
-    __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
+    __ CallRuntime(Runtime::kNotifyDeoptimized);
   }
 
   // Get the full codegen state from the stack and untag it.
   Register state = x6;
   __ Peek(state, 0);
   __ SmiUntag(state);
 
   // Switch on the state.
   Label with_tos_register, unknown_state;
   __ CompareAndBranch(
@@ skipping 136 matching lines @@
   __ Bind(&set_global_proxy);
   __ LoadGlobalProxy(x2);
   __ Str(x2, MemOperand(jssp, x0, LSL, kPointerSizeLog2));
   __ B(&valid_receiver);
 
   // Compatible receiver check failed: throw an Illegal Invocation exception.
   __ Bind(&receiver_check_failed);
   // Drop the arguments (including the receiver)
   __ add(x0, x0, Operand(1));
   __ Drop(x0);
-  __ TailCallRuntime(Runtime::kThrowIllegalInvocation, 0);
+  __ TailCallRuntime(Runtime::kThrowIllegalInvocation);
 }
 
 
 void Builtins::Generate_OnStackReplacement(MacroAssembler* masm) {
   // Lookup the function in the JavaScript frame.
   __ Ldr(x0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     // Pass function as argument.
     __ Push(x0);
-    __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
+    __ CallRuntime(Runtime::kCompileForOnStackReplacement);
   }
 
   // If the code object is null, just return to the unoptimized code.
   Label skip;
   __ CompareAndBranch(x0, Smi::FromInt(0), ne, &skip);
   __ Ret();
 
   __ Bind(&skip);
 
   // Load deoptimization data from the code object.
@@ skipping 15 matching lines @@
 }
 
 
 void Builtins::Generate_OsrAfterStackCheck(MacroAssembler* masm) {
   // We check the stack limit as indicator that recompilation might be done.
   Label ok;
   __ CompareRoot(jssp, Heap::kStackLimitRootIndex);
   __ B(hs, &ok);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
-    __ CallRuntime(Runtime::kStackGuard, 0);
+    __ CallRuntime(Runtime::kStackGuard);
   }
   __ Jump(masm->isolate()->builtins()->OnStackReplacement(),
           RelocInfo::CODE_TARGET);
 
   __ Bind(&ok);
   __ Ret();
 }
 
 
 // static
@@ skipping 54 matching lines @@
   __ Bind(&no_arguments);
   {
     __ Mov(x0, 0);
     __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
   }
 
   // 4c. The receiver is not callable, throw an appropriate TypeError.
   __ Bind(&receiver_not_callable);
   {
     __ Poke(x1, 0);
-    __ TailCallRuntime(Runtime::kThrowApplyNonFunction, 1);
+    __ TailCallRuntime(Runtime::kThrowApplyNonFunction);
   }
 }
 
 
 // static
 void Builtins::Generate_FunctionPrototypeCall(MacroAssembler* masm) {
   Register argc = x0;
   Register function = x1;
   Register scratch1 = x10;
   Register scratch2 = x11;
@@ skipping 86 matching lines @@
 
   // 3a. Apply the target to the given argumentsList (passing undefined for
   // new.target).
   __ LoadRoot(x3, Heap::kUndefinedValueRootIndex);
   __ Jump(masm->isolate()->builtins()->Apply(), RelocInfo::CODE_TARGET);
 
   // 3b. The target is not callable, throw an appropriate TypeError.
   __ Bind(&target_not_callable);
   {
     __ Poke(x1, 0);
-    __ TailCallRuntime(Runtime::kThrowApplyNonFunction, 1);
+    __ TailCallRuntime(Runtime::kThrowApplyNonFunction);
   }
 }
 
 
 void Builtins::Generate_ReflectConstruct(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x0     : argc
   //  -- sp[0]  : new.target (optional)
   //  -- sp[8]  : argumentsList
   //  -- sp[16] : target
@@ skipping 48 matching lines @@
   __ TestAndBranchIfAllClear(x4, 1 << Map::kIsConstructor,
                              &new_target_not_constructor);
 
   // 4a. Construct the target with the given new.target and argumentsList.
   __ Jump(masm->isolate()->builtins()->Apply(), RelocInfo::CODE_TARGET);
 
   // 4b. The target is not a constructor, throw an appropriate TypeError.
   __ Bind(&target_not_constructor);
   {
     __ Poke(x1, 0);
-    __ TailCallRuntime(Runtime::kThrowCalledNonCallable, 1);
+    __ TailCallRuntime(Runtime::kThrowCalledNonCallable);
   }
 
   // 4c. The new.target is not a constructor, throw an appropriate TypeError.
   __ Bind(&new_target_not_constructor);
   {
     __ Poke(x3, 0);
-    __ TailCallRuntime(Runtime::kThrowCalledNonCallable, 1);
+    __ TailCallRuntime(Runtime::kThrowCalledNonCallable);
   }
 }
 
 
 static void ArgumentAdaptorStackCheck(MacroAssembler* masm,
                                       Label* stack_overflow) {
   // ----------- S t a t e -------------
   //  -- x0 : actual number of arguments
   //  -- x1 : function (passed through to callee)
   //  -- x2 : expected number of arguments
@@ skipping 68 matching lines @@
 
     // Check if argumentsList is a fast JSArray.
     __ CompareInstanceType(x2, x4, JS_ARRAY_TYPE);
     __ B(eq, &create_array);
 
     // Ask the runtime to create the list (actually a FixedArray).
     __ Bind(&create_runtime);
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ Push(x1, x3, x0);
-      __ CallRuntime(Runtime::kCreateListFromArrayLike, 1);
+      __ CallRuntime(Runtime::kCreateListFromArrayLike);
       __ Pop(x3, x1);
       __ Ldrsw(x2, UntagSmiFieldMemOperand(x0, FixedArray::kLengthOffset));
     }
     __ B(&done_create);
 
     // Try to create the list from an arguments object.
     __ Bind(&create_arguments);
     __ Ldr(x2,
            FieldMemOperand(x0, JSObject::kHeaderSize +
                                    Heap::kArgumentsLengthIndex * kPointerSize));
@@ skipping 27 matching lines @@
     // Check the stack for overflow. We are not trying to catch interruptions
     // (i.e. debug break and preemption) here, so check the "real stack limit".
     Label done;
     __ LoadRoot(x10, Heap::kRealStackLimitRootIndex);
     // Make x10 the space we have left. The stack might already be overflowed
     // here which will cause x10 to become negative.
     __ Sub(x10, jssp, x10);
     // Check if the arguments will overflow the stack.
     __ Cmp(x10, Operand(x2, LSL, kPointerSizeLog2));
     __ B(gt, &done);  // Signed comparison.
-    __ TailCallRuntime(Runtime::kThrowStackOverflow, 1);
+    __ TailCallRuntime(Runtime::kThrowStackOverflow);
     __ Bind(&done);
   }
 
   // ----------- S t a t e -------------
   //  -- x1    : target
   //  -- x0    : args (a FixedArray built from argumentsList)
   //  -- x2    : len (number of elements to push from args)
   //  -- x3    : new.target (checked to be constructor or undefined)
   //  -- sp[0] : thisArgument
   // -----------------------------------
@@ skipping 117 matching lines @@
   ParameterCount actual(x0);
   ParameterCount expected(x2);
   __ InvokeFunctionCode(x1, no_reg, expected, actual, JUMP_FUNCTION,
                         CheckDebugStepCallWrapper());
 
   // The function is a "classConstructor", need to raise an exception.
   __ bind(&class_constructor);
   {
     FrameScope frame(masm, StackFrame::INTERNAL);
     __ Push(x1);
-    __ CallRuntime(Runtime::kThrowConstructorNonCallableError, 1);
+    __ CallRuntime(Runtime::kThrowConstructorNonCallableError);
   }
 }
 
 
 namespace {
 
 void Generate_PushBoundArguments(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x0 : the number of arguments (not including the receiver)
   //  -- x1 : target (checked to be a JSBoundFunction)
@@ skipping 22 matching lines @@
       // Check the stack for overflow. We are not trying to catch interruptions
       // (i.e. debug break and preemption) here, so check the "real stack
       // limit".
       __ CompareRoot(jssp, Heap::kRealStackLimitRootIndex);
       __ B(gt, &done);  // Signed comparison.
       // Restore the stack pointer.
       __ Drop(x4);
       {
         FrameScope scope(masm, StackFrame::MANUAL);
         __ EnterFrame(StackFrame::INTERNAL);
-        __ CallRuntime(Runtime::kThrowStackOverflow, 0);
+        __ CallRuntime(Runtime::kThrowStackOverflow);
       }
       __ Bind(&done);
     }
 
     // Relocate arguments down the stack.
     {
       Label loop, done_loop;
       __ Mov(x5, 0);
       __ Bind(&loop);
       __ Cmp(x5, x0);
@@ skipping 91 matching lines @@
   __ LoadNativeContextSlot(Context::CALL_AS_FUNCTION_DELEGATE_INDEX, x1);
   __ Jump(masm->isolate()->builtins()->CallFunction(
               ConvertReceiverMode::kNotNullOrUndefined),
           RelocInfo::CODE_TARGET);
 
   // 3. Call to something that is not callable.
   __ bind(&non_callable);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(x1);
-    __ CallRuntime(Runtime::kThrowCalledNonCallable, 1);
+    __ CallRuntime(Runtime::kThrowCalledNonCallable);
   }
 }
 
 
 // static
 void Builtins::Generate_ConstructFunction(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x0 : the number of arguments (not including the receiver)
   //  -- x1 : the constructor to call (checked to be a JSFunction)
   //  -- x3 : the new target (checked to be a constructor)
@@ skipping 268 matching lines @@
     // What we really care about is the required number of arguments.
     DCHECK_EQ(kPointerSize, kInt64Size);
     __ Ldr(scratch2.W(),
            FieldMemOperand(scratch1, SharedFunctionInfo::kLengthOffset));
     __ Cmp(argc_actual, Operand(scratch2, LSR, 1));
     __ B(ge, &no_strong_error);
 
     {
       FrameScope frame(masm, StackFrame::MANUAL);
       EnterArgumentsAdaptorFrame(masm);
-      __ CallRuntime(Runtime::kThrowStrongModeTooFewArguments, 0);
+      __ CallRuntime(Runtime::kThrowStrongModeTooFewArguments);
     }
 
     __ Bind(&no_strong_error);
     EnterArgumentsAdaptorFrame(masm);
     ArgumentAdaptorStackCheck(masm, &stack_overflow);
 
     __ Lsl(scratch2, argc_expected, kPointerSizeLog2);
     __ Lsl(argc_actual, argc_actual, kPointerSizeLog2);
 
     // Adjust for fp, lr, and the receiver.
@@ skipping 53 matching lines @@
   __ Ret();
 
   // Call the entry point without adapting the arguments.
   __ Bind(&dont_adapt_arguments);
   __ Ldr(code_entry, FieldMemOperand(function, JSFunction::kCodeEntryOffset));
   __ Jump(code_entry);
 
   __ Bind(&stack_overflow);
   {
     FrameScope frame(masm, StackFrame::MANUAL);
-    __ CallRuntime(Runtime::kThrowStackOverflow, 0);
+    __ CallRuntime(Runtime::kThrowStackOverflow);
     __ Unreachable();
   }
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM