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

runtime/vm/stub_code_ia32.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_IA32)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 89 matching lines @@
 END_LEAF_RUNTIME_ENTRY
 
 
 // Input parameters:
 //   ESP : points to return address.
 //   EAX : stop message (const char*).
 // Must preserve all registers, except EAX.
 void StubCode::GeneratePrintStopMessageStub(Assembler* assembler) {
   __ EnterCallRuntimeFrame(1 * kWordSize);
   __ movl(Address(ESP, 0), EAX);
-  __ CallRuntime(kPrintStopMessageRuntimeEntry);
+  __ CallRuntime(kPrintStopMessageRuntimeEntry, 1);
   __ LeaveCallRuntimeFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : address of return value.
 //   EAX : address of first argument in argument array.
 //   ECX : address of the native function to call.
@@ skipping 135 matching lines @@
 
 
 // Input parameters:
 //   EDX: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(raw_null);  // Setup space on stack for return value.
-  __ CallRuntime(kPatchStaticCallRuntimeEntry);
+  __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
   __ popl(EAX);  // Get Code object result.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // EDX: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(raw_null);  // Setup space on stack for return value.
-  __ CallRuntime(kFixCallersTargetRuntimeEntry);
+  __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   __ popl(EAX);  // Get Code object.
   __ popl(EDX);  // Restore arguments descriptor array.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
 
 
@@ skipping 50 matching lines @@
   __ movl(EDI, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   __ pushl(Address(ESP, EDI, TIMES_2, (3 * kWordSize)));
 
   __ pushl(ECX);  // Pass IC data object.
   __ pushl(EDX);  // Pass arguments descriptor array.
 
   // Pass the call's arguments array.
   __ movl(EDX, EDI);  // Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry);
+  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry, 4);
 
   // Remove arguments.
   __ Drop(4);
   __ popl(EAX);  // Get result into EAX.
   __ LeaveFrame();
   __ ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
@@ skipping 44 matching lines @@
   intptr_t offset = 0;
   for (intptr_t reg_idx = 0; reg_idx < kNumberOfXmmRegisters; ++reg_idx) {
     XmmRegister xmm_reg = static_cast<XmmRegister>(reg_idx);
     __ movups(Address(ESP, offset), xmm_reg);
     offset += kFpuRegisterSize;
   }
 
   __ movl(ECX, ESP);  // Preserve saved registers block.
   __ ReserveAlignedFrameSpace(1 * kWordSize);
   __ movl(Address(ESP, 0), ECX);  // Start of register block.
-  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry);
+  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
   // Result (EAX) is stack-size (FP - SP) in bytes.
 
   if (preserve_result) {
     // Restore result into EBX temporarily.
     __ movl(EBX, Address(EBP, saved_result_slot_from_fp * kWordSize));
   }
 
   __ LeaveFrame();
   __ popl(EDX);  // Preserve return address.
   __ movl(ESP, EBP);  // Discard optimized frame.
   __ subl(ESP, EAX);  // Reserve space for deoptimized frame.
   __ pushl(EDX);  // Restore return address.
 
   // Leaf runtime function DeoptimizeFillFrame expects a Dart frame.
   __ EnterDartFrame(0);
   if (preserve_result) {
     __ pushl(EBX);  // Preserve result as first local.
   }
   __ ReserveAlignedFrameSpace(1 * kWordSize);
   __ movl(Address(ESP, 0), EBP);  // Pass last FP as parameter on stack.
-  __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry);
+  __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry, 1);
   if (preserve_result) {
     // Restore result into EBX.
     __ movl(EBX, Address(EBP, kFirstLocalSlotFromFp * kWordSize));
   }
   // Code above cannot cause GC.
   __ LeaveFrame();
 
   // 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) {
     __ pushl(EBX);  // Preserve result, it will be GC-d here.
   }
   __ pushl(Immediate(Smi::RawValue(0)));  // 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.
   __ popl(EBX);
   __ SmiUntag(EBX);
   if (preserve_result) {
     __ popl(EAX);  // Restore result.
   }
   __ LeaveFrame();
 
   __ popl(ECX);  // Pop return address.
@@ skipping 31 matching lines @@
   // Preserve IC data and arguments descriptor.
   __ pushl(ECX);
   __ pushl(EDX);
 
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Instructions::null()));
   __ pushl(raw_null);  // Space for the result of the runtime call.
   __ pushl(EAX);  // Pass receiver.
   __ pushl(ECX);  // Pass IC data.
   __ pushl(EDX);  // Pass arguments descriptor.
-  __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry);
+  __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
   // Discard arguments.
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);  // Return value from the runtime call (instructions).
   __ popl(EDX);  // Restore arguments descriptor.
   __ popl(ECX);  // Restore IC data.
   __ LeaveFrame();
 
   Label lookup;
@@ skipping 130 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();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDX);  // Array length as Smi.
   __ pushl(ECX);  // Element type.
-  __ CallRuntime(kAllocateArrayRuntimeEntry);
+  __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   __ popl(EAX);  // Pop element type argument.
   __ popl(EDX);  // Pop array length argument.
   __ popl(EAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   EDX: Arguments descriptor array.
@@ skipping 36 matching lines @@
   __ cmpl(EAX, raw_null);
   Label function_compiled;
   __ j(NOT_EQUAL, &function_compiled, Assembler::kNearJump);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve read-only function object argument.
-  __ CallRuntime(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ popl(ECX);  // Restore read-only function object argument in ECX.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Restore EAX.
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
   __ LeaveFrame();
 
   __ Bind(&function_compiled);
   // EAX: Code.
@@ skipping 15 matching lines @@
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   __ pushl(raw_null);  // Setup space on stack for result from error reporting.
   __ pushl(EDX);  // Arguments descriptor.
   // Load smi-tagged arguments array length, including the non-closure.
   __ movl(EDX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInvokeNonClosureRuntimeEntry);
+  __ CallRuntime(kInvokeNonClosureRuntimeEntry, 2);
   // Remove arguments.
   __ Drop(2);
   __ popl(EAX);  // Get result into EAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 }
 
 
@@ skipping 228 matching lines @@
     __ ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ SmiTag(EDX);
   __ pushl(EDX);
-  __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
+  __ CallRuntime(kAllocateContextRuntimeEntry, 1);  // Allocate context.
   __ popl(EAX);  // Pop number of context variables argument.
   __ popl(EAX);  // Pop the new context object.
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
 
@@ skipping 50 matching lines @@
   __ j(EQUAL, &L, Assembler::kNearJump);
   __ ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
 
   __ EnterCallRuntimeFrame(1 * kWordSize);
   __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
   __ movl(Address(ESP, 0), EAX);  // Push the isolate as the only argument.
-  __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry);
+  __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   ESP + 8 : type arguments object (only if class is parameterized).
 //   ESP + 4 : type arguments of instantiator (only if class is parameterized).
@@ skipping 149 matching lines @@
   __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushl(EAX);  // Push type arguments of object to be allocated.
     __ pushl(EDX);  // Push type arguments of instantiator.
   } else {
     __ pushl(raw_null);  // Push null type arguments.
     __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
-  __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
+  __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ popl(EAX);  // Pop argument (instantiator).
   __ popl(EAX);  // Pop argument (type arguments of object).
   __ popl(EAX);  // Pop argument (class of object).
   __ popl(EAX);  // Pop result (newly allocated object).
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
 
@@ skipping 113 matching lines @@
   __ PushObject(func);
   if (is_implicit_instance_closure) {
     __ pushl(EAX);  // Receiver.
   }
   if (has_type_arguments) {
     __ pushl(ECX);  // Push type arguments of closure to be allocated.
   } else {
     __ pushl(raw_null);  // Push null type arguments.
   }
   if (is_implicit_instance_closure) {
-    __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry);
+    __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry, 3);
     __ popl(EAX);  // Pop argument (type arguments of object).
     __ popl(EAX);  // Pop receiver.
   } else {
     ASSERT(func.IsNonImplicitClosureFunction());
-    __ CallRuntime(kAllocateClosureRuntimeEntry);
+    __ CallRuntime(kAllocateClosureRuntimeEntry, 2);
     __ popl(EAX);  // Pop argument (type arguments of object).
   }
   __ popl(EAX);  // Pop function object.
   __ popl(EAX);
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
 
@@ skipping 18 matching lines @@
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Setup space on stack for result from noSuchMethod.
   __ pushl(EAX);  // Receiver.
   __ pushl(ECX);  // IC data array.
   __ pushl(EDX);  // Arguments descriptor array.
 
   __ movl(EDX, EDI);
   // EDX: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
 
-  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry);
+  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry, 4);
 
   // Remove arguments.
   __ Drop(4);
   __ popl(EAX);  // Get result into EAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // 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 = ECX;
   Register func_reg = EDI;
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ pushl(func_reg);     // Preserve
     __ pushl(ic_reg);       // Preserve.
     __ pushl(ic_reg);       // Argument.
     __ pushl(func_reg);     // Argument.
-    __ CallRuntime(kTraceICCallRuntimeEntry);
+    __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ popl(EAX);          // Discard argument;
     __ popl(EAX);          // Discard argument;
     __ popl(ic_reg);       // Restore.
     __ popl(func_reg);     // Restore.
     __ LeaveFrame();
   }
   __ incl(FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
 
@@ skipping 37 matching lines @@
 
   // Check single stepping.
   Label not_stepping;
   __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
   __ movzxb(EAX, Address(EAX, Isolate::single_step_offset()));
   __ cmpl(EAX, Immediate(0));
   __ j(EQUAL, &not_stepping, Assembler::kNearJump);
 
   __ EnterStubFrame();
   __ pushl(ECX);
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ popl(ECX);
   __ LeaveFrame();
   __ Bind(&not_stepping);
 
   // ECX: IC data object (preserved).
   // Load arguments descriptor into EDX.
   __ movl(EDX, FieldAddress(ECX, ICData::arguments_descriptor_offset()));
   // Loop that checks if there is an IC data match.
   Label loop, update, test, found, get_class_id_as_smi;
   // ECX: IC data object (preserved).
@@ skipping 58 matching lines @@
   __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve IC data object.
   __ pushl(raw_null);  // Setup space on stack for result (target code object).
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ movl(EBX, Address(EAX, -kWordSize * i));
     __ pushl(EBX);
   }
   __ pushl(ECX);  // Pass IC data object.
-  __ CallRuntime(handle_ic_miss);
+  __ CallRuntime(handle_ic_miss, num_args + 1);
   // Remove the call arguments pushed earlier, including the IC data object.
   for (intptr_t i = 0; i < num_args + 1; i++) {
     __ popl(EAX);
   }
   __ popl(EAX);  // Pop returned code object into EAX (null if not found).
   __ popl(ECX);  // Restore IC data array.
   __ popl(EDX);  // Restore arguments descriptor array.
   __ LeaveFrame();
   Label call_target_function;
   __ cmpl(EAX, raw_null);
@@ skipping 136 matching lines @@
 #endif  // DEBUG
   // Check single stepping.
   Label not_stepping;
   __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
   __ movzxb(EAX, Address(EAX, Isolate::single_step_offset()));
   __ cmpl(EAX, Immediate(0));
   __ j(EQUAL, &not_stepping, Assembler::kNearJump);
 
   __ EnterStubFrame();
   __ pushl(ECX);
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ popl(ECX);
   __ LeaveFrame();
   __ Bind(&not_stepping);
 
   // ECX: IC data object (preserved).
   __ movl(EBX, FieldAddress(ECX, ICData::ic_data_offset()));
   // EBX: ic_data_array with entries: target functions and count.
   __ leal(EBX, FieldAddress(EBX, Array::data_offset()));
   // EBX: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
@@ skipping 11 matching lines @@
   Label target_is_compiled;
   // Get function and call it, if possible.
   __ movl(EDI, Address(EBX, target_offset));
   __ movl(EAX, FieldAddress(EDI, Function::code_offset()));
   __ cmpl(EAX, raw_null);
   __ j(NOT_EQUAL, &target_is_compiled, Assembler::kNearJump);
   __ EnterStubFrame();
   __ pushl(EDI);  // Preserve target function.
   __ pushl(ECX);  // Preserve IC data object.
   __ pushl(EDI);  // Pass function.
-  __ CallRuntime(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ popl(EAX);  // Discard argument.
   __ popl(ECX);  // Restore IC data object.
   __ popl(EDI);  // Restore target function.
   __ LeaveFrame();
   __ movl(EAX, FieldAddress(EDI, Function::code_offset()));
 
   __ Bind(&target_is_compiled);
   // EAX: Target code.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
@@ skipping 14 matching lines @@
 void StubCode::GenerateBreakpointRuntimeStub(Assembler* assembler) {
   __ EnterStubFrame();
   // Save runtime args.
   __ pushl(ECX);
   __ pushl(EDX);
   // Room for result. Debugger stub returns address of the
   // unpatched runtime stub.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Room for result.
-  __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry, 0);
   __ popl(EAX);  // Address of original stub.
   __ popl(EDX);  // Restore arguments.
   __ popl(ECX);
   __ LeaveFrame();
   __ jmp(EAX);   // Jump to original stub.
 }
 
 
 // ECX: ICData (unoptimized static call).
 // TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ pushl(ECX);  // Preserve ICData for unoptimized call.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Room for result.
-  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry, 0);
   __ popl(EAX);  // Code object.
   __ popl(ECX);  // Restore ICData.
   __ LeaveFrame();
 
   // Load arguments descriptor into EDX.
   __ movl(EDX, FieldAddress(ECX, ICData::arguments_descriptor_offset()));
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   // Note that we can't just jump to the CallStatic function stub
   // here since that stub would patch the call site with the
   // static function address.
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ pushl(EAX);
-  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry, 0);
   __ popl(EAX);
   __ LeaveFrame();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
   __ popl(ECX);  // Discard return address to patched dart code.
   // Execute function epilog code that was smashed in the Dart code.
   __ LeaveFrame();
   __ ret();
 }
 
 
 //  ECX: Inline cache data array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ pushl(ECX);
-  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry, 0);
   __ popl(ECX);
   __ LeaveFrame();
 
   // Find out which dispatch stub to call.
   Label test_two, test_three, test_four;
   __ movl(EBX, FieldAddress(ECX, ICData::num_args_tested_offset()));
   __ cmpl(EBX, Immediate(1));
   __ j(NOT_EQUAL, &test_two, Assembler::kNearJump);
   __ jmp(&StubCode::OneArgCheckInlineCacheLabel());
   __ Bind(&test_two);
@@ skipping 232 matching lines @@
   __ Bind(&update_ic_data);
 
   // ECX: ICData
   __ movl(EAX, Address(ESP, 1 * kWordSize));
   __ movl(EDI, Address(ESP, 2 * kWordSize));
   __ EnterStubFrame();
   __ pushl(EDI);  // arg 0
   __ pushl(EAX);  // arg 1
   __ PushObject(Symbols::EqualOperator());  // Target's name.
   __ pushl(ECX);  // ICData
-  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry);
+  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry, 4);
   __ Drop(4);
   __ LeaveFrame();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 
 // Calls to the runtime to optimize the given function.
 // EDI: function to be reoptimized.
 // EDX: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
   __ pushl(EDX);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDI);
-  __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
+  __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
   __ popl(EAX);  // Discard argument.
   __ popl(EAX);  // Get Code object
   __ popl(EDX);  // Restore argument descriptor.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
 
@@ skipping 49 matching lines @@
 
   __ Bind(&check_bigint);
   __ CompareClassId(left, kBigintCid, temp);
   __ j(NOT_EQUAL, &reference_compare, Assembler::kNearJump);
   __ CompareClassId(right, kBigintCid, temp);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ EnterFrame(0);
   __ ReserveAlignedFrameSpace(2 * kWordSize);
   __ movl(Address(ESP, 1 * kWordSize), left);
   __ movl(Address(ESP, 0 * kWordSize), right);
-  __ CallRuntime(kBigintCompareRuntimeEntry);
+  __ CallRuntime(kBigintCompareRuntimeEntry, 2);
   // Result in EAX, 0 means equal.
   __ LeaveFrame();
   __ cmpl(EAX, Immediate(0));
   __ jmp(&done);
 
   __ Bind(&reference_compare);
   __ cmpl(left, right);
   __ Bind(&done);
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 // TOS + 0: return address
 // TOS + 1: right argument.
 // TOS + 2: left argument.
 // Returns ZF set.
 void StubCode::GenerateUnoptimizedIdenticalWithNumberCheckStub(
     Assembler* assembler) {
   // Check single stepping.
   Label not_stepping;
   __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
   __ movzxb(EAX, Address(EAX, Isolate::single_step_offset()));
   __ cmpl(EAX, Immediate(0));
   __ j(EQUAL, &not_stepping, Assembler::kNearJump);
 
   __ EnterStubFrame();
-  __ CallRuntime(kSingleStepHandlerRuntimeEntry);
+  __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ LeaveFrame();
   __ Bind(&not_stepping);
 
   const Register left = EAX;
   const Register right = EDX;
   const Register temp = ECX;
   __ movl(left, Address(ESP, 2 * kWordSize));
   __ movl(right, Address(ESP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
@@ skipping 20 matching lines @@
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ popl(temp);
   __ popl(right);
   __ popl(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32