[runtime] TailCallRuntime and CallRuntime should use default argument counts

src/ppc/code-stubs-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/base/bits.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
@@ skipping 690 matching lines @@
   } else {
     StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, r5, r6, r7);
   }
   // 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;
     }
     __ LoadSmiLiteral(r3, Smi::FromInt(ncr));
     __ push(r3);
 
     // 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 202 matching lines @@
   __ bne(&done);
   // double_exponent may not containe the exponent value if the input was a
   // smi.  We set it with exponent value before bailing out.
   __ ConvertIntToDouble(exponent, double_exponent);
 
   // 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);
     __ stfd(double_result,
             FieldMemOperand(heapnumber, HeapNumber::kValueOffset));
     DCHECK(heapnumber.is(r3));
     __ IncrementCounter(counters->math_pow(), 1, scratch, scratch2);
@@ skipping 523 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.
   __ LoadSmiLiteral(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(r7, r8, LoadWithVectorDescriptor::VectorRegister(),
                      LoadWithVectorDescriptor::SlotRegister()));
@@ skipping 84 matching lines @@
   __ sub(r6, r3, r4);
   __ SmiToPtrArrayOffset(r6, r6);
   __ add(r6, r5, r6);
   __ LoadP(r3, MemOperand(r6, kDisplacement));
   __ blr();
 
   // Slow-case: Handle non-smi or out-of-bounds access to arguments
   // by calling the runtime system.
   __ bind(&slow);
   __ push(r4);
-  __ TailCallRuntime(Runtime::kArguments, 1);
+  __ TailCallRuntime(Runtime::kArguments);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppySlow(MacroAssembler* masm) {
   // r4 : function
   // r5 : number of parameters (tagged)
   // r6 : parameters pointer
 
   DCHECK(r4.is(ArgumentsAccessNewDescriptor::function()));
   DCHECK(r5.is(ArgumentsAccessNewDescriptor::parameter_count()));
   DCHECK(r6.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
 
   // Check if the calling frame is an arguments adaptor frame.
   Label runtime;
   __ LoadP(r7, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ LoadP(r3, MemOperand(r7, StandardFrameConstants::kContextOffset));
   __ CmpSmiLiteral(r3, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
   __ bne(&runtime);
 
   // Patch the arguments.length and the parameters pointer in the current frame.
   __ LoadP(r5, MemOperand(r7, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ SmiToPtrArrayOffset(r6, r5);
   __ add(r6, r6, r7);
   __ addi(r6, r6, Operand(StandardFrameConstants::kCallerSPOffset));
 
   __ bind(&runtime);
   __ Push(r4, r6, r5);
-  __ TailCallRuntime(Runtime::kNewSloppyArguments, 3);
+  __ TailCallRuntime(Runtime::kNewSloppyArguments);
 }
 
 
 void ArgumentsAccessStub::GenerateNewSloppyFast(MacroAssembler* masm) {
   // r4 : function
   // r5 : number of parameters (tagged)
   // r6 : parameters pointer
   // Registers used over whole function:
   // r8 : arguments count (tagged)
   // r9 : mapped parameter count (tagged)
@@ skipping 221 matching lines @@
   __ StorePU(r7, MemOperand(r11, kPointerSize));
   __ bdnz(&arguments_loop);
 
   // Return.
   __ Ret();
 
   // Do the runtime call to allocate the arguments object.
   // r8 = argument count (tagged)
   __ bind(&runtime);
   __ Push(r4, r6, r8);
-  __ 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.
   __ TestIfPositiveSmi(key, r0);
   __ bne(&slow, cr0);
 
   // 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) {
   // r4 : function
   // r5 : number of parameters (tagged)
@@ skipping 71 matching lines @@
   // Pre-increment r7 with kPointerSize on each iteration.
   __ StorePU(r8, MemOperand(r7, kPointerSize));
   __ bdnz(&loop);
 
   // Return.
   __ Ret();
 
   // Do the runtime call to allocate the arguments object.
   __ bind(&runtime);
   __ Push(r4, r6, r5);
-  __ 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;
   __ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
   __ LoadP(r6, MemOperand(r5, StandardFrameConstants::kContextOffset));
   __ CmpSmiLiteral(r6, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
   __ bne(&runtime);
 
   // Patch the arguments.length and the parameters pointer.
   __ LoadP(r4, MemOperand(r5, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ StoreP(r4, MemOperand(sp, 2 * kPointerSize));
   __ SmiToPtrArrayOffset(r0, r4);
   __ add(r6, r5, r0);
   __ addi(r6, r6, Operand(StandardFrameConstants::kCallerSPOffset));
   __ StoreP(r6, 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 274 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(r4, Operand(isolate()->factory()->the_hole_value()));
   __ mov(r5, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
                                        isolate())));
   __ LoadP(r3, MemOperand(r5, 0));
   __ cmp(r3, r4);
   __ beq(&runtime);
 
   // For exception, throw the exception again.
-  __ TailCallRuntime(Runtime::kRegExpExecReThrow, 4);
+  __ TailCallRuntime(Runtime::kRegExpExecReThrow);
 
   __ bind(&failure);
   // For failure and exception return null.
   __ mov(r3, Operand(isolate()->factory()->null_value()));
   __ addi(sp, sp, Operand(4 * kPointerSize));
   __ Ret();
 
   // Process the result from the native regexp code.
   __ bind(&success);
   __ LoadP(r4,
@@ skipping 68 matching lines @@
   __ StorePU(r6, MemOperand(r3, kPointerSize));
   __ bdnz(&next_capture);
 
   // Return last match info.
   __ LoadP(r3, MemOperand(sp, kLastMatchInfoOffset));
   __ addi(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.
   __ bgt(&not_long_external);  // Go to (8).
 
   // (7) External string.  Make it, offset-wise, look like a sequential string.
   __ bind(&external_string);
   __ LoadP(r3, FieldMemOperand(subject, HeapObject::kMapOffset));
@@ skipping 347 matching lines @@
 }
 
 
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
 
   // Push the function and feedback info.
   __ Push(r4, r5, r6);
 
   // Call the entry.
-  __ CallRuntime(Runtime::kCallIC_Miss, 3);
+  __ CallRuntime(Runtime::kCallIC_Miss);
 
   // Move result to r4 and exit the internal frame.
   __ mr(r4, r3);
 }
 
 
 // StringCharCodeAtGenerator
 void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
   // If the receiver is a smi trigger the non-string case.
   if (check_mode_ == RECEIVER_IS_UNKNOWN) {
@@ skipping 38 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_, r3);
   if (embed_mode == PART_OF_IC_HANDLER) {
     __ Pop(LoadWithVectorDescriptor::VectorRegister(),
            LoadWithVectorDescriptor::SlotRegister(), object_);
   } else {
     __ pop(object_);
   }
   // Reload the instance type.
   __ LoadP(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
   __ lbz(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);
   __ Move(result_, r3);
   call_helper.AfterCall(masm);
   __ b(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 
 // -------------------------------------------------------------------------
 // StringCharFromCodeGenerator
@@ skipping 19 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_, r3);
   call_helper.AfterCall(masm);
   __ b(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
 enum CopyCharactersFlags { COPY_ONE_BYTE = 1, DEST_ALWAYS_ALIGNED = 2 };
 
@@ skipping 233 matching lines @@
                                        String::TWO_BYTE_ENCODING);
 
   __ bind(&return_r3);
   Counters* counters = isolate()->counters();
   __ IncrementCounter(counters->sub_string_native(), 1, r6, r7);
   __ Drop(3);
   __ Ret();
 
   // Just jump to runtime to create the sub string.
   __ bind(&runtime);
-  __ TailCallRuntime(Runtime::kSubString, 3);
+  __ TailCallRuntime(Runtime::kSubString);
 
   __ bind(&single_char);
   // r3: original string
   // r4: instance type
   // r5: length
   // r6: from index (untagged)
   __ SmiTag(r6, r6);
   StringCharAtGenerator generator(r3, r6, r5, r3, &runtime, &runtime, &runtime,
                                   STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
   generator.GenerateFast(masm);
@@ skipping 19 matching lines @@
   __ cmpli(r4, Operand(FIRST_NONSTRING_TYPE));
   __ bge(&not_string);
   // Check if string has a cached array index.
   __ lwz(r5, FieldMemOperand(r3, String::kHashFieldOffset));
   __ And(r0, r5, Operand(String::kContainsCachedArrayIndexMask), SetRC);
   __ bne(&slow_string, cr0);
   __ IndexFromHash(r5, r3);
   __ blr();
   __ bind(&slow_string);
   __ push(r3);  // Push argument.
-  __ TailCallRuntime(Runtime::kStringToNumber, 1);
+  __ TailCallRuntime(Runtime::kStringToNumber);
   __ bind(&not_string);
 
   Label not_oddball;
   __ cmpi(r4, Operand(ODDBALL_TYPE));
   __ bne(&not_oddball);
   __ LoadP(r3, FieldMemOperand(r3, Oddball::kToNumberOffset));
   __ blr();
   __ bind(&not_oddball);
 
   __ push(r3);  // Push argument.
-  __ TailCallRuntime(Runtime::kToNumber, 1);
+  __ TailCallRuntime(Runtime::kToNumber);
 }
 
 
 void ToLengthStub::Generate(MacroAssembler* masm) {
   // The ToLength stub takes one argument in r3.
   Label not_smi;
   __ JumpIfNotSmi(r3, &not_smi);
   STATIC_ASSERT(kSmiTag == 0);
   __ cmpi(r3, Operand::Zero());
   if (CpuFeatures::IsSupported(ISELECT)) {
     __ isel(lt, r3, r0, r3);
   } else {
     Label positive;
     __ bgt(&positive);
     __ li(r3, Operand::Zero());
     __ bind(&positive);
   }
   __ Ret();
   __ bind(&not_smi);
 
   __ push(r3);  // Push argument.
-  __ TailCallRuntime(Runtime::kToLength, 1);
+  __ TailCallRuntime(Runtime::kToLength);
 }
 
 
 void ToStringStub::Generate(MacroAssembler* masm) {
   // The ToString stub takes one argument in r3.
   Label is_number;
   __ JumpIfSmi(r3, &is_number);
 
   __ CompareObjectType(r3, r4, r4, FIRST_NONSTRING_TYPE);
   // r3: receiver
   // r4: receiver instance type
   __ Ret(lt);
 
   Label not_heap_number;
   __ cmpi(r4, Operand(HEAP_NUMBER_TYPE));
   __ bne(&not_heap_number);
   __ bind(&is_number);
   NumberToStringStub stub(isolate());
   __ TailCallStub(&stub);
   __ bind(&not_heap_number);
 
   Label not_oddball;
   __ cmpi(r4, Operand(ODDBALL_TYPE));
   __ bne(&not_oddball);
   __ LoadP(r3, FieldMemOperand(r3, Oddball::kToStringOffset));
   __ Ret();
   __ bind(&not_oddball);
 
   __ push(r3);  // Push argument.
-  __ TailCallRuntime(Runtime::kToString, 1);
+  __ TailCallRuntime(Runtime::kToString);
 }
 
 
 void StringHelper::GenerateFlatOneByteStringEquals(MacroAssembler* masm,
                                                    Register left,
                                                    Register right,
                                                    Register scratch1,
                                                    Register scratch2) {
   Register length = scratch1;
 
@@ skipping 134 matching lines @@
 
   // Compare flat one-byte strings natively.
   __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, r5,
                       r6);
   StringHelper::GenerateCompareFlatOneByteStrings(masm, r4, r3, r5, r6, r7);
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ Push(r4, r3);
-  __ TailCallRuntime(Runtime::kStringCompare, 2);
+  __ TailCallRuntime(Runtime::kStringCompare);
 }
 
 
 void BinaryOpICWithAllocationSiteStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- r4    : left
   //  -- r3    : right
   //  -- lr    : return address
   // -----------------------------------
 
@@ skipping 21 matching lines @@
 }
 
 
 void CompareICStub::GenerateBooleans(MacroAssembler* masm) {
   DCHECK_EQ(CompareICState::BOOLEAN, state());
   Label miss;
 
   __ CheckMap(r4, r5, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
   __ CheckMap(r3, r6, 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())) {
       __ LoadP(r4, FieldMemOperand(r4, Oddball::kToNumberOffset));
       __ AssertSmi(r4);
       __ LoadP(r3, FieldMemOperand(r3, Oddball::kToNumberOffset));
       __ AssertSmi(r3);
     }
     __ sub(r3, r4, r3);
     __ Ret();
   }
@@ skipping 263 matching lines @@
                                                   tmp2);
   } else {
     StringHelper::GenerateCompareFlatOneByteStrings(masm, left, right, tmp1,
                                                     tmp2, tmp3);
   }
 
   // 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 @@
   __ LoadP(r6, FieldMemOperand(r4, HeapObject::kMapOffset));
   __ cmp(r5, r7);
   __ bne(&miss);
   __ cmp(r6, r7);
   __ bne(&miss);
 
   if (Token::IsEqualityOp(op())) {
     __ sub(r3, r3, r4);
     __ Ret();
   } else if (is_strong(strength())) {
-    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion, 0);
+    __ TailCallRuntime(Runtime::kThrowStrongModeImplicitConversion);
   } else {
     if (op() == Token::LT || op() == Token::LTE) {
       __ LoadSmiLiteral(r5, Smi::FromInt(GREATER));
     } else {
       __ LoadSmiLiteral(r5, Smi::FromInt(LESS));
     }
     __ Push(r4, r3, r5);
-    __ 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(r4, r3);
     __ Push(r4, r3);
     __ LoadSmiLiteral(r0, Smi::FromInt(op()));
     __ push(r0);
-    __ CallRuntime(Runtime::kCompareIC_Miss, 3);
+    __ CallRuntime(Runtime::kCompareIC_Miss);
     // Compute the entry point of the rewritten stub.
     __ addi(r5, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
     // Restore registers.
     __ Pop(r4, r3);
   }
 
   __ JumpToJSEntry(r5);
 }
 
 
@@ skipping 1352 matching lines @@
   __ LoadP(result, ContextMemOperand(result));
   __ LoadP(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 = r3;
   Register slot = r5;
 
   Register cell = r4;
   Register cell_details = r6;
   Register cell_value = r7;
@@ skipping 107 matching lines @@
   __ LoadP(scratch, FieldMemOperand(value, HeapObject::kMapOffset));
   __ cmp(cell_value_map, scratch);
   __ beq(&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 115 matching lines @@
   __ LoadRoot(r14, Heap::kTheHoleValueRootIndex);
   __ mov(r15, Operand(ExternalReference::scheduled_exception_address(isolate)));
   __ LoadP(r15, MemOperand(r15));
   __ cmp(r14, r15);
   __ bne(&promote_scheduled_exception);
 
   __ blr();
 
   // 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);
   __ StoreP(r15, MemOperand(r17, kLimitOffset));
   __ mr(r14, r3);
   __ PrepareCallCFunction(1, r15);
   __ mov(r3, Operand(ExternalReference::isolate_address(isolate)));
   __ CallCFunction(ExternalReference::delete_handle_scope_extensions(isolate),
                    1);
   __ mr(r3, r14);
@@ skipping 211 matching lines @@
                            kStackUnwindSpace, NULL,
                            MemOperand(fp, 6 * kPointerSize), NULL);
 }
 
 
 #undef __
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_PPC