[runtime] TailCallRuntime and CallRuntime should use default argument counts

src/arm64/code-stubs-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/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
 #include "src/ic/handler-compiler.h"
@@ skipping 635 matching lines @@
   // Never fall through to here.
   if (FLAG_debug_code) {
     __ Unreachable();
   }
 
   __ Bind(&slow);
 
   __ Push(lhs, rhs);
   // Figure out which native to call and setup the arguments.
   if (cond == eq) {
-    __ TailCallRuntime(strict() ? Runtime::kStrictEquals : Runtime::kEquals, 2);
+    __ TailCallRuntime(strict() ? Runtime::kStrictEquals : Runtime::kEquals);
   } else {
     int ncr;  // NaN compare result
     if ((cond == lt) || (cond == le)) {
       ncr = GREATER;
     } else {
       DCHECK((cond == gt) || (cond == ge));  // remaining cases
       ncr = LESS;
     }
     __ Mov(x10, Smi::FromInt(ncr));
     __ Push(x10);
 
     // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
     // tagged as a small integer.
-    __ TailCallRuntime(
-        is_strong(strength()) ? Runtime::kCompare_Strong : Runtime::kCompare,
-        3);
+    __ TailCallRuntime(is_strong(strength()) ? Runtime::kCompare_Strong
+                                             : Runtime::kCompare);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
   CPURegList saved_regs = kCallerSaved;
   CPURegList saved_fp_regs = kCallerSavedFP;
@@ skipping 275 matching lines @@
   // catch this corner-case, we bail out if the result was 0. (This can only
   // occur if the divisor is infinity or the base is zero.)
   __ Fcmp(result_double, 0.0);
   __ B(&done, ne);
 
   if (exponent_type() == ON_STACK) {
     // Bail out to runtime code.
     __ Bind(&call_runtime);
     // Put the arguments back on the stack.
     __ Push(base_tagged, exponent_tagged);
-    __ TailCallRuntime(Runtime::kMathPowRT, 2);
+    __ TailCallRuntime(Runtime::kMathPowRT);
 
     // Return.
     __ Bind(&done);
     __ AllocateHeapNumber(result_tagged, &call_runtime, scratch0, scratch1,
                           result_double);
     DCHECK(result_tagged.is(x0));
     __ IncrementCounter(
         isolate()->counters()->math_pow(), 1, scratch0, scratch1);
     __ Ret();
   } else {
@@ skipping 622 matching lines @@
   __ Bind(&done);
   __ StoreRoot(result, Heap::kInstanceofCacheAnswerRootIndex);
   __ Ret();
 
   // Found Proxy or access check needed: Call the runtime
   __ Bind(&fast_runtime_fallback);
   __ Push(object, function_prototype);
   // Invalidate the instanceof cache.
   __ Move(scratch, Smi::FromInt(0));
   __ StoreRoot(scratch, Heap::kInstanceofCacheFunctionRootIndex);
-  __ TailCallRuntime(Runtime::kHasInPrototypeChain, 2);
+  __ TailCallRuntime(Runtime::kHasInPrototypeChain);
 
   // Slow-case: Call the %InstanceOf runtime function.
   __ bind(&slow_case);
   __ Push(object, function);
-  __ TailCallRuntime(Runtime::kInstanceOf, 2);
+  __ TailCallRuntime(Runtime::kInstanceOf);
 }
 
 
 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
   Register arg_count = ArgumentsAccessReadDescriptor::parameter_count();
   Register key = ArgumentsAccessReadDescriptor::index();
   DCHECK(arg_count.is(x0));
   DCHECK(key.is(x1));
 
   // The displacement is the offset of the last parameter (if any) relative
@@ skipping 30 matching lines @@
   // Read the argument from the stack and return it.
   __ Sub(x10, arg_count, key);
   __ Add(x10, local_fp, Operand::UntagSmiAndScale(x10, kPointerSizeLog2));
   __ Ldr(x0, MemOperand(x10, kDisplacement));
   __ Ret();
 
   // Slow case: handle non-smi or out-of-bounds access to arguments by calling
   // the runtime system.
   __ Bind(&slow);
   __ Push(key);
-  __ TailCallRuntime(Runtime::kArguments, 1);
+  __ TailCallRuntime(Runtime::kArguments);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppySlow(MacroAssembler* masm) {
   // x1 : function
   // x2 : number of parameters (tagged)
   // x3 : parameters pointer
 
   DCHECK(x1.is(ArgumentsAccessNewDescriptor::function()));
   DCHECK(x2.is(ArgumentsAccessNewDescriptor::parameter_count()));
@@ skipping 10 matching lines @@
   __ B(ne, &runtime);
 
   // Patch the arguments.length and parameters pointer in the current frame.
   __ Ldr(x2,
          MemOperand(caller_fp, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ Add(x3, caller_fp, Operand::UntagSmiAndScale(x2, kPointerSizeLog2));
   __ Add(x3, x3, StandardFrameConstants::kCallerSPOffset);
 
   __ Bind(&runtime);
   __ Push(x1, x3, x2);
-  __ TailCallRuntime(Runtime::kNewSloppyArguments, 3);
+  __ TailCallRuntime(Runtime::kNewSloppyArguments);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppyFast(MacroAssembler* masm) {
   // x1 : function
   // x2 : number of parameters (tagged)
   // x3 : parameters pointer
   //
   // Returns pointer to result object in x0.
 
@@ skipping 254 matching lines @@
 
   __ Bind(&arguments_test);
   __ Cmp(x10, arg_count);
   __ B(lt, &arguments_loop);
 
   __ Ret();
 
   // Do the runtime call to allocate the arguments object.
   __ Bind(&runtime);
   __ Push(function, recv_arg, arg_count_smi);
-  __ TailCallRuntime(Runtime::kNewSloppyArguments, 3);
+  __ TailCallRuntime(Runtime::kNewSloppyArguments);
 }
 
 
 void LoadIndexedInterceptorStub::Generate(MacroAssembler* masm) {
   // Return address is in lr.
   Label slow;
 
   Register receiver = LoadDescriptor::ReceiverRegister();
   Register key = LoadDescriptor::NameRegister();
 
   // Check that the key is an array index, that is Uint32.
   __ TestAndBranchIfAnySet(key, kSmiTagMask | kSmiSignMask, &slow);
 
   // Everything is fine, call runtime.
   __ Push(receiver, key);
-  __ TailCallRuntime(Runtime::kLoadElementWithInterceptor, 2);
+  __ TailCallRuntime(Runtime::kLoadElementWithInterceptor);
 
   __ Bind(&slow);
   PropertyAccessCompiler::TailCallBuiltin(
       masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
 }
 
 
 void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) {
   // x1 : function
   // x2 : number of parameters (tagged)
@@ skipping 111 matching lines @@
   __ Sub(param_count, param_count, 1);
   __ Cbnz(param_count, &loop);
 
   // Return from stub.
   __ Bind(&done);
   __ Ret();
 
   // Do the runtime call to allocate the arguments object.
   __ Bind(&runtime);
   __ Push(function, params, param_count_smi);
-  __ TailCallRuntime(Runtime::kNewStrictArguments, 3);
+  __ TailCallRuntime(Runtime::kNewStrictArguments);
 }
 
 
 void RestParamAccessStub::GenerateNew(MacroAssembler* masm) {
   // Stack layout on entry.
   //  jssp[0]:  language mode (tagged)
   //  jssp[8]:  index of rest parameter (tagged)
   //  jssp[16]: number of parameters (tagged)
   //  jssp[24]: address of receiver argument
   //
@@ skipping 28 matching lines @@
 
   // Patch the argument length and parameters pointer.
   __ Ldr(param_count_smi,
          MemOperand(caller_fp, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ SmiUntag(param_count, param_count_smi);
   __ Add(x10, caller_fp, Operand(param_count, LSL, kPointerSizeLog2));
   __ Add(params, x10, StandardFrameConstants::kCallerSPOffset);
 
   __ Bind(&runtime);
   __ Push(params, param_count_smi, rest_index_smi, language_mode_smi);
-  __ TailCallRuntime(Runtime::kNewRestParam, 4);
+  __ TailCallRuntime(Runtime::kNewRestParam);
 }
 
 
 void RegExpExecStub::Generate(MacroAssembler* masm) {
 #ifdef V8_INTERPRETED_REGEXP
-  __ TailCallRuntime(Runtime::kRegExpExec, 4);
+  __ TailCallRuntime(Runtime::kRegExpExec);
 #else  // V8_INTERPRETED_REGEXP
 
   // Stack frame on entry.
   //  jssp[0]: last_match_info (expected JSArray)
   //  jssp[8]: previous index
   //  jssp[16]: subject string
   //  jssp[24]: JSRegExp object
   Label runtime;
 
   // Use of registers for this function.
@@ skipping 420 matching lines @@
   // If there is no pending exception, handle that in the runtime system.
   __ Mov(x10, Operand(isolate()->factory()->the_hole_value()));
   __ Mov(x11,
          Operand(ExternalReference(Isolate::kPendingExceptionAddress,
                                    isolate())));
   __ Ldr(exception_value, MemOperand(x11));
   __ Cmp(x10, exception_value);
   __ B(eq, &runtime);
 
   // For exception, throw the exception again.
-  __ TailCallRuntime(Runtime::kRegExpExecReThrow, 4);
+  __ TailCallRuntime(Runtime::kRegExpExecReThrow);
 
   __ Bind(&failure);
   __ Mov(x0, Operand(isolate()->factory()->null_value()));
   // Drop the 4 arguments of the stub from the stack.
   __ Drop(4);
   __ Ret();
 
   __ Bind(&runtime);
-  __ TailCallRuntime(Runtime::kRegExpExec, 4);
+  __ TailCallRuntime(Runtime::kRegExpExec);
 
   // Deferred code for string handling.
   // (6) Not a long external string?  If yes, go to (8).
   __ Bind(&not_seq_nor_cons);
   // Compare flags are still set.
   __ B(ne, &not_long_external);  // Go to (8).
 
   // (7) External string. Make it, offset-wise, look like a sequential string.
   __ Bind(&external_string);
   if (masm->emit_debug_code()) {
@@ skipping 371 matching lines @@
 
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   ASM_LOCATION("CallICStub[Miss]");
 
   FrameScope scope(masm, StackFrame::INTERNAL);
 
   // Push the receiver and the function and feedback info.
   __ Push(x1, x2, x3);
 
   // Call the entry.
-  __ CallRuntime(Runtime::kCallIC_Miss, 3);
+  __ CallRuntime(Runtime::kCallIC_Miss);
 
   // Move result to edi and exit the internal frame.
   __ Mov(x1, x0);
 }
 
 
 void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
   // If the receiver is a smi trigger the non-string case.
   if (check_mode_ == RECEIVER_IS_UNKNOWN) {
     __ JumpIfSmi(object_, receiver_not_string_);
@@ skipping 37 matching lines @@
   __ JumpIfNotHeapNumber(index_, index_not_number_);
   call_helper.BeforeCall(masm);
   if (embed_mode == PART_OF_IC_HANDLER) {
     __ Push(LoadWithVectorDescriptor::VectorRegister(),
             LoadWithVectorDescriptor::SlotRegister(), object_, index_);
   } else {
     // Save object_ on the stack and pass index_ as argument for runtime call.
     __ Push(object_, index_);
   }
   if (index_flags_ == STRING_INDEX_IS_NUMBER) {
-    __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
+    __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero);
   } else {
     DCHECK(index_flags_ == STRING_INDEX_IS_ARRAY_INDEX);
     // NumberToSmi discards numbers that are not exact integers.
-    __ CallRuntime(Runtime::kNumberToSmi, 1);
+    __ CallRuntime(Runtime::kNumberToSmi);
   }
   // Save the conversion result before the pop instructions below
   // have a chance to overwrite it.
   __ Mov(index_, x0);
   if (embed_mode == PART_OF_IC_HANDLER) {
     __ Pop(object_, LoadWithVectorDescriptor::SlotRegister(),
            LoadWithVectorDescriptor::VectorRegister());
   } else {
     __ Pop(object_);
   }
   // Reload the instance type.
   __ Ldr(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
   __ Ldrb(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
   call_helper.AfterCall(masm);
 
   // If index is still not a smi, it must be out of range.
   __ JumpIfNotSmi(index_, index_out_of_range_);
   // Otherwise, return to the fast path.
   __ B(&got_smi_index_);
 
   // Call runtime. We get here when the receiver is a string and the
   // index is a number, but the code of getting the actual character
   // is too complex (e.g., when the string needs to be flattened).
   __ Bind(&call_runtime_);
   call_helper.BeforeCall(masm);
   __ SmiTag(index_);
   __ Push(object_, index_);
-  __ CallRuntime(Runtime::kStringCharCodeAtRT, 2);
+  __ CallRuntime(Runtime::kStringCharCodeAtRT);
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 
 void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
   __ JumpIfNotSmi(code_, &slow_case_);
@@ skipping 10 matching lines @@
 
 
 void StringCharFromCodeGenerator::GenerateSlow(
     MacroAssembler* masm,
     const RuntimeCallHelper& call_helper) {
   __ Abort(kUnexpectedFallthroughToCharFromCodeSlowCase);
 
   __ Bind(&slow_case_);
   call_helper.BeforeCall(masm);
   __ Push(code_);
-  __ CallRuntime(Runtime::kStringCharFromCode, 1);
+  __ CallRuntime(Runtime::kStringCharFromCode);
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
 void CompareICStub::GenerateBooleans(MacroAssembler* masm) {
   // Inputs are in x0 (lhs) and x1 (rhs).
   DCHECK_EQ(CompareICState::BOOLEAN, state());
   ASM_LOCATION("CompareICStub[Booleans]");
   Label miss;
 
   __ CheckMap(x1, x2, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
   __ CheckMap(x0, x3, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
   if (op() != Token::EQ_STRICT && is_strong(strength())) {
-    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion, 0);
+    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion);
   } else {
     if (!Token::IsEqualityOp(op())) {
       __ Ldr(x1, FieldMemOperand(x1, Oddball::kToNumberOffset));
       __ AssertSmi(x1);
       __ Ldr(x0, FieldMemOperand(x0, Oddball::kToNumberOffset));
       __ AssertSmi(x0);
     }
     __ Sub(x0, x1, x0);
     __ Ret();
   }
@@ skipping 233 matching lines @@
                                                   x12);
   } else {
     StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, x10, x11,
                                                     x12, x13);
   }
 
   // Handle more complex cases in runtime.
   __ Bind(&runtime);
   __ Push(lhs, rhs);
   if (equality) {
-    __ TailCallRuntime(Runtime::kStringEquals, 2);
+    __ TailCallRuntime(Runtime::kStringEquals);
   } else {
-    __ TailCallRuntime(Runtime::kStringCompare, 2);
+    __ TailCallRuntime(Runtime::kStringCompare);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void CompareICStub::GenerateReceivers(MacroAssembler* masm) {
   DCHECK_EQ(CompareICState::RECEIVER, state());
   ASM_LOCATION("CompareICStub[Receivers]");
@@ skipping 39 matching lines @@
   __ Ldr(lhs_map, FieldMemOperand(lhs, HeapObject::kMapOffset));
   __ Cmp(rhs_map, map);
   __ B(ne, &miss);
   __ Cmp(lhs_map, map);
   __ B(ne, &miss);
 
   if (Token::IsEqualityOp(op())) {
   __ Sub(result, rhs, lhs);
   __ Ret();
   } else if (is_strong(strength())) {
-    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion, 0);
+    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion);
   } else {
     Register ncr = x2;
     if (op() == Token::LT || op() == Token::LTE) {
       __ Mov(ncr, Smi::FromInt(GREATER));
     } else {
       __ Mov(ncr, Smi::FromInt(LESS));
     }
     __ Push(lhs, rhs, ncr);
-    __ TailCallRuntime(Runtime::kCompare, 3);
+    __ TailCallRuntime(Runtime::kCompare);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 // This method handles the case where a compare stub had the wrong
 // implementation. It calls a miss handler, which re-writes the stub. All other
 // CompareICStub::Generate* methods should fall back into this one if their
 // operands were not the expected types.
 void CompareICStub::GenerateMiss(MacroAssembler* masm) {
   ASM_LOCATION("CompareICStub[Miss]");
 
   Register stub_entry = x11;
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     Register op = x10;
     Register left = x1;
     Register right = x0;
     // Preserve some caller-saved registers.
     __ Push(x1, x0, lr);
     // Push the arguments.
     __ Mov(op, Smi::FromInt(this->op()));
     __ Push(left, right, op);
 
     // Call the miss handler. This also pops the arguments.
-    __ CallRuntime(Runtime::kCompareIC_Miss, 3);
+    __ CallRuntime(Runtime::kCompareIC_Miss);
 
     // Compute the entry point of the rewritten stub.
     __ Add(stub_entry, x0, Code::kHeaderSize - kHeapObjectTag);
     // Restore caller-saved registers.
     __ Pop(lr, x0, x1);
   }
 
   // Tail-call to the new stub.
   __ Jump(stub_entry);
 }
@@ skipping 225 matching lines @@
   __ Add(result_length, result_length, result_length);
   __ CopyBytes(result_char0, substring_char0, result_length, x3, kCopyLong);
 
   __ Bind(&return_x0);
   Counters* counters = isolate()->counters();
   __ IncrementCounter(counters->sub_string_native(), 1, x3, x4);
   __ Drop(3);
   __ Ret();
 
   __ Bind(&runtime);
-  __ TailCallRuntime(Runtime::kSubString, 3);
+  __ TailCallRuntime(Runtime::kSubString);
 
   __ bind(&single_char);
   // x1: result_length
   // x10: input_string
   // x12: input_type
   // x15: from (untagged)
   __ SmiTag(from);
   StringCharAtGenerator generator(input_string, from, result_length, x0,
                                   &runtime, &runtime, &runtime,
                                   STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
@@ skipping 25 matching lines @@
   __ Cmp(x1, FIRST_NONSTRING_TYPE);
   __ B(hs, &not_string);
   // Check if string has a cached array index.
   __ Ldr(x2, FieldMemOperand(x0, String::kHashFieldOffset));
   __ Tst(x2, Operand(String::kContainsCachedArrayIndexMask));
   __ B(ne, &slow_string);
   __ IndexFromHash(x2, x0);
   __ Ret();
   __ Bind(&slow_string);
   __ Push(x0);  // Push argument.
-  __ TailCallRuntime(Runtime::kStringToNumber, 1);
+  __ TailCallRuntime(Runtime::kStringToNumber);
   __ Bind(&not_string);
 
   Label not_oddball;
   __ Cmp(x1, ODDBALL_TYPE);
   __ B(ne, &not_oddball);
   __ Ldr(x0, FieldMemOperand(x0, Oddball::kToNumberOffset));
   __ Ret();
   __ Bind(&not_oddball);
 
   __ Push(x0);  // Push argument.
-  __ TailCallRuntime(Runtime::kToNumber, 1);
+  __ TailCallRuntime(Runtime::kToNumber);
 }
 
 
 void ToLengthStub::Generate(MacroAssembler* masm) {
   // The ToLength stub takes one argument in x0.
   Label not_smi;
   __ JumpIfNotSmi(x0, &not_smi);
   STATIC_ASSERT(kSmiTag == 0);
   __ Tst(x0, x0);
   __ Csel(x0, x0, Operand(0), ge);
   __ Ret();
   __ Bind(&not_smi);
 
   __ Push(x0);  // Push argument.
-  __ TailCallRuntime(Runtime::kToLength, 1);
+  __ TailCallRuntime(Runtime::kToLength);
 }
 
 
 void ToStringStub::Generate(MacroAssembler* masm) {
   // The ToString stub takes one argument in x0.
   Label is_number;
   __ JumpIfSmi(x0, &is_number);
 
   Label not_string;
   __ JumpIfObjectType(x0, x1, x1, FIRST_NONSTRING_TYPE, &not_string, hs);
@@ skipping 11 matching lines @@
   __ Bind(&not_heap_number);
 
   Label not_oddball;
   __ Cmp(x1, ODDBALL_TYPE);
   __ B(ne, &not_oddball);
   __ Ldr(x0, FieldMemOperand(x0, Oddball::kToStringOffset));
   __ Ret();
   __ Bind(&not_oddball);
 
   __ Push(x0);  // Push argument.
-  __ TailCallRuntime(Runtime::kToString, 1);
+  __ TailCallRuntime(Runtime::kToString);
 }
 
 
 void StringHelper::GenerateFlatOneByteStringEquals(
     MacroAssembler* masm, Register left, Register right, Register scratch1,
     Register scratch2, Register scratch3) {
   DCHECK(!AreAliased(left, right, scratch1, scratch2, scratch3));
   Register result = x0;
   Register left_length = scratch1;
   Register right_length = scratch2;
@@ skipping 123 matching lines @@
   // Compare flat one-byte strings natively.
   __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, x3,
                       x4);
   StringHelper::GenerateCompareFlatOneByteStrings(masm, x1, x0, x12, x13, x14,
                                                   x15);
 
   // Call the runtime.
   // Returns -1 (less), 0 (equal), or 1 (greater) tagged as a small integer.
   __ Bind(&runtime);
   __ Push(x1, x0);
-  __ TailCallRuntime(Runtime::kStringCompare, 2);
+  __ TailCallRuntime(Runtime::kStringCompare);
 }
 
 
 void BinaryOpICWithAllocationSiteStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x1    : left
   //  -- x0    : right
   //  -- lr    : return address
   // -----------------------------------
 
@@ skipping 1348 matching lines @@
   __ Ldr(result, FieldMemOperand(result, PropertyCell::kValueOffset));
 
   // If the result is not the_hole, return. Otherwise, handle in the runtime.
   __ JumpIfRoot(result, Heap::kTheHoleValueRootIndex, &slow_case);
   __ Ret();
 
   // Fallback to runtime.
   __ Bind(&slow_case);
   __ SmiTag(slot);
   __ Push(slot);
-  __ TailCallRuntime(Runtime::kLoadGlobalViaContext, 1);
+  __ TailCallRuntime(Runtime::kLoadGlobalViaContext);
 }
 
 
 void StoreGlobalViaContextStub::Generate(MacroAssembler* masm) {
   Register context = cp;
   Register value = x0;
   Register slot = x2;
   Register context_temp = x10;
   Register cell = x10;
   Register cell_details = x11;
@@ skipping 99 matching lines @@
   __ Ldr(value_map, FieldMemOperand(value, HeapObject::kMapOffset));
   __ Cmp(cell_value_map, value_map);
   __ B(eq, &fast_heapobject_case);
 
   // Fall back to the runtime.
   __ Bind(&slow_case);
   __ SmiTag(slot);
   __ Push(slot, value);
   __ TailCallRuntime(is_strict(language_mode())
                          ? Runtime::kStoreGlobalViaContext_Strict
-                         : Runtime::kStoreGlobalViaContext_Sloppy,
-                     2);
+                         : Runtime::kStoreGlobalViaContext_Sloppy);
 }
 
 
 // The number of register that CallApiFunctionAndReturn will need to save on
 // the stack. The space for these registers need to be allocated in the
 // ExitFrame before calling CallApiFunctionAndReturn.
 static const int kCallApiFunctionSpillSpace = 4;
 
 
 static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
@@ skipping 132 matching lines @@
 
   if (stack_space_operand != NULL) {
     __ Drop(x2, 1);
   } else {
     __ Drop(stack_space);
   }
   __ Ret();
 
   // Re-throw by promoting a scheduled exception.
   __ Bind(&promote_scheduled_exception);
-  __ TailCallRuntime(Runtime::kPromoteScheduledException, 0);
+  __ TailCallRuntime(Runtime::kPromoteScheduledException);
 
   // HandleScope limit has changed. Delete allocated extensions.
   __ Bind(&delete_allocated_handles);
   __ Str(limit_reg, MemOperand(handle_scope_base, kLimitOffset));
   // Save the return value in a callee-save register.
   Register saved_result = x19;
   __ Mov(saved_result, x0);
   __ Mov(x0, ExternalReference::isolate_address(isolate));
   __ CallCFunction(ExternalReference::delete_handle_scope_extensions(isolate),
                    1);
@@ skipping 180 matching lines @@
                            MemOperand(fp, 6 * kPointerSize), NULL);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64