[runtime] TailCallRuntime and CallRuntime should use default argument counts

src/arm/code-stubs-arm.cc

 // Copyright 2012 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_ARM
 
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
@@ skipping 664 matching lines @@
     StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, r2, r3, r4,
                                                     r5);
   }
   // Never falls through to here.
 
   __ bind(&slow);
 
   __ Push(lhs, rhs);
   // Figure out which native to call and setup the arguments.
   if (cc == eq) {
-    __ TailCallRuntime(strict() ? Runtime::kStrictEquals : Runtime::kEquals, 2);
+    __ TailCallRuntime(strict() ? Runtime::kStrictEquals : Runtime::kEquals);
   } else {
     int ncr;  // NaN compare result
     if (cc == lt || cc == le) {
       ncr = GREATER;
     } else {
       DCHECK(cc == gt || cc == ge);  // remaining cases
       ncr = LESS;
     }
     __ mov(r0, Operand(Smi::FromInt(ncr)));
     __ push(r0);
 
     // 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) {
   // We don't allow a GC during a store buffer overflow so there is no need to
   // store the registers in any particular way, but we do have to store and
@@ skipping 181 matching lines @@
   // double_exponent may not containe the exponent value if the input was a
   // smi.  We set it with exponent value before bailing out.
   __ vmov(single_scratch, exponent);
   __ vcvt_f64_s32(double_exponent, single_scratch);
 
   // Returning or bailing out.
   Counters* counters = isolate()->counters();
   if (exponent_type() == ON_STACK) {
     // The arguments are still on the stack.
     __ bind(&call_runtime);
-    __ TailCallRuntime(Runtime::kMathPowRT, 2);
+    __ TailCallRuntime(Runtime::kMathPowRT);
 
     // The stub is called from non-optimized code, which expects the result
     // as heap number in exponent.
     __ bind(&done);
     __ AllocateHeapNumber(
         heapnumber, scratch, scratch2, heapnumbermap, &call_runtime);
     __ vstr(double_result,
             FieldMemOperand(heapnumber, HeapNumber::kValueOffset));
     DCHECK(heapnumber.is(r0));
     __ IncrementCounter(counters->math_pow(), 1, scratch, scratch2);
@@ skipping 483 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 FunctionPrototypeStub::Generate(MacroAssembler* masm) {
   Label miss;
   Register receiver = LoadDescriptor::ReceiverRegister();
   // Ensure that the vector and slot registers won't be clobbered before
   // calling the miss handler.
   DCHECK(!AreAliased(r4, r5, LoadWithVectorDescriptor::VectorRegister(),
                      LoadWithVectorDescriptor::SlotRegister()));
@@ skipping 81 matching lines @@
   // Read the argument from the adaptor frame and return it.
   __ sub(r3, r0, r1);
   __ add(r3, r2, Operand::PointerOffsetFromSmiKey(r3));
   __ ldr(r0, MemOperand(r3, kDisplacement));
   __ Jump(lr);
 
   // Slow-case: Handle non-smi or out-of-bounds access to arguments
   // by calling the runtime system.
   __ bind(&slow);
   __ push(r1);
-  __ TailCallRuntime(Runtime::kArguments, 1);
+  __ TailCallRuntime(Runtime::kArguments);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppySlow(MacroAssembler* masm) {
   // r1 : function
   // r2 : number of parameters (tagged)
   // r3 : parameters pointer
 
   DCHECK(r1.is(ArgumentsAccessNewDescriptor::function()));
   DCHECK(r2.is(ArgumentsAccessNewDescriptor::parameter_count()));
   DCHECK(r3.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
 
   // Check if the calling frame is an arguments adaptor frame.
   Label runtime;
   __ ldr(r4, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ ldr(r0, MemOperand(r4, StandardFrameConstants::kContextOffset));
   __ cmp(r0, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
   __ b(ne, &runtime);
 
   // Patch the arguments.length and the parameters pointer in the current frame.
   __ ldr(r2, MemOperand(r4, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ add(r4, r4, Operand(r2, LSL, 1));
   __ add(r3, r4, Operand(StandardFrameConstants::kCallerSPOffset));
 
   __ bind(&runtime);
   __ Push(r1, r3, r2);
-  __ TailCallRuntime(Runtime::kNewSloppyArguments, 3);
+  __ TailCallRuntime(Runtime::kNewSloppyArguments);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppyFast(MacroAssembler* masm) {
   // r1 : function
   // r2 : number of parameters (tagged)
   // r3 : parameters pointer
   // Registers used over whole function:
   //  r5 : arguments count (tagged)
   //  r6 : mapped parameter count (tagged)
@@ skipping 179 matching lines @@
   __ b(lt, &arguments_loop);
 
   // Return.
   __ Ret();
 
   // Do the runtime call to allocate the arguments object.
   // r0 = address of new object (tagged)
   // r5 = argument count (tagged)
   __ bind(&runtime);
   __ Push(r1, r3, r5);
-  __ 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.
   __ NonNegativeSmiTst(key);
   __ b(ne, &slow);
 
   // Everything is fine, call runtime.
   __ Push(receiver, key);  // Receiver, key.
 
   // Perform tail call to the entry.
-  __ TailCallRuntime(Runtime::kLoadElementWithInterceptor, 2);
+  __ TailCallRuntime(Runtime::kLoadElementWithInterceptor);
 
   __ bind(&slow);
   PropertyAccessCompiler::TailCallBuiltin(
       masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
 }
 
 
 void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) {
   // r1 : function
   // r2 : number of parameters (tagged)
@@ skipping 72 matching lines @@
   __ cmp(r2, Operand::Zero());
   __ b(ne, &loop);
 
   // Return.
   __ bind(&done);
   __ Ret();
 
   // Do the runtime call to allocate the arguments object.
   __ bind(&runtime);
   __ Push(r1, r3, r2);
-  __ TailCallRuntime(Runtime::kNewStrictArguments, 3);
+  __ TailCallRuntime(Runtime::kNewStrictArguments);
 }
 
 
 void RestParamAccessStub::GenerateNew(MacroAssembler* masm) {
   // Stack layout on entry.
   //  sp[0] : language mode
   //  sp[4] : index of rest parameter
   //  sp[8] : number of parameters
   //  sp[12] : receiver displacement
 
   Label runtime;
   __ ldr(r2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ ldr(r3, MemOperand(r2, StandardFrameConstants::kContextOffset));
   __ cmp(r3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
   __ b(ne, &runtime);
 
   // Patch the arguments.length and the parameters pointer.
   __ ldr(r1, MemOperand(r2, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ str(r1, MemOperand(sp, 2 * kPointerSize));
   __ add(r3, r2, Operand::PointerOffsetFromSmiKey(r1));
   __ add(r3, r3, Operand(StandardFrameConstants::kCallerSPOffset));
   __ str(r3, MemOperand(sp, 3 * kPointerSize));
 
   __ bind(&runtime);
-  __ TailCallRuntime(Runtime::kNewRestParam, 4);
+  __ TailCallRuntime(Runtime::kNewRestParam);
 }
 
 
 void RegExpExecStub::Generate(MacroAssembler* masm) {
   // Just jump directly to runtime if native RegExp is not selected at compile
   // time or if regexp entry in generated code is turned off runtime switch or
   // at compilation.
 #ifdef V8_INTERPRETED_REGEXP
-  __ TailCallRuntime(Runtime::kRegExpExec, 4);
+  __ TailCallRuntime(Runtime::kRegExpExec);
 #else  // V8_INTERPRETED_REGEXP
 
   // Stack frame on entry.
   //  sp[0]: last_match_info (expected JSArray)
   //  sp[4]: previous index
   //  sp[8]: subject string
   //  sp[12]: JSRegExp object
 
   const int kLastMatchInfoOffset = 0 * kPointerSize;
   const int kPreviousIndexOffset = 1 * kPointerSize;
@@ skipping 250 matching lines @@
   // haven't created the exception yet. Handle that in the runtime system.
   // TODO(592): Rerunning the RegExp to get the stack overflow exception.
   __ mov(r1, Operand(isolate()->factory()->the_hole_value()));
   __ mov(r2, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
                                        isolate())));
   __ ldr(r0, MemOperand(r2, 0));
   __ cmp(r0, r1);
   __ b(eq, &runtime);
 
   // For exception, throw the exception again.
-  __ TailCallRuntime(Runtime::kRegExpExecReThrow, 4);
+  __ TailCallRuntime(Runtime::kRegExpExecReThrow);
 
   __ bind(&failure);
   // For failure and exception return null.
   __ mov(r0, Operand(isolate()->factory()->null_value()));
   __ add(sp, sp, Operand(4 * kPointerSize));
   __ Ret();
 
   // Process the result from the native regexp code.
   __ bind(&success);
   __ ldr(r1,
@@ skipping 74 matching lines @@
   __ jmp(&next_capture);
   __ bind(&done);
 
   // Return last match info.
   __ ldr(r0, MemOperand(sp, kLastMatchInfoOffset));
   __ add(sp, sp, Operand(4 * kPointerSize));
   __ Ret();
 
   // Do the runtime call to execute the regexp.
   __ 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(gt, &not_long_external);  // Go to (8).
 
   // (7) External string.  Make it, offset-wise, look like a sequential string.
   __ bind(&external_string);
   __ ldr(r0, FieldMemOperand(subject, HeapObject::kMapOffset));
@@ skipping 338 matching lines @@
 }
 
 
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
 
   // Push the receiver and the function and feedback info.
   __ Push(r1, r2, r3);
 
   // Call the entry.
-  __ CallRuntime(Runtime::kCallIC_Miss, 3);
+  __ CallRuntime(Runtime::kCallIC_Miss);
 
   // Move result to edi and exit the internal frame.
   __ mov(r1, r0);
 }
 
 
 // StringCharCodeAtGenerator
 void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
   // If the receiver is a smi trigger the non-string case.
   if (check_mode_ == RECEIVER_IS_UNKNOWN) {
@@ skipping 44 matching lines @@
               DONT_DO_SMI_CHECK);
   call_helper.BeforeCall(masm);
   if (embed_mode == PART_OF_IC_HANDLER) {
     __ Push(LoadWithVectorDescriptor::VectorRegister(),
             LoadWithVectorDescriptor::SlotRegister(), object_, index_);
   } else {
     // index_ is consumed by runtime conversion function.
     __ 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.
   __ Move(index_, r0);
   if (embed_mode == PART_OF_IC_HANDLER) {
     __ Pop(LoadWithVectorDescriptor::VectorRegister(),
            LoadWithVectorDescriptor::SlotRegister(), object_);
   } 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.
   __ jmp(&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);
   __ Move(result_, r0);
   call_helper.AfterCall(masm);
   __ jmp(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 
 // -------------------------------------------------------------------------
 // StringCharFromCodeGenerator
@@ skipping 18 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);
   __ Move(result_, r0);
   call_helper.AfterCall(masm);
   __ jmp(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
 enum CopyCharactersFlags { COPY_ONE_BYTE = 1, DEST_ALWAYS_ALIGNED = 2 };
 
@@ skipping 235 matching lines @@
       masm, r1, r5, r2, r3, String::TWO_BYTE_ENCODING);
 
   __ bind(&return_r0);
   Counters* counters = isolate()->counters();
   __ IncrementCounter(counters->sub_string_native(), 1, r3, r4);
   __ Drop(3);
   __ Ret();
 
   // Just jump to runtime to create the sub string.
   __ bind(&runtime);
-  __ TailCallRuntime(Runtime::kSubString, 3);
+  __ TailCallRuntime(Runtime::kSubString);
 
   __ bind(&single_char);
   // r0: original string
   // r1: instance type
   // r2: length
   // r3: from index (untagged)
   __ SmiTag(r3, r3);
   StringCharAtGenerator generator(r0, r3, r2, r0, &runtime, &runtime, &runtime,
                                   STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
   generator.GenerateFast(masm);
@@ skipping 19 matching lines @@
   __ cmp(r1, Operand(FIRST_NONSTRING_TYPE));
   __ b(hs, &not_string);
   // Check if string has a cached array index.
   __ ldr(r2, FieldMemOperand(r0, String::kHashFieldOffset));
   __ tst(r2, Operand(String::kContainsCachedArrayIndexMask));
   __ b(ne, &slow_string);
   __ IndexFromHash(r2, r0);
   __ Ret();
   __ bind(&slow_string);
   __ push(r0);  // Push argument.
-  __ TailCallRuntime(Runtime::kStringToNumber, 1);
+  __ TailCallRuntime(Runtime::kStringToNumber);
   __ bind(&not_string);
 
   Label not_oddball;
   __ cmp(r1, Operand(ODDBALL_TYPE));
   __ b(ne, &not_oddball);
   __ ldr(r0, FieldMemOperand(r0, Oddball::kToNumberOffset));
   __ Ret();
   __ bind(&not_oddball);
 
   __ push(r0);  // Push argument.
-  __ TailCallRuntime(Runtime::kToNumber, 1);
+  __ TailCallRuntime(Runtime::kToNumber);
 }
 
 
 void ToLengthStub::Generate(MacroAssembler* masm) {
   // The ToLength stub takes one argument in r0.
   Label not_smi;
   __ JumpIfNotSmi(r0, &not_smi);
   STATIC_ASSERT(kSmiTag == 0);
   __ tst(r0, r0);
   __ mov(r0, Operand(0), LeaveCC, lt);
   __ Ret();
   __ bind(&not_smi);
 
   __ push(r0);  // Push argument.
-  __ TailCallRuntime(Runtime::kToLength, 1);
+  __ TailCallRuntime(Runtime::kToLength);
 }
 
 
 void ToStringStub::Generate(MacroAssembler* masm) {
   // The ToString stub takes one argument in r0.
   Label is_number;
   __ JumpIfSmi(r0, &is_number);
 
   __ CompareObjectType(r0, r1, r1, FIRST_NONSTRING_TYPE);
   // r0: receiver
   // r1: receiver instance type
   __ Ret(lo);
 
   Label not_heap_number;
   __ cmp(r1, Operand(HEAP_NUMBER_TYPE));
   __ b(ne, &not_heap_number);
   __ bind(&is_number);
   NumberToStringStub stub(isolate());
   __ TailCallStub(&stub);
   __ bind(&not_heap_number);
 
   Label not_oddball;
   __ cmp(r1, Operand(ODDBALL_TYPE));
   __ b(ne, &not_oddball);
   __ ldr(r0, FieldMemOperand(r0, Oddball::kToStringOffset));
   __ Ret();
   __ bind(&not_oddball);
 
   __ push(r0);  // Push argument.
-  __ TailCallRuntime(Runtime::kToString, 1);
+  __ TailCallRuntime(Runtime::kToString);
 }
 
 
 void StringHelper::GenerateFlatOneByteStringEquals(
     MacroAssembler* masm, Register left, Register right, Register scratch1,
     Register scratch2, Register scratch3) {
   Register length = scratch1;
 
   // Compare lengths.
   Label strings_not_equal, check_zero_length;
@@ skipping 109 matching lines @@
 
   // Compare flat one-byte strings natively.
   __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, r2,
                       r3);
   StringHelper::GenerateCompareFlatOneByteStrings(masm, r1, r0, r2, r3, r4, r5);
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ Push(r1, r0);
-  __ TailCallRuntime(Runtime::kStringCompare, 2);
+  __ TailCallRuntime(Runtime::kStringCompare);
 }
 
 
 void BinaryOpICWithAllocationSiteStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- r1    : left
   //  -- r0    : right
   //  -- lr    : return address
   // -----------------------------------
 
@@ skipping 21 matching lines @@
 }
 
 
 void CompareICStub::GenerateBooleans(MacroAssembler* masm) {
   DCHECK_EQ(CompareICState::BOOLEAN, state());
   Label miss;
 
   __ CheckMap(r1, r2, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
   __ CheckMap(r0, r3, 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(r1, FieldMemOperand(r1, Oddball::kToNumberOffset));
       __ AssertSmi(r1);
       __ ldr(r0, FieldMemOperand(r0, Oddball::kToNumberOffset));
       __ AssertSmi(r0);
     }
     __ sub(r0, r1, r0);
     __ Ret();
   }
@@ skipping 240 matching lines @@
                                                   tmp3);
   } else {
     StringHelper::GenerateCompareFlatOneByteStrings(masm, left, right, tmp1,
                                                     tmp2, tmp3, tmp4);
   }
 
   // Handle more complex cases in runtime.
   __ bind(&runtime);
   __ Push(left, right);
   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());
   Label miss;
@@ skipping 25 matching lines @@
   __ ldr(r3, FieldMemOperand(r1, HeapObject::kMapOffset));
   __ cmp(r2, r4);
   __ b(ne, &miss);
   __ cmp(r3, r4);
   __ b(ne, &miss);
 
   if (Token::IsEqualityOp(op())) {
     __ sub(r0, r0, Operand(r1));
     __ Ret();
   } else if (is_strong(strength())) {
-    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion, 0);
+    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion);
   } else {
     if (op() == Token::LT || op() == Token::LTE) {
       __ mov(r2, Operand(Smi::FromInt(GREATER)));
     } else {
       __ mov(r2, Operand(Smi::FromInt(LESS)));
     }
     __ Push(r1, r0, r2);
-    __ TailCallRuntime(Runtime::kCompare, 3);
+    __ TailCallRuntime(Runtime::kCompare);
   }
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void CompareICStub::GenerateMiss(MacroAssembler* masm) {
   {
     // Call the runtime system in a fresh internal frame.
     FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
     __ Push(r1, r0);
     __ Push(lr, r1, r0);
     __ mov(ip, Operand(Smi::FromInt(op())));
     __ push(ip);
-    __ CallRuntime(Runtime::kCompareIC_Miss, 3);
+    __ CallRuntime(Runtime::kCompareIC_Miss);
     // Compute the entry point of the rewritten stub.
     __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
     // Restore registers.
     __ pop(lr);
     __ Pop(r1, r0);
   }
 
   __ Jump(r2);
 }
 
@@ skipping 1323 matching lines @@
   __ ldr(result, ContextMemOperand(result));
   __ ldr(result, FieldMemOperand(result, PropertyCell::kValueOffset));
 
   // If the result is not the_hole, return. Otherwise, handle in the runtime.
   __ CompareRoot(result, Heap::kTheHoleValueRootIndex);
   __ Ret(ne);
 
   // Fallback to runtime.
   __ SmiTag(slot);
   __ push(slot);
-  __ TailCallRuntime(Runtime::kLoadGlobalViaContext, 1);
+  __ TailCallRuntime(Runtime::kLoadGlobalViaContext);
 }
 
 
 void StoreGlobalViaContextStub::Generate(MacroAssembler* masm) {
   Register value = r0;
   Register slot = r2;
 
   Register cell = r1;
   Register cell_details = r4;
   Register cell_value = r5;
@@ skipping 103 matching lines @@
   __ ldr(scratch, FieldMemOperand(value, HeapObject::kMapOffset));
   __ cmp(cell_value_map, scratch);
   __ b(eq, &fast_heapobject_case);
 
   // Fallback to runtime.
   __ bind(&slow_case);
   __ SmiTag(slot);
   __ Push(slot, value);
   __ TailCallRuntime(is_strict(language_mode())
                          ? Runtime::kStoreGlobalViaContext_Strict
-                         : Runtime::kStoreGlobalViaContext_Sloppy,
-                     2);
+                         : Runtime::kStoreGlobalViaContext_Sloppy);
 }
 
 
 static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
   return ref0.address() - ref1.address();
 }
 
 
 // Calls an API function.  Allocates HandleScope, extracts returned value
 // from handle and propagates exceptions.  Restores context.  stack_space
@@ skipping 106 matching lines @@
   __ LoadRoot(r4, Heap::kTheHoleValueRootIndex);
   __ mov(ip, Operand(ExternalReference::scheduled_exception_address(isolate)));
   __ ldr(r5, MemOperand(ip));
   __ cmp(r4, r5);
   __ b(ne, &promote_scheduled_exception);
 
   __ mov(pc, lr);
 
   // 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(r5, MemOperand(r9, kLimitOffset));
   __ mov(r4, r0);
   __ PrepareCallCFunction(1, r5);
   __ mov(r0, Operand(ExternalReference::isolate_address(isolate)));
   __ CallCFunction(ExternalReference::delete_handle_scope_extensions(isolate),
                    1);
   __ mov(r0, r4);
@@ skipping 178 matching lines @@
                            MemOperand(fp, 6 * kPointerSize), NULL);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM