Fix the previously ineffective assert checking the number of arguments passed to

runtime/vm/stub_code_mips.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 107 matching lines @@
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 // Input parameters:
 //   A0 : stop message (const char*).
 // Must preserve all registers.
 void StubCode::GeneratePrintStopMessageStub(Assembler* assembler) {
   __ EnterCallRuntimeFrame(0);
   // Call the runtime leaf function. A0 already contains the parameter.
-  __ CallRuntime(kPrintStopMessageRuntimeEntry);
+  __ CallRuntime(kPrintStopMessageRuntimeEntry, 1);
   __ LeaveCallRuntimeFrame();
   __ Ret();
 }
 
 
 // Input parameters:
 //   RA : return address.
 //   SP : address of return value.
 //   T5 : address of the native function to call.
 //   A2 : address of first argument in argument array.
@@ skipping 182 matching lines @@
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   __ TraceSimMsg("CallStaticFunctionStub");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
 
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
 
-  __ CallRuntime(kPatchStaticCallRuntimeEntry);
+  __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
   __ TraceSimMsg("CallStaticFunctionStub return");
 
   // Get Code object result and restore arguments descriptor array.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // S4: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ TraceSimMsg("FixCallersTarget");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
-  __ CallRuntime(kFixCallersTargetRuntimeEntry);
+  __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   // Get Code object result and restore arguments descriptor array.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
   // Jump to the dart function.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame.
@@ skipping 60 matching lines @@
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 3 * kWordSize));
   __ sw(T1, Address(SP, 2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
 
   // A1: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
   __ TraceSimMsg("InstanceFunctionLookupStub return");
 
-  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry);
+  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry, 4);
 
   __ lw(V0, Address(SP, 4 * kWordSize));  // Get result into V0.
   __ addiu(SP, SP, Immediate(5 * kWordSize));    // Remove arguments.
 
   __ LeaveStubFrameAndReturn();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                            intptr_t deopt_reason,
@@ skipping 62 matching lines @@
   }
   for (int i = 0; i < kNumberOfFRegisters; i++) {
     // These go below the CPU registers.
     const int slot = 4 + kNumberOfCpuRegisters + kNumberOfFRegisters - i;
     FRegister reg = static_cast<FRegister>(i);
     __ swc1(reg, Address(SP, kPushedRegistersSize - slot * kWordSize));
   }
 
   __ mov(A0, SP);  // Pass address of saved registers block.
   __ ReserveAlignedFrameSpace(1 * kWordSize);
-  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry);
+  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
   // Result (V0) is stack-size (FP - SP) in bytes, incl. the return address.
 
   if (preserve_result) {
     // Restore result into T1 temporarily.
     __ lw(T1, Address(FP, saved_result_slot_from_fp * kWordSize));
   }
 
   __ addiu(SP, FP, Immediate(-kWordSize));
   __ lw(RA, Address(SP, 2 * kWordSize));
   __ lw(FP, Address(SP, 1 * kWordSize));
   __ lw(PP, Address(SP, 0 * kWordSize));
   __ subu(SP, FP, V0);
 
   // DeoptimizeFillFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
   // is no need to set the correct PC marker or load PP, since they get patched.
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
   __ sw(ZR, Address(SP, 3 * kWordSize));
   __ sw(RA, Address(SP, 2 * kWordSize));
   __ sw(FP, Address(SP, 1 * kWordSize));
   __ sw(PP, Address(SP, 0 * kWordSize));
   __ addiu(FP, SP, Immediate(kWordSize));
 
   __ mov(A0, FP);  // Get last FP address.
   if (preserve_result) {
     __ Push(T1);  // Preserve result as first local.
   }
   __ ReserveAlignedFrameSpace(1 * kWordSize);
-  __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry);  // Pass last FP in A0.
+  __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry, 1);  // Pass last FP in A0.
   if (preserve_result) {
     // Restore result into T1.
     __ lw(T1, Address(FP, kFirstLocalSlotFromFp * kWordSize));
   }
   // Code above cannot cause GC.
   __ addiu(SP, FP, Immediate(-kWordSize));
   __ lw(RA, Address(SP, 2 * kWordSize));
   __ lw(FP, Address(SP, 1 * kWordSize));
   __ lw(PP, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(4 * kWordSize));
 
   // Frame is fully rewritten at this point and it is safe to perform a GC.
   // Materialize any objects that were deferred by FillFrame because they
   // require allocation.
   __ EnterStubFrame();
   if (preserve_result) {
     __ Push(T1);  // Preserve result, it will be GC-d here.
   }
   __ PushObject(Smi::ZoneHandle());  // Space for the result.
-  __ CallRuntime(kDeoptimizeMaterializeRuntimeEntry);
+  __ CallRuntime(kDeoptimizeMaterializeRuntimeEntry, 0);
   // Result tells stub how many bytes to remove from the expression stack
   // of the bottom-most frame. They were used as materialization arguments.
   __ Pop(T1);
   if (preserve_result) {
     __ Pop(V0);  // Restore result.
   }
   __ LeaveStubFrame();
   // Remove materialization arguments.
   __ SmiUntag(T1);
   __ addu(SP, SP, T1);
@@ skipping 31 matching lines @@
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 3 * kWordSize));
   __ sw(T6, Address(SP, 2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
 
-  __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry);
+  __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
 
   __ lw(T0, Address(SP, 3 * kWordSize));  // Get result.
   __ lw(S4, Address(SP, 4 * kWordSize));  // Restore argument descriptor.
   __ lw(S5, Address(SP, 5 * kWordSize));  // Restore IC data.
   __ addiu(SP, SP, Immediate(6 * kWordSize));
 
   __ LeaveStubFrame();
 
   Label nonnull;
   __ BranchNotEqual(T0, reinterpret_cast<int32_t>(Object::null()), &nonnull);
@@ skipping 126 matching lines @@
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   // Setup space on stack for return value.
   // Push array length as Smi and element type.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 2 * kWordSize));
   __ sw(A1, Address(SP, 1 * kWordSize));
   __ sw(A0, Address(SP, 0 * kWordSize));
-  __ CallRuntime(kAllocateArrayRuntimeEntry);
+  __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   __ TraceSimMsg("AllocateArrayStub return");
   // Pop arguments; result is popped in IP.
   __ lw(V0, Address(SP, 2 * kWordSize));
   __ lw(A1, Address(SP, 1 * kWordSize));
   __ lw(A0, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));
 
   __ LeaveStubFrameAndReturn();
 }
 
@@ skipping 49 matching lines @@
   __ bne(T0, T7, &function_compiled);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   // Preserve arguments descriptor array and read-only function object argument.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ sw(T2, Address(SP, 0 * kWordSize));
-  __ CallRuntime(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ TraceSimMsg("GenerateCallClosureFunctionStub return");
   // Restore arguments descriptor array and read-only function object argument.
   __ lw(T2, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   // Restore T0.
   __ lw(T0, FieldAddress(T2, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
   __ LeaveStubFrame();
@@ skipping 29 matching lines @@
 
   // Stack:
   // TOS + 0: Argument array.
   // TOS + 1: Arguments descriptor array.
   // TOS + 2: Place for result from the call.
   // TOS + 3: Saved FP of previous frame.
   // TOS + 4: Dart code return address.
   // TOS + 5: PC marker (0 for stub).
   // TOS + 6: Last argument of caller.
   // ....
-  __ CallRuntime(kInvokeNonClosureRuntimeEntry);
+  __ CallRuntime(kInvokeNonClosureRuntimeEntry, 2);
   __ lw(V0, Address(SP, 2 * kWordSize));  // Get result into V0.
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Remove arguments.
 
   // Remove the stub frame as we are about to return.
   __ LeaveStubFrameAndReturn();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
@@ skipping 220 matching lines @@
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   // Setup space on stack for return value.
   __ SmiTag(T1);
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 1 * kWordSize));  // Store null.
   __ sw(T1, Address(SP, 0 * kWordSize));
-  __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
+  __ CallRuntime(kAllocateContextRuntimeEntry, 1);  // Allocate context.
   __ lw(V0, Address(SP, 1 * kWordSize));  // Get the new context.
   __ addiu(SP, SP, Immediate(2 * kWordSize));  // Pop argument and return.
 
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrameAndReturn();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
@@ skipping 56 matching lines @@
   __ beq(CMPRES, ZR, &L);
   __ delay_slot()->addiu(SP, SP, Immediate(3 * kWordSize));
   __ Ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
 
   __ EnterCallRuntimeFrame(1 * kWordSize);
   __ lw(A0, FieldAddress(CTX, Context::isolate_offset()));
-  __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry);
+  __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
   __ TraceSimMsg("UpdateStoreBufferStub return");
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ Ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   RA : return address.
@@ skipping 152 matching lines @@
   if (is_cls_parameterized) {
     // Push type arguments of object to be allocated and of instantiator.
     __ sw(T1, Address(SP, 1 * kWordSize));
     __ sw(T0, Address(SP, 0 * kWordSize));
   } else {
     // Push null type arguments and kNoInstantiator.
     __ LoadImmediate(T1, Smi::RawValue(StubCode::kNoInstantiator));
     __ sw(T7, Address(SP, 1 * kWordSize));
     __ sw(T1, Address(SP, 0 * kWordSize));
   }
-  __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
+  __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ TraceSimMsg("AllocationStubForClass return");
   // Pop result (newly allocated object).
   __ lw(V0, Address(SP, 3 * kWordSize));
   __ addiu(SP, SP, Immediate(4 * kWordSize));  // Pop arguments.
   // V0: new object
   // Restore the frame pointer and return.
   __ LeaveStubFrameAndReturn(RA, true);
 }
 
 
@@ skipping 118 matching lines @@
   if (is_implicit_instance_closure) {
     __ lw(T1, Address(FP, kReceiverFPOffset));
     __ sw(T1, Address(SP, (num_slots - 3) * kWordSize));  // Receiver.
   }
   if (has_type_arguments) {
     __ lw(T2, Address(FP, kTypeArgumentsFPOffset));
   }
   __ sw(T2, Address(SP, 0 * kWordSize));
 
   if (is_implicit_instance_closure) {
-    __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry);
+    __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry, 3);
     __ TraceSimMsg("AllocationStubForClosure return");
   } else {
     ASSERT(func.IsNonImplicitClosureFunction());
-    __ CallRuntime(kAllocateClosureRuntimeEntry);
+    __ CallRuntime(kAllocateClosureRuntimeEntry, 2);
     __ TraceSimMsg("AllocationStubForClosure return");
   }
   __ lw(V0, Address(SP, (num_slots - 1) * kWordSize));  // Pop function object.
   __ addiu(SP, SP, Immediate(num_slots * kWordSize));
 
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrameAndReturn(RA, true);
 }
 
@@ skipping 22 matching lines @@
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 3 * kWordSize));
   __ sw(T6, Address(SP, 2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
 
   // A1: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry);
+  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry, 4);
 
   __ lw(V0, Address(SP, 4 * kWordSize));  // Get result into V0.
   __ LeaveStubFrameAndReturn();
 }
 
 
 //  T0: function object.
 //  S5: inline cache data object.
 // Cannot use function object from ICData as it may be the inlined
 // function and not the top-scope function.
 void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) {
   __ TraceSimMsg("OptimizedUsageCounterIncrement");
   Register ic_reg = S5;
   Register func_reg = T0;
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(-4 * kWordSize));
     __ sw(T0, Address(SP, 3 * kWordSize));
     __ sw(S5, Address(SP, 2 * kWordSize));
     __ sw(ic_reg, Address(SP, 1 * kWordSize));  // Argument.
     __ sw(func_reg, Address(SP, 0 * kWordSize));  // Argument.
-    __ CallRuntime(kTraceICCallRuntimeEntry);
+    __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ lw(S5, Address(SP, 2 * kWordSize));
     __ lw(T0, Address(SP, 3 * kWordSize));
     __ addiu(SP, SP, Immediate(4 * kWordSize));  // Discard argument;
     __ LeaveStubFrame();
   }
   __ lw(T7, FieldAddress(func_reg, Function::usage_counter_offset()));
   __ addiu(T7, T7, Immediate(1));
   __ sw(T7, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
@@ skipping 42 matching lines @@
 
   // Check single stepping.
   Label not_stepping;
   __ lw(T0, FieldAddress(CTX, Context::isolate_offset()));
   __ lbu(T0, Address(T0, Isolate::single_step_offset()));
   __ BranchEqual(T0, 0, &not_stepping);
   // Call single step callback in debugger.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));  // Preserve IC data.
   __ sw(RA, Address(SP, 0 * kWordSize));  // Return address.
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ lw(RA, Address(SP, 0 * kWordSize));
   __ lw(S5, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ Bind(&not_stepping);
 
   // Load argument descriptor into S4.
   __ lw(S4, FieldAddress(S5, ICData::arguments_descriptor_offset()));
   // Preserve return address, since RA is needed for subroutine call.
   __ mov(T2, RA);
   // Loop that checks if there is an IC data match.
@@ skipping 80 matching lines @@
   __ sw(S4, Address(SP, (num_slots - 2) * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, (num_slots - 3) * kWordSize));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ lw(TMP1, Address(T1, -i * kWordSize));
     __ sw(TMP1, Address(SP, (num_slots - i - 4) * kWordSize));
   }
   // Pass IC data object.
   __ sw(S5, Address(SP, (num_slots - num_args - 4) * kWordSize));
-  __ CallRuntime(handle_ic_miss);
+  __ CallRuntime(handle_ic_miss, num_args + 1);
   __ TraceSimMsg("NArgsCheckInlineCacheStub return");
   // Pop returned code object into T3 (null if not found).
   // Restore arguments descriptor array and IC data array.
   __ lw(T3, Address(SP, (num_slots - 3) * kWordSize));
   __ lw(S4, Address(SP, (num_slots - 2) * kWordSize));
   __ lw(S5, Address(SP, (num_slots - 1) * kWordSize));
   // Remove the call arguments pushed earlier, including the IC data object
   // and the arguments descriptor array.
   __ addiu(SP, SP, Immediate(num_slots * kWordSize));
   __ LeaveStubFrame();
@@ skipping 132 matching lines @@
 
   // Check single stepping.
   Label not_stepping;
   __ lw(T0, FieldAddress(CTX, Context::isolate_offset()));
   __ lbu(T0, Address(T0, Isolate::single_step_offset()));
   __ BranchEqual(T0, 0, &not_stepping);
   // Call single step callback in debugger.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));  // Preserve IC data.
   __ sw(RA, Address(SP, 0 * kWordSize));  // Return address.
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ lw(RA, Address(SP, 0 * kWordSize));
   __ lw(S5, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ Bind(&not_stepping);
 
 
   // S5: IC data object (preserved).
   __ lw(T0, FieldAddress(S5, ICData::ic_data_offset()));
   // T0: ic_data_array with entries: target functions and count.
   __ AddImmediate(T0, Array::data_offset() - kHeapObjectTag);
@@ skipping 20 matching lines @@
   __ LoadImmediate(CMPRES1, reinterpret_cast<intptr_t>(Object::null()));
   __ bne(T4, CMPRES1, &target_is_compiled);
 
   __ EnterStubFrame();
   // Preserve target function and IC data object.
   // Two preserved registers, one argument (function) => 3 slots.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(S5, Address(SP, 2 * kWordSize));  // Preserve IC data.
   __ sw(T3, Address(SP, 1 * kWordSize));  // Preserve function.
   __ sw(T3, Address(SP, 0 * kWordSize));  // Function argument.
-  __ CallRuntime(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ lw(T3, Address(SP, 1 * kWordSize));  // Restore function.
   __ lw(S5, Address(SP, 2 * kWordSize));  // Restore IC data.
   __ addiu(SP, SP, Immediate(3 * kWordSize));
   // T3: target function.
   __ lw(T4, FieldAddress(T3, Function::code_offset()));
   __ LeaveStubFrame();
 
   __ Bind(&target_is_compiled);
   // T4: target code.
   __ lw(T3, FieldAddress(T4, Code::instructions_offset()));
@@ skipping 22 matching lines @@
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   __ TraceSimMsg("BreakpointStaticStub");
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   // Preserve arguments descriptor and make room for result.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
-  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry, 0);
   // Pop code object result and restore arguments descriptor.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S5, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ LeaveStubFrame();
 
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   // Load arguments descriptor into S4.
   __ lw(S4, FieldAddress(S5, ICData::arguments_descriptor_offset()));
   __ jr(T0);
 }
 
 
 //  V0: return value.
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   __ TraceSimMsg("BreakpoingReturnStub");
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ Push(V0);
-  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry, 0);
   __ Pop(V0);
   __ LeaveStubFrame();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
   __ LeaveDartFrameAndReturn();
 }
 
 
 //  RA: return address (Dart code).
 //  S5: Inline cache data array.
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ TraceSimMsg("BreakpointDynamicStub");
   __ EnterStubFrame();
   __ Push(S5);
-  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry, 0);
   __ Pop(S5);
   __ LeaveStubFrame();
 
   // Find out which dispatch stub to call.
   __ lw(T1, FieldAddress(S5, ICData::num_args_tested_offset()));
 
   Label one_arg, two_args, three_args;
   __ BranchEqual(T1, 1, &one_arg);
   __ BranchEqual(T1, 2, &two_args);
   __ BranchEqual(T1, 3, &three_args);
@@ skipping 234 matching lines @@
   __ delay_slot()->SmiTag(T2);
 
   __ Bind(&update_ic_data);
   // T0: ICData
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
   __ sw(A1, Address(SP, 3 * kWordSize));
   __ sw(A0, Address(SP, 2 * kWordSize));
   __ LoadObject(TMP1, Symbols::EqualOperator());  // Target's name.
   __ sw(TMP1, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));  // ICData.
-  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry);
+  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry, 4);
   __ lw(A0, Address(SP, 2 * kWordSize));
   __ lw(A1, Address(SP, 3 * kWordSize));
   __ b(&compute_result);
   __ delay_slot()->addiu(SP, SP, Immediate(4 * kWordSize));
 }
 
 
 // Calls to the runtime to optimize the given function.
 // T0: function to be reoptimized.
 // S4: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   __ TraceSimMsg("OptimizeFunctionStub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(S4, Address(SP, 2 * kWordSize));
   // Setup space on stack for return value.
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
-  __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
+  __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
   __ TraceSimMsg("OptimizeFunctionStub return");
   __ lw(T0, Address(SP, 1 * kWordSize));  // Get Code object
   __ lw(S4, Address(SP, 2 * kWordSize));  // Restore argument descriptor.
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Discard argument.
 
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ LeaveStubFrameAndReturn(T0);
   __ break_(0);
 }
@@ skipping 66 matching lines @@
   __ LoadClassId(temp2, right);
   __ subu(CMPRES, temp1, temp2);
   __ bne(CMPRES, ZR, &done);
 
   __ EnterStubFrame();
   __ ReserveAlignedFrameSpace(2 * kWordSize);
   __ sw(left, Address(SP, 1 * kWordSize));
   __ sw(right, Address(SP, 0 * kWordSize));
   __ mov(A0, left);
   __ mov(A1, right);
-  __ CallRuntime(kBigintCompareRuntimeEntry);
+  __ CallRuntime(kBigintCompareRuntimeEntry, 2);
   __ TraceSimMsg("IdenticalWithNumberCheckStub return");
   // Result in V0, 0 means equal.
   __ LeaveStubFrame();
   __ b(&done);
   __ delay_slot()->mov(CMPRES, V0);
 
   __ Bind(&reference_compare);
   __ subu(CMPRES, left, right);
   __ Bind(&done);
   // A branch or test after this comparison will check CMPRES1 == CMPRES2.
   __ mov(CMPRES2, ZR);
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 // RA: return address.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Returns: CMPRES is zero if equal, non-zero otherwise.
 void StubCode::GenerateUnoptimizedIdenticalWithNumberCheckStub(
     Assembler* assembler) {
   // Check single stepping.
   Label not_stepping;
   __ lw(T0, FieldAddress(CTX, Context::isolate_offset()));
   __ lbu(T0, Address(T0, Isolate::single_step_offset()));
   __ BranchEqual(T0, 0, &not_stepping);
   // Call single step callback in debugger.
   __ addiu(SP, SP, Immediate(-1 * kWordSize));
   __ sw(RA, Address(SP, 0 * kWordSize));  // Return address.
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ lw(RA, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(1 * kWordSize));
   __ Bind(&not_stepping);
 
   const Register temp1 = T2;
   const Register temp2 = T3;
   const Register left = T1;
   const Register right = T0;
   // Preserve left, right.
   __ lw(left, Address(SP, 1 * kWordSize));
@@ skipping 27 matching lines @@
   __ lw(left, Address(SP, 1 * kWordSize));
   __ lw(temp2, Address(SP, 2 * kWordSize));
   __ lw(temp1, Address(SP, 3 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(4 * kWordSize));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS