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

runtime/vm/stub_code_arm.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_ARM)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 95 matching lines @@
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 // Input parameters:
 //   R0 : stop message (const char*).
 // Must preserve all registers.
 void StubCode::GeneratePrintStopMessageStub(Assembler* assembler) {
   __ EnterCallRuntimeFrame(0);
   // Call the runtime leaf function. R0 already contains the parameter.
-  __ CallRuntime(kPrintStopMessageRuntimeEntry);
+  __ CallRuntime(kPrintStopMessageRuntimeEntry, 1);
   __ LeaveCallRuntimeFrame();
   __ Ret();
 }
 
 
 // Input parameters:
 //   LR : return address.
 //   SP : address of return value.
 //   R5 : address of the native function to call.
 //   R2 : address of first argument in argument array.
@@ skipping 157 matching lines @@
 
 // Input parameters:
 //   R4: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   // 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 and preserve arguments descriptor.
   __ LoadImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R0) | (1 << R4));
-  __ CallRuntime(kPatchStaticCallRuntimeEntry);
+  __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
   // Get Code object result and restore arguments descriptor array.
   __ PopList((1 << R0) | (1 << R4));
   // Remove the stub frame.
   __ LeaveStubFrame();
   // Jump to the dart function.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, R0, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R0);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // R4: 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.
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
   __ LoadImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R0) | (1 << R4));
-  __ CallRuntime(kFixCallersTargetRuntimeEntry);
+  __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   // Get Code object result and restore arguments descriptor array.
   __ PopList((1 << R0) | (1 << R4));
   // Remove the stub frame.
   __ LeaveStubFrame();
   // Jump to the dart function.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, R0, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R0);
 }
 
@@ skipping 43 matching lines @@
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R4) | (1 << R5) | (1 << R6) | (1 << IP));
 
   // R2: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry);
+  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry, 4);
 
   // Remove arguments.
   __ Drop(4);
   __ Pop(R0);  // Get result into R0.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
@@ skipping 49 matching lines @@
   ASSERT(kFpuRegisterSize == 4 * kWordSize);
   if (kNumberOfDRegisters > 16) {
     __ vstmd(DB_W, SP, D16, kNumberOfDRegisters - 16);
     __ vstmd(DB_W, SP, D0, 16);
   } else {
     __ vstmd(DB_W, SP, D0, kNumberOfDRegisters);
   }
 
   __ mov(R0, ShifterOperand(SP));  // Pass address of saved registers block.
   __ ReserveAlignedFrameSpace(0);
-  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry);
+  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
   // Result (R0) is stack-size (FP - SP) in bytes.
 
   if (preserve_result) {
     // Restore result into R1 temporarily.
     __ ldr(R1, Address(FP, saved_result_slot_from_fp * kWordSize));
   }
 
   __ LeaveDartFrame();
   __ sub(SP, FP, ShifterOperand(R0));
 
   // 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.
   __ mov(IP, ShifterOperand(LR));
   __ mov(LR, ShifterOperand(0));
   __ EnterFrame((1 << PP) | (1 << FP) | (1 << IP) | (1 << LR), 0);
   __ mov(R0, ShifterOperand(FP));  // Get last FP address.
   if (preserve_result) {
     __ Push(R1);  // Preserve result as first local.
   }
   __ ReserveAlignedFrameSpace(0);
-  __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry);  // Pass last FP in R0.
+  __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry, 1);  // Pass last FP in R0.
   if (preserve_result) {
     // Restore result into R1.
     __ ldr(R1, Address(FP, kFirstLocalSlotFromFp * kWordSize));
   }
   // Code above cannot cause GC.
   __ LeaveDartFrame();
 
   // 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(R1);  // 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(R1);
   if (preserve_result) {
     __ Pop(R0);  // Restore result.
   }
   __ LeaveStubFrame();
   // Remove materialization arguments.
   __ add(SP, SP, ShifterOperand(R1, ASR, kSmiTagSize));
   __ Ret();
@@ skipping 23 matching lines @@
 
   // Preserve IC data and arguments descriptor.
   __ PushList((1 << R4) | (1 << R5));
 
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R4) | (1 << R5) | (1 << R6) | (1 << IP));
-  __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry);
+  __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
   // Remove arguments.
   __ Drop(3);
   __ Pop(R0);  // Get result into R0.
 
   // Restore IC data and arguments descriptor.
   __ PopList((1 << R4) | (1 << R5));
 
   __ LeaveStubFrame();
 
   __ CompareImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 118 matching lines @@
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   // Setup space on stack for return value.
   // Push array length as Smi and element type.
   __ PushList((1 << R1) | (1 << R2) | (1 << IP));
-  __ CallRuntime(kAllocateArrayRuntimeEntry);
+  __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   // Pop arguments; result is popped in IP.
   __ PopList((1 << R1) | (1 << R2) | (1 << IP));  // R2 is restored.
   __ mov(R0, ShifterOperand(IP));
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 // Input parameters:
 //   LR: return address.
@@ skipping 36 matching lines @@
   __ cmp(R0, ShifterOperand(R8));  // R8 is raw null.
   Label function_compiled;
   __ b(&function_compiled, NE);
 
   // 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.
   __ PushList((1 << R2) | (1 << R4));
-  __ CallRuntime(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   // Restore arguments descriptor array and read-only function object argument.
   __ PopList((1 << R2) | (1 << R4));
   // Restore R0.
   __ ldr(R0, FieldAddress(R2, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
   __ LeaveStubFrame();
 
   __ Bind(&function_compiled);
   // R0: code.
@@ skipping 14 matching lines @@
   // calling into the runtime.
   __ EnterStubFrame();
 
   // Setup space on stack for result from error reporting.
   __ PushList((1 << R4) | (1 << R8));  // Arguments descriptor and raw null.
 
   // Load smi-tagged arguments array length, including the non-closure.
   __ ldr(R2, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInvokeNonClosureRuntimeEntry);
+  __ CallRuntime(kInvokeNonClosureRuntimeEntry, 2);
   // Remove arguments.
   __ Drop(2);
   __ Pop(R0);  // Get result into R0.
 
   // Remove the stub frame as we are about to return.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
@@ skipping 202 matching lines @@
 
     __ Bind(&slow_case);
   }
   // 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.
   __ LoadImmediate(R2, reinterpret_cast<intptr_t>(Object::null()));
   __ SmiTag(R1);
   __ PushList((1 << R1) | (1 << R2));
-  __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
+  __ CallRuntime(kAllocateContextRuntimeEntry, 1);  // Allocate context.
   __ Drop(1);  // Pop number of context variables argument.
   __ Pop(R0);  // Pop the new context object.
   // R0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
@@ skipping 44 matching lines @@
   __ PopList((1 << R1) | (1 << R2) | (1 << R3));
   __ b(&L, EQ);
   __ Ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
 
   __ EnterCallRuntimeFrame(0 * kWordSize);
   __ ldr(R0, FieldAddress(CTX, Context::isolate_offset()));
-  __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry);
+  __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ Ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   LR : return address.
 //   SP + 4 : type arguments object (only if class is parameterized).
@@ skipping 144 matching lines @@
   __ Push(R2);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     // Push type arguments of object to be allocated and of instantiator.
     __ PushList((1 << R0) | (1 << R1));
   } else {
     // Push null type arguments and kNoInstantiator.
     __ LoadImmediate(R1, Smi::RawValue(StubCode::kNoInstantiator));
     __ PushList((1 << R1) | (1 << R2));
   }
-  __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
+  __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ Drop(3);  // Pop arguments.
   __ Pop(R0);  // Pop result (newly allocated object).
   // R0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame(true);
   __ Ret();
 }
 
 
 // Called for inline allocation of closures.
@@ skipping 112 matching lines @@
     __ ldr(R1, Address(FP, kReceiverFPOffset));
     __ Push(R1);  // Receiver.
   }
   // R0: raw null.
   if (has_type_arguments) {
     __ ldr(R0, Address(FP, kTypeArgumentsFPOffset));
   }
   __ Push(R0);  // Push type arguments of closure to be allocated or null.
 
   if (is_implicit_instance_closure) {
-    __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry);
+    __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry, 3);
     __ Drop(2);  // Pop arguments (type arguments of object and receiver).
   } else {
     ASSERT(func.IsNonImplicitClosureFunction());
-    __ CallRuntime(kAllocateClosureRuntimeEntry);
+    __ CallRuntime(kAllocateClosureRuntimeEntry, 2);
     __ Drop(1);  // Pop argument (type arguments of object).
   }
   __ Drop(1);  // Pop function object.
   __ Pop(R0);
   // R0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame(true);
   __ Ret();
 }
 
@@ skipping 17 matching lines @@
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R4) | (1 << R5) | (1 << R6) | (1 << IP));
 
   // R2: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry);
+  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry, 4);
   // Remove arguments.
   __ Drop(4);
   __ Pop(R0);  // Get result into R0.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 //  R6: function object.
 //  R5: 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) {
   Register ic_reg = R5;
   Register func_reg = R6;
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ PushList((1 << R5) | (1 << R6));  // Preserve.
     __ Push(ic_reg);  // Argument.
     __ Push(func_reg);  // Argument.
-    __ CallRuntime(kTraceICCallRuntimeEntry);
+    __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ Drop(2);  // Discard argument;
     __ PopList((1 << R5) | (1 << R6));  // Restore.
     __ LeaveStubFrame();
   }
   __ ldr(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
   __ add(R7, R7, ShifterOperand(1));
   __ str(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
 
@@ skipping 38 matching lines @@
 #endif  // DEBUG
 
   // Check single stepping.
   Label not_stepping;
   __ ldr(R6, FieldAddress(CTX, Context::isolate_offset()));
   __ ldrb(R6, Address(R6, Isolate::single_step_offset()));
   __ CompareImmediate(R6, 0);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
   __ Push(R5);  // Preserve IC data.
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ Pop(R5);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
 
   // Load arguments descriptor into R4.
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
   // Preserve return address, since LR is needed for subroutine call.
   __ mov(R8, ShifterOperand(LR));
   // Loop that checks if there is an IC data match.
   Label loop, update, test, found, get_class_id_as_smi;
@@ skipping 64 matching lines @@
   // Preserve IC data object and arguments descriptor array and
   // setup space on stack for result (target code object).
   __ PushList((1 << R0) | (1 << R4) | (1 << R5));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ LoadFromOffset(kWord, IP, R7, -i * kWordSize);
     __ Push(IP);
   }
   // Pass IC data object.
   __ Push(R5);
-  __ CallRuntime(handle_ic_miss);
+  __ CallRuntime(handle_ic_miss, num_args + 1);
   // Remove the call arguments pushed earlier, including the IC data object.
   __ Drop(num_args + 1);
   // Pop returned code object into R0 (null if not found).
   // Restore arguments descriptor array and IC data array.
   __ PopList((1 << R0) | (1 << R4) | (1 << R5));
   __ LeaveStubFrame();
   Label call_target_function;
   __ CompareImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   __ b(&call_target_function, NE);
   // NoSuchMethod or closure.
@@ skipping 120 matching lines @@
 #endif  // DEBUG
 
   // Check single stepping.
   Label not_stepping;
   __ ldr(R6, FieldAddress(CTX, Context::isolate_offset()));
   __ ldrb(R6, Address(R6, Isolate::single_step_offset()));
   __ CompareImmediate(R6, 0);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
   __ Push(R5);  // Preserve IC data.
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ Pop(R5);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
 
   // R5: IC data object (preserved).
   __ ldr(R6, FieldAddress(R5, ICData::ic_data_offset()));
   // R6: ic_data_array with entries: target functions and count.
   __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
   // R6: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
@@ skipping 14 matching lines @@
   __ LoadFromOffset(kWord, R1, R6, target_offset);
   __ ldr(R0, FieldAddress(R1, Function::code_offset()));
   __ CompareImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   __ b(&target_is_compiled, NE);
   // R1: function.
 
   __ EnterStubFrame();
   // Preserve target function and IC data object.
   __ PushList((1 << R1) | (1 << R5));
   __ Push(R1);  // Pass function.
-  __ CallRuntime(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ Drop(1);  // Discard argument.
   __ PopList((1 << R1) | (1 << R5));  // Restore function and IC data.
   __ LeaveStubFrame();
   // R0: target function.
   __ ldr(R0, FieldAddress(R1, Function::code_offset()));
 
   __ Bind(&target_is_compiled);
   // R0: target code.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, Instructions::HeaderSize() - kHeapObjectTag);
@@ skipping 17 matching lines @@
 
 //  LR: return address (Dart code).
 //  R5: IC data (unoptimized static call).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   // Preserve arguments descriptor and make room for result.
   __ PushList((1 << R0) | (1 << R5));
-  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry, 0);
   // Pop code object result and restore arguments descriptor.
   __ PopList((1 << R0) | (1 << R5));
   __ LeaveStubFrame();
 
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, Instructions::HeaderSize() - kHeapObjectTag);
   // Load arguments descriptor into R4.
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
   __ bx(R0);
 }
 
 
 //  R0: return value.
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ Push(R0);
-  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry, 0);
   __ Pop(R0);
   __ LeaveStubFrame();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
   __ LeaveDartFrame();
   __ Ret();
 }
 
 
 //  LR: return address (Dart code).
 //  R5: 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.
   __ EnterStubFrame();
   __ Push(R5);
-  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry, 0);
   __ Pop(R5);
   __ LeaveStubFrame();
 
   // Find out which dispatch stub to call.
   __ ldr(IP, FieldAddress(R5, ICData::num_args_tested_offset()));
   __ cmp(IP, ShifterOperand(1));
   __ Branch(&StubCode::OneArgCheckInlineCacheLabel(), EQ);
   __ cmp(IP, ShifterOperand(2));
   __ Branch(&StubCode::TwoArgsCheckInlineCacheLabel(), EQ);
   __ cmp(IP, ShifterOperand(3));
@@ skipping 206 matching lines @@
   __ bx(LR, EQ);
   __ LoadClassId(R2, R2);
   __ SmiTag(R2);
   __ bx(LR);
 
   __ Bind(&update_ic_data);
   // R5: ICData
   __ PushList((1 << R0) | (1 << R1));
   __ PushObject(Symbols::EqualOperator());  // Target's name.
   __ Push(R5);  // ICData
-  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry);  // Clobbers R4, R5.
+  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry, 4);  // Clobbers R4, R5.
   __ Drop(2);
   __ PopList((1 << R0) | (1 << R1));
   __ b(&compute_result);
 }
 
 
 // Calls to the runtime to optimize the given function.
 // R6: function to be reoptimized.
 // R4: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   __ EnterStubFrame();
   __ Push(R4);
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   __ Push(IP);  // Setup space on stack for return value.
   __ Push(R6);
-  __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
+  __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
   __ Pop(R0);  // Discard argument.
   __ Pop(R0);  // Get Code object
   __ Pop(R4);  // Restore argument descriptor.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, Instructions::HeaderSize() - kHeapObjectTag);
   __ LeaveStubFrame();
   __ bx(R0);
   __ bkpt(0);
 }
 
@@ skipping 53 matching lines @@
   __ b(&done);
 
   __ Bind(&check_bigint);
   __ CompareClassId(left, kBigintCid, temp);
   __ b(&reference_compare, NE);
   __ CompareClassId(right, kBigintCid, temp);
   __ b(&done, NE);
   __ EnterStubFrame(0);
   __ ReserveAlignedFrameSpace(2 * kWordSize);
   __ stm(IA, SP,  (1 << R0) | (1 << R1));
-  __ CallRuntime(kBigintCompareRuntimeEntry);
+  __ CallRuntime(kBigintCompareRuntimeEntry, 2);
   // Result in R0, 0 means equal.
   __ LeaveStubFrame();
   __ cmp(R0, ShifterOperand(0));
   __ b(&done);
 
   __ Bind(&reference_compare);
   __ cmp(left, ShifterOperand(right));
   __ Bind(&done);
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 // LR: return address.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Return Zero condition flag set if equal.
 void StubCode::GenerateUnoptimizedIdenticalWithNumberCheckStub(
     Assembler* assembler) {
   // Check single stepping.
   Label not_stepping;
   __ ldr(R1, FieldAddress(CTX, Context::isolate_offset()));
   __ ldrb(R1, Address(R1, Isolate::single_step_offset()));
   __ CompareImmediate(R1, 0);
   __ b(&not_stepping, EQ);
   __ EnterStubFrame();
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ LeaveStubFrame();
   __ Bind(&not_stepping);
 
   const Register temp = R2;
   const Register left = R1;
   const Register right = R0;
   __ ldr(left, Address(SP, 1 * kWordSize));
   __ ldr(right, Address(SP, 0 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ Ret();
@@ skipping 16 matching lines @@
   __ ldr(left, Address(SP, 4 * kWordSize));
   __ ldr(right, Address(SP, 3 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ PopList((1 << R0) | (1 << R1) | (1 << R2));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM