Move the assertion checking the number of arguments passed to a runtime entry

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 44 matching lines @@
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(bool, trace_type_checks);
 
 DEFINE_FLAG(bool, use_osr, true, "Use on-stack replacement.");
 DEFINE_FLAG(bool, trace_osr, false, "Trace attempts at on-stack replacement.");
 
 
 DEFINE_RUNTIME_ENTRY(TraceFunctionEntry, 1) {
-  ASSERT(arguments.ArgCount() ==
-      kTraceFunctionEntryRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   const String& function_name = String::Handle(function.name());
   const String& class_name =
       String::Handle(Class::Handle(function.Owner()).Name());
   OS::PrintErr("> Entering '%s.%s'\n",
       class_name.ToCString(), function_name.ToCString());
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceFunctionExit, 1) {
-  ASSERT(arguments.ArgCount() ==
-      kTraceFunctionExitRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   const String& function_name = String::Handle(function.name());
   const String& class_name =
       String::Handle(Class::Handle(function.Owner()).Name());
   OS::PrintErr("< Exiting '%s.%s'\n",
       class_name.ToCString(), function_name.ToCString());
 }
 
 
 // Allocation of a fixed length array of given element type.
 // This runtime entry is never called for allocating a List of a generic type,
 // because a prior run time call instantiates the element type if necessary.
 // Arg0: array length.
 // Arg1: array type arguments, i.e. vector of 1 type, the element type.
 // Return value: newly allocated array of length arg0.
 DEFINE_RUNTIME_ENTRY(AllocateArray, 2) {
-  ASSERT(arguments.ArgCount() == kAllocateArrayRuntimeEntry.argument_count());
   const Smi& length = Smi::CheckedHandle(arguments.ArgAt(0));
   const Array& array = Array::Handle(Array::New(length.Value()));
   arguments.SetReturn(array);
   AbstractTypeArguments& element_type =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   // An Array is raw or takes one type argument. However, its type argument
   // vector may be longer than 1 due to a type optimization reusing the type
   // argument vector of the instantiator.
   ASSERT(element_type.IsNull() ||
          ((element_type.Length() >= 1) && element_type.IsInstantiated()));
   array.SetTypeArguments(element_type);  // May be null.
 }
 
 
 // Allocate a new object.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObject, 3) {
-  ASSERT(arguments.ArgCount() == kAllocateObjectRuntimeEntry.argument_count());
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
   if (!cls.HasTypeArguments()) {
     // No type arguments required for a non-parameterized type.
     ASSERT(Instance::CheckedHandle(arguments.ArgAt(1)).IsNull());
     return;
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
@@ skipping 34 matching lines @@
 
 
 // Allocate a new object of a generic type and check that the instantiated type
 // arguments are within the declared bounds or throw a dynamic type error.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObjectWithBoundsCheck, 3) {
   ASSERT(FLAG_enable_type_checks);
-  ASSERT(arguments.ArgCount() ==
-         kAllocateObjectWithBoundsCheckRuntimeEntry.argument_count());
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
   ASSERT(cls.HasTypeArguments());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
     ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
     // Unless null (for a raw type), the type argument vector may be longer than
@@ skipping 29 matching lines @@
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type.
 // Arg0: uninstantiated type.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type.
 DEFINE_RUNTIME_ENTRY(InstantiateType, 2) {
-  ASSERT(arguments.ArgCount() == kInstantiateTypeRuntimeEntry.argument_count());
   AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(0));
   const AbstractTypeArguments& instantiator =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(!type.IsNull() && !type.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   Error& malformed_error = Error::Handle();
   type = type.InstantiateFrom(instantiator, &malformed_error);
   if (!malformed_error.IsNull()) {
     // Throw a dynamic type error.
     const intptr_t location = GetCallerLocation();
     String& malformed_error_message =  String::Handle(
         String::New(malformed_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(
         location, Symbols::Empty(), Symbols::Empty(),
         Symbols::Empty(), malformed_error_message);
     UNREACHABLE();
   }
   ASSERT(!type.IsNull() && type.IsInstantiated());
   arguments.SetReturn(type);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
-  ASSERT(arguments.ArgCount() ==
-         kInstantiateTypeArgumentsRuntimeEntry.argument_count());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(0));
   const AbstractTypeArguments& instantiator =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(!type_arguments.IsNull() && !type_arguments.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   // Code inlined in the caller should have optimized the case where the
   // instantiator can be reused as type argument vector.
   ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
   type_arguments = InstantiatedTypeArguments::New(type_arguments, instantiator);
   ASSERT(type_arguments.IsInstantiated());
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new closure.
 // The type argument vector of a closure is always the vector of type parameters
 // of its signature class, i.e. an uninstantiated identity vector. Therefore,
 // the instantiator type arguments can be used as the instantiated closure type
 // arguments and is passed here as the type arguments.
 // Arg0: local function.
 // Arg1: type arguments of the closure (i.e. instantiator).
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateClosure, 2) {
-  ASSERT(arguments.ArgCount() == kAllocateClosureRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(function.IsClosureFunction() && !function.IsImplicitClosureFunction());
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   // The current context was saved in the Isolate structure when entering the
   // runtime.
   const Context& context = Context::Handle(isolate->top_context());
   ASSERT(!context.IsNull());
   const Instance& closure = Instance::Handle(Closure::New(function, context));
   Closure::SetTypeArguments(closure, type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new implicit instance closure.
 // Arg0: local function.
 // Arg1: receiver object.
 // Arg2: type arguments of the closure.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitInstanceClosure, 3) {
-  ASSERT(arguments.ArgCount() ==
-         kAllocateImplicitInstanceClosureRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(function.IsImplicitInstanceClosureFunction());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(1));
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   Context& context = Context::Handle();
   context = Context::New(1);
   context.SetAt(0, receiver);
   const Instance& closure = Instance::Handle(Closure::New(function, context));
   Closure::SetTypeArguments(closure, type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new context large enough to hold the given number of variables.
 // Arg0: number of variables.
 // Return value: newly allocated context.
 DEFINE_RUNTIME_ENTRY(AllocateContext, 1) {
-  ASSERT(arguments.ArgCount() == kAllocateContextRuntimeEntry.argument_count());
   const Smi& num_variables = Smi::CheckedHandle(arguments.ArgAt(0));
   arguments.SetReturn(Context::Handle(Context::New(num_variables.Value())));
 }
 
 
 // Make a copy of the given context, including the values of the captured
 // variables.
 // Arg0: the context to be cloned.
 // Return value: newly allocated context.
 DEFINE_RUNTIME_ENTRY(CloneContext, 1) {
-  ASSERT(arguments.ArgCount() == kCloneContextRuntimeEntry.argument_count());
   const Context& ctx = Context::CheckedHandle(arguments.ArgAt(0));
   Context& cloned_ctx = Context::Handle(Context::New(ctx.num_variables()));
   cloned_ctx.set_parent(Context::Handle(ctx.parent()));
   for (int i = 0; i < ctx.num_variables(); i++) {
     cloned_ctx.SetAt(i, Instance::Handle(ctx.At(i)));
   }
   arguments.SetReturn(cloned_ctx);
 }
 
 
@@ skipping 206 matching lines @@
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: instance being checked.
 // Arg1: type.
 // Arg2: instantiator (or null).
 // Arg3: type arguments of the instantiator of the type.
 // Arg4: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
 DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
-  ASSERT(arguments.ArgCount() == kInstanceofRuntimeEntry.argument_count());
   const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
   const AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(1));
   const Instance& instantiator = Instance::CheckedHandle(arguments.ArgAt(2));
   const AbstractTypeArguments& instantiator_type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(arguments.ArgAt(4));
   ASSERT(type.IsFinalized());
   Error& malformed_error = Error::Handle();
   const Bool& result =
@@ skipping 23 matching lines @@
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
 // Arg0: instance being assigned.
 // Arg1: type being assigned to.
 // Arg2: instantiator (or null).
 // Arg3: type arguments of the instantiator of the type being assigned to.
 // Arg4: name of variable being assigned to.
 // Arg5: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
 DEFINE_RUNTIME_ENTRY(TypeCheck, 6) {
-  ASSERT(arguments.ArgCount() == kTypeCheckRuntimeEntry.argument_count());
   const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
   const AbstractType& dst_type =
       AbstractType::CheckedHandle(arguments.ArgAt(1));
   const Instance& dst_instantiator =
       Instance::CheckedHandle(arguments.ArgAt(2));
   const AbstractTypeArguments& instantiator_type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
   const String& dst_name = String::CheckedHandle(arguments.ArgAt(4));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(arguments.ArgAt(5));
@@ skipping 39 matching lines @@
                       dst_instantiator, instantiator_type_arguments,
                       Bool::True(), cache);
   arguments.SetReturn(src_instance);
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
 // Arg0: bad object.
 // Return value: none, throws a TypeError.
 DEFINE_RUNTIME_ENTRY(ConditionTypeError, 1) {
-  ASSERT(arguments.ArgCount() ==
-      kConditionTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolType());
   const AbstractType& src_type = AbstractType::Handle(src_instance.GetType());
   const String& src_type_name = String::Handle(src_type.UserVisibleName());
   const String& bool_type_name =
       String::Handle(bool_interface.UserVisibleName());
   const String& no_malformed_type_error = String::Handle();
   Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
                                       Symbols::BooleanExpression(),
                                       no_malformed_type_error);
   UNREACHABLE();
 }
 
 
 // Report that the type of the type check is malformed.
 // Arg0: src value.
 // Arg1: name of instance being assigned to.
 // Arg2: malformed type error message.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(MalformedTypeError, 3) {
-  ASSERT(arguments.ArgCount() ==
-      kMalformedTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_value = Instance::CheckedHandle(arguments.ArgAt(0));
   const String& dst_name = String::CheckedHandle(arguments.ArgAt(1));
   const String& malformed_error = String::CheckedHandle(arguments.ArgAt(2));
   const AbstractType& src_type = AbstractType::Handle(src_value.GetType());
   const String& src_type_name = String::Handle(src_type.UserVisibleName());
   Exceptions::CreateAndThrowTypeError(location, src_type_name,
                                       Symbols::Malformed(),
                                       dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
-  ASSERT(arguments.ArgCount() == kThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   Exceptions::Throw(exception);
 }
 
 
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
-  ASSERT(arguments.ArgCount() == kReThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& stacktrace = Instance::CheckedHandle(arguments.ArgAt(1));
   Exceptions::ReThrow(exception, stacktrace);
 }
 
 
 // Patches static call in optimized code with the target's entry point.
 // Compiles target if necessary.
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
-  ASSERT(arguments.ArgCount() == kPatchStaticCallRuntimeEntry.argument_count());
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& caller_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
   if (!target_function.HasCode()) {
     const Error& error =
@@ skipping 53 matching lines @@
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint
 // set on a runtime stub call.
 DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
-  ASSERT(arguments.ArgCount() ==
-         kBreakpointRuntimeHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   uword orig_stub =
       isolate->debugger()->GetPatchedStubAddress(caller_frame->pc());
   isolate->debugger()->SignalBpReached();
   ASSERT((orig_stub & kSmiTagMask) == kSmiTag);
   arguments.SetReturn(Smi::Handle(reinterpret_cast<RawSmi*>(orig_stub)));
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint.
 DEFINE_RUNTIME_ENTRY(BreakpointStaticHandler, 0) {
-  ASSERT(arguments.ArgCount() ==
-      kBreakpointStaticHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
   // Make sure the static function that is about to be called is
   // compiled. The stub will jump to the entry point without any
   // further tests.
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(!code.is_optimized());
   const Function& function =
       Function::Handle(CodePatcher::GetUnoptimizedStaticCallAt(
           caller_frame->pc(), code, NULL));
 
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   arguments.SetReturn(Code::ZoneHandle(function.CurrentCode()));
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint at a return
 // in Dart code.
 DEFINE_RUNTIME_ENTRY(BreakpointReturnHandler, 0) {
-  ASSERT(arguments.ArgCount() ==
-         kBreakpointReturnHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint.
 DEFINE_RUNTIME_ENTRY(BreakpointDynamicHandler, 0) {
-  ASSERT(arguments.ArgCount() ==
-     kBreakpointDynamicHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
 }
 
 
 DEFINE_RUNTIME_ENTRY(SingleStepHandler, 0) {
-  ASSERT(arguments.ArgCount() ==
-         kSingleStepHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SingleStepCallback();
 }
 
 
 static RawFunction* InlineCacheMissHandler(
     const GrowableArray<const Instance*>& args,
     const ICData& ic_data) {
   const Instance& receiver = *args[0];
   const Code& target_code =
@@ skipping 47 matching lines @@
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: IC data object.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerOneArg, 2) {
-  ASSERT(arguments.ArgCount() ==
-      kInlineCacheMissHandlerOneArgRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   GrowableArray<const Instance*> args(1);
   args.Add(&receiver);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(args, ic_data));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: IC data object.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerTwoArgs, 3) {
-  ASSERT(arguments.ArgCount() ==
-      kInlineCacheMissHandlerTwoArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& other = Instance::CheckedHandle(arguments.ArgAt(1));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(2));
   GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&other);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(args, ic_data));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: Second argument after receiver.
 //   Arg3: IC data object.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerThreeArgs, 4) {
-  ASSERT(arguments.ArgCount() ==
-      kInlineCacheMissHandlerThreeArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const Instance& arg2 = Instance::CheckedHandle(arguments.ArgAt(2));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(3));
   GrowableArray<const Instance*> args(3);
   args.Add(&receiver);
   args.Add(&arg1);
   args.Add(&arg2);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(args, ic_data));
   arguments.SetReturn(result);
 }
 
 
 // Handles a static call in unoptimized code that has two argument types not
 // seen before. Compile the target if necessary and update the ICData.
 // Arg0: argument 0.
 // Arg1: argument 1.
 // Arg2: IC data object.
 DEFINE_RUNTIME_ENTRY(StaticCallMissHandlerTwoArgs, 3) {
-  ASSERT(arguments.ArgCount() ==
-      kStaticCallMissHandlerTwoArgsRuntimeEntry.argument_count());
   const Instance& arg0 = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(2));
   // IC data for static call is prepopulated with the statically known target.
   ASSERT(ic_data.NumberOfChecks() > 0);
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (!target.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(target));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
@@ skipping 18 matching lines @@
 
 // Handle a miss of a megamorphic cache.
 //   Arg0: Receiver.
 //   Arg1: ICData object.
 //   Arg2: Arguments descriptor array.
 
 //   Returns: target instructions to call or null if the
 // InstanceFunctionLookup stub should be used (e.g., to invoke no such
 // method and implicit closures)..
 DEFINE_RUNTIME_ENTRY(MegamorphicCacheMissHandler, 3) {
-  ASSERT(arguments.ArgCount() ==
-     kMegamorphicCacheMissHandlerRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const Array& descriptor = Array::CheckedHandle(arguments.ArgAt(2));
   const String& name = String::Handle(ic_data.target_name());
   const MegamorphicCache& cache = MegamorphicCache::Handle(
       isolate->megamorphic_cache_table()->Lookup(name, descriptor));
   Class& cls = Class::Handle(receiver.clazz());
   ASSERT(!cls.IsNull());
   if (FLAG_trace_ic || FLAG_trace_ic_miss_in_optimized) {
     OS::PrintErr("Megamorphic IC miss, class=%s, function=%s\n",
@@ skipping 27 matching lines @@
 }
 
 
 // Updates IC data for two arguments. Used by the equality operation when
 // the control flow bypasses regular inline cache (null arguments).
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: Target's name.
 //   Arg3: ICData.
 DEFINE_RUNTIME_ENTRY(UpdateICDataTwoArgs, 4) {
-  ASSERT(arguments.ArgCount() ==
-      kUpdateICDataTwoArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const String& target_name = String::CheckedHandle(arguments.ArgAt(2));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(3));
   GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&arg1);
   const intptr_t kNumArguments = 2;
     ArgumentsDescriptor args_desc(
         Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
   const Function& target_function = Function::Handle(
       Resolver::ResolveDynamic(receiver,
                                target_name,
                                args_desc));
   ASSERT(!target_function.IsNull());
   GrowableArray<intptr_t> class_ids(kNumArguments);
   ASSERT(ic_data.num_args_tested() == kNumArguments);
   class_ids.Add(receiver.GetClassId());
   class_ids.Add(arg1.GetClassId());
   ic_data.AddCheck(class_ids, target_function);
 }
 
 
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver.
 // Arg1: ic-data.
 // Arg2: arguments descriptor array.
 // Arg3: arguments array.
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodFunction, 4) {
-  ASSERT(arguments.ArgCount() ==
-         kInvokeNoSuchMethodFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const Array& orig_arguments_desc = Array::CheckedHandle(arguments.ArgAt(2));
   const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(3));
 
   String& original_function_name = String::Handle(ic_data.target_name());
   if (receiver.IsClosure()) {
     // For closure the function name is always 'call'. Replace it with the
     // name of the closurized function so that exception contains more
     // relevant information.
     const Function& function = Function::Handle(Closure::function(receiver));
     original_function_name = function.QualifiedUserVisibleName();
   }
   const Object& result = Object::Handle(
       DartEntry::InvokeNoSuchMethod(receiver,
                                     original_function_name,
                                     orig_arguments,
                                     orig_arguments_desc));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
 // A non-closure object was invoked as a closure, so call the "call" method
 // on it.
 // Arg0: arguments descriptor.
 // Arg1: arguments array, including non-closure object.
 DEFINE_RUNTIME_ENTRY(InvokeNonClosure, 2) {
-  ASSERT(arguments.ArgCount() ==
-         kInvokeNonClosureRuntimeEntry.argument_count());
   const Array& args_descriptor = Array::CheckedHandle(arguments.ArgAt(0));
   const Array& function_args = Array::CheckedHandle(arguments.ArgAt(1));
 
   const Object& result = Object::Handle(
       DartEntry::InvokeClosure(function_args, args_descriptor));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
@@ skipping 49 matching lines @@
 // 1. If the call was a getter o.f, there may be an instance function with
 //    the same name.  If so, create an implicit closure and return it.
 //
 // 2. If the call was an instance call o.f(...), there may be a getter with
 //    the same name.  If so, invoke it.  If the value is a closure, invoke
 //    it with the given arguments.  If the value is a non-closure, attempt
 //    to invoke "call" on it.
 //
 // 3. There is no such method.
 DEFINE_RUNTIME_ENTRY(InstanceFunctionLookup, 4) {
-  ASSERT(arguments.ArgCount() ==
-         kInstanceFunctionLookupRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const Array& args_descriptor = Array::CheckedHandle(arguments.ArgAt(2));
   const Array& args = Array::CheckedHandle(arguments.ArgAt(3));
 
   const Class& receiver_class = Class::Handle(receiver.clazz());
   const String& target_name = String::Handle(ic_data.target_name());
 
   Object& result = Object::Handle();
   if (!ResolveCallThroughGetter(receiver,
@@ skipping 83 matching lines @@
     }
     // TODO(5442338): Abort as this should not happen.
     function.set_usage_counter(kLowInvocationCount);
     return false;
   }
   return true;
 }
 
 
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
-  ASSERT(arguments.ArgCount() ==
-         kStackOverflowRuntimeEntry.argument_count());
 #if defined(USING_SIMULATOR)
   uword stack_pos = Simulator::Current()->get_register(SPREG);
 #else
   uword stack_pos = reinterpret_cast<uword>(&arguments);
 #endif
 
   // If an interrupt happens at the same time as a stack overflow, we
   // process the stack overflow first.
   if (stack_pos < isolate->saved_stack_limit()) {
     // Use the preallocated stack overflow exception to avoid calling
@@ skipping 65 matching lines @@
       uword optimized_entry =
           Instructions::Handle(optimized_code.instructions()).EntryPoint();
       function.SetCode(original_code);
       frame->set_pc(optimized_entry);
     }
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
-  ASSERT(arguments.ArgCount() ==
-         kTraceICCallRuntimeEntry.argument_count());
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   OS::PrintErr("IC call @%#" Px ": ICData: %p cnt:%" Pd " nchecks: %" Pd
       " %s %s\n",
       frame->pc(),
       ic_data.raw(),
       function.usage_counter(),
       ic_data.NumberOfChecks(),
       ic_data.is_closure_call() ? "closure" : "",
       function.ToFullyQualifiedCString());
 }
 
 
 // This is called from function that needs to be optimized.
 // The requesting function can be already optimized (reoptimization).
 // Returns the Code object where to continue execution.
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
-  ASSERT(arguments.ArgCount() ==
-         kOptimizeInvokedFunctionRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(!function.IsNull());
 
   if (CanOptimizeFunction(function, isolate)) {
     const Error& error =
         Error::Handle(Compiler::CompileOptimizedFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
     const Code& optimized_code = Code::Handle(function.CurrentCode());
     ASSERT(!optimized_code.IsNull());
     // Reset usage counter for reoptimization.
     function.set_usage_counter(0);
   }
   arguments.SetReturn(Code::Handle(function.CurrentCode()));
 }
 
 
 // The caller must be a static call in a Dart frame, or an entry frame.
 // Patch static call to point to valid code's entry point.
 DEFINE_RUNTIME_ENTRY(FixCallersTarget, 0) {
-  ASSERT(arguments.ArgCount() ==
-      kFixCallersTargetRuntimeEntry.argument_count());
-
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL && (frame->IsStubFrame() || frame->IsExitFrame())) {
     frame = iterator.NextFrame();
   }
   ASSERT(frame != NULL);
   if (frame->IsEntryFrame()) {
     // Since function's current code is always unpatched, the entry frame always
     // calls to unpatched code.
     UNREACHABLE();
@@ skipping 418 matching lines @@
   UNIMPLEMENTED();
   return Field::kNoFixedLength;
 }
 
 
 // Update global type feedback recorded for a field recording the assignment
 // of the given value.
 //   Arg0: Field object;
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
-  ASSERT(arguments.ArgCount() == kUpdateFieldCidRuntimeEntry.argument_count());
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
   const intptr_t cid = value.GetClassId();
   field.UpdateCid(cid);
   intptr_t list_length = Field::kNoFixedLength;
   if ((field.guarded_cid() != kDynamicCid) &&
       field.is_final() && RawObject::IsBuiltinListClassId(cid)) {
     list_length = GetListLength(value);
   }
   field.UpdateLength(list_length);
 }
 
 }  // namespace dart