Fix native argument handling

runtime/vm/code_generator.cc

 // Copyright (c) 2012, 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_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 38 matching lines @@
     "Traces all failed optimization attempts");
 DEFINE_FLAG(bool, trace_optimized_ic_calls, false,
     "Trace IC calls in optimized code.");
 DEFINE_FLAG(int, reoptimization_counter_threshold, 2000,
     "Counter threshold before a function gets reoptimized.");
 DEFINE_FLAG(int, max_subtype_cache_entries, 100,
     "Maximum number of subtype cache entries (number of checks cached).");
 
 
 DEFINE_RUNTIME_ENTRY(TraceFunctionEntry, 1) {
-  ASSERT(arguments.Count() == kTraceFunctionEntryRuntimeEntry.argument_count());
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  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::Print("> Entering '%s.%s'\n",
       class_name.ToCString(), function_name.ToCString());
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceFunctionExit, 1) {
-  ASSERT(arguments.Count() == kTraceFunctionExitRuntimeEntry.argument_count());
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  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::Print("< 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 element type.
 // Return value: newly allocated array of length arg0.
 DEFINE_RUNTIME_ENTRY(AllocateArray, 2) {
-  ASSERT(arguments.Count() == kAllocateArrayRuntimeEntry.argument_count());
-  const Smi& length = Smi::CheckedHandle(arguments.At(0));
+  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.At(1));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   // An Array is raw or takes only one type argument.
   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.Count() == kAllocateObjectRuntimeEntry.argument_count());
-  const Class& cls = Class::CheckedHandle(arguments.At(0));
+  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.At(1)).IsNull());
+    ASSERT(Instance::CheckedHandle(arguments.ArgAt(1)).IsNull());
     return;
   }
   AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.At(1));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   // If no instantiator is provided, set the type arguments and return.
-  if (Object::Handle(arguments.At(2)).IsSmi()) {
-    ASSERT(Smi::CheckedHandle(arguments.At(2)).Value() ==
+  if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
+    ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
     instance.SetTypeArguments(type_arguments);  // May be null.
     return;
   }
   ASSERT(!type_arguments.IsInstantiated());
   const AbstractTypeArguments& instantiator =
-      AbstractTypeArguments::CheckedHandle(arguments.At(2));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   if (instantiator.IsNull()) {
     type_arguments =
         InstantiatedTypeArguments::New(type_arguments, instantiator);
   } else if (instantiator.IsTypeArguments()) {
     // Code inlined in the caller should have optimized the case where the
     // instantiator is a TypeArguments and can be used as type argument vector.
     ASSERT(!type_arguments.IsUninstantiatedIdentity() ||
            (instantiator.Length() != type_arguments.Length()));
     type_arguments =
@@ skipping 32 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.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kAllocateObjectWithBoundsCheckRuntimeEntry.argument_count());
-  const Class& cls = Class::CheckedHandle(arguments.At(0));
+  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.At(1));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   AbstractTypeArguments& bounds_instantiator = AbstractTypeArguments::Handle();
-  if (Object::Handle(arguments.At(2)).IsSmi()) {
-    ASSERT(Smi::CheckedHandle(arguments.At(2)).Value() ==
+  if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
+    ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
   } else {
     ASSERT(!type_arguments.IsInstantiated());
     const AbstractTypeArguments& instantiator =
-        AbstractTypeArguments::CheckedHandle(arguments.At(2));
+        AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
     ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
     if (instantiator.IsNull()) {
       type_arguments =
           InstantiatedTypeArguments::New(type_arguments, instantiator);
     } else if (instantiator.IsTypeArguments()) {
       // Code inlined in the caller should have optimized the case where the
       // instantiator is a TypeArguments and can be used as type argument
       // vector.
       ASSERT(!type_arguments.IsUninstantiatedIdentity() ||
              (instantiator.Length() != type_arguments.Length()));
@@ skipping 30 matching lines @@
   }
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kInstantiateTypeArgumentsRuntimeEntry.argument_count());
   AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.At(0));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(0));
   const AbstractTypeArguments& instantiator =
-      AbstractTypeArguments::CheckedHandle(arguments.At(1));
+      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 used as type argument vector.
   ASSERT(instantiator.IsNull() ||
          !type_arguments.IsUninstantiatedIdentity() ||
          !instantiator.IsTypeArguments() ||
          (instantiator.Length() != type_arguments.Length()));
   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.Count() == kAllocateClosureRuntimeEntry.argument_count());
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  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.At(1));
+      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 static closure.
 // Arg0: local function.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitStaticClosure, 1) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kAllocateImplicitStaticClosureRuntimeEntry.argument_count());
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(!function.IsNull());
   ASSERT(function.IsImplicitStaticClosureFunction());
   const Context& context = Context::Handle(object_store->empty_context());
   arguments.SetReturn(Instance::Handle(Closure::New(function, context)));
 }
 
 
 // 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.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kAllocateImplicitInstanceClosureRuntimeEntry.argument_count());
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(function.IsImplicitInstanceClosureFunction());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(1));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(1));
   const AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.At(2));
+      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.Count() == kAllocateContextRuntimeEntry.argument_count());
-  const Smi& num_variables = Smi::CheckedHandle(arguments.At(0));
+  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.Count() == kCloneContextRuntimeEntry.argument_count());
-  const Context& ctx = Context::CheckedHandle(arguments.At(0));
+  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);
 }
 
 
 // Helper routine for tracing a type check.
@@ skipping 212 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.Count() == kInstanceofRuntimeEntry.argument_count());
-  const Instance& instance = Instance::CheckedHandle(arguments.At(0));
-  const AbstractType& type = AbstractType::CheckedHandle(arguments.At(1));
-  const Instance& instantiator = Instance::CheckedHandle(arguments.At(2));
+  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.At(3));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(arguments.At(4));
+      SubtypeTestCache::CheckedHandle(arguments.ArgAt(4));
   ASSERT(type.IsFinalized());
   Error& malformed_error = Error::Handle();
   const Bool& result = Bool::Handle(
       instance.IsInstanceOf(type,
                             instantiator_type_arguments,
                             &malformed_error) ?
       Bool::True() : Bool::False());
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf",
         instance, type, instantiator_type_arguments, result);
@@ skipping 17 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.Count() == kTypeCheckRuntimeEntry.argument_count());
-  const Instance& src_instance = Instance::CheckedHandle(arguments.At(0));
-  const AbstractType& dst_type = AbstractType::CheckedHandle(arguments.At(1));
-  const Instance& dst_instantiator = Instance::CheckedHandle(arguments.At(2));
+  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.At(3));
-  const String& dst_name = String::CheckedHandle(arguments.At(4));
+      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
+  const String& dst_name = String::CheckedHandle(arguments.ArgAt(4));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(arguments.At(5));
+      SubtypeTestCache::CheckedHandle(arguments.ArgAt(5));
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
   ASSERT(!dst_type.IsMalformed());  // Already checked in code generator.
   ASSERT(!src_instance.IsNull());  // Already checked in inlined code.
 
   Error& malformed_error = Error::Handle();
   const bool is_instance_of = src_instance.IsInstanceOf(
       dst_type, instantiator_type_arguments, &malformed_error);
 
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("TypeCheck",
@@ skipping 29 matching lines @@
   arguments.SetReturn(src_instance);
 }
 
 
 // Test whether a formal parameter was defined by a passed-in argument.
 // Arg0: formal parameter index as Smi.
 // Arg1: formal parameter name as Symbol.
 // Arg2: arguments descriptor array.
 // Return value: true or false.
 DEFINE_RUNTIME_ENTRY(ArgumentDefinitionTest, 3) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kArgumentDefinitionTestRuntimeEntry.argument_count());
-  const Smi& param_index = Smi::CheckedHandle(arguments.At(0));
-  const String& param_name = String::CheckedHandle(arguments.At(1));
+  const Smi& param_index = Smi::CheckedHandle(arguments.ArgAt(0));
+  const String& param_name = String::CheckedHandle(arguments.ArgAt(1));
   ASSERT(param_name.IsSymbol());
-  const Array& arg_desc = Array::CheckedHandle(arguments.At(2));
+  const Array& arg_desc = Array::CheckedHandle(arguments.ArgAt(2));
   const intptr_t num_pos_args = Smi::CheckedHandle(arg_desc.At(1)).Value();
   // Check if the formal parameter is defined by a positional argument.
   bool is_defined = num_pos_args > param_index.Value();
   if (!is_defined) {
     // Check if the formal parameter is defined by a named argument.
     const intptr_t num_named_args =
         Smi::CheckedHandle(arg_desc.At(0)).Value() - num_pos_args;
     String& arg_name = String::Handle();
     for (intptr_t i = 0; i < num_named_args; i++) {
       arg_name ^= arg_desc.At(2*i + 2);
       if (arg_name.raw() == param_name.raw()) {
         is_defined = true;
         break;
       }
     }
   }
   arguments.SetReturn(Bool::Handle(Bool::Get(is_defined)));
 }
 
 
 // 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.Count() ==
+  ASSERT(arguments.ArgCount() ==
       kConditionTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
-  const Instance& src_instance = Instance::CheckedHandle(arguments.At(0));
+  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& expr = String::Handle(Symbols::New("boolean expression"));
   const String& no_malformed_type_error = String::Handle();
   Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
                                       expr, 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.Count() ==
+  ASSERT(arguments.ArgCount() ==
       kMalformedTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
-  const Instance& src_value = Instance::CheckedHandle(arguments.At(0));
-  const String& dst_name = String::CheckedHandle(arguments.At(1));
-  const String& malformed_error = String::CheckedHandle(arguments.At(2));
+  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 String& dst_type_name = String::Handle(Symbols::New("malformed"));
   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,
                                       dst_type_name, dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
-  ASSERT(arguments.Count() == kThrowRuntimeEntry.argument_count());
-  const Instance& exception = Instance::CheckedHandle(arguments.At(0));
+  ASSERT(arguments.ArgCount() == kThrowRuntimeEntry.argument_count());
+  const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   Exceptions::Throw(exception);
 }
 
 
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
-  ASSERT(arguments.Count() == kReThrowRuntimeEntry.argument_count());
-  const Instance& exception = Instance::CheckedHandle(arguments.At(0));
-  const Instance& stacktrace = Instance::CheckedHandle(arguments.At(1));
+  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);
 }
 
 
 static bool UpdateResolvedStaticCall(const Code& code,
                               intptr_t offset,
                               const Code& target_code) {
   // PC offsets are mapped to the corresponding code object in the
   // resolved_static_calls array. The array grows as static calls are being
   // resolved.
@@ skipping 27 matching lines @@
     // Overwrite the currently recorded target.
     resolved_static_calls.SetAt(index + kCode, target_code);
   }
   return index != -1;
 }
 
 
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
   // This function is called after successful resolving and compilation of
   // the target method.
-  ASSERT(arguments.Count() == kPatchStaticCallRuntimeEntry.argument_count());
+  ASSERT(arguments.ArgCount() == kPatchStaticCallRuntimeEntry.argument_count());
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   uword target = 0;
   Function& target_function = Function::Handle();
   CodePatcher::GetStaticCallAt(caller_frame->pc(), &target_function, &target);
   ASSERT(target_function.HasCode());
   const Code& target_code = Code::Handle(target_function.CurrentCode());
   uword new_target = target_code.EntryPoint();
   // Verify that we are not patching repeatedly.
@@ skipping 60 matching lines @@
 }
 
 
 // Resolves an instance function and compiles it if necessary.
 //   Arg0: receiver object.
 //   Returns: RawCode object or NULL (method not found or not compileable).
 // This is called by the megamorphic stub when instance call does not need to be
 // patched.
 // Used by megamorphic lookup/no-such-method-handling.
 DEFINE_RUNTIME_ENTRY(ResolveCompileInstanceFunction, 1) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kResolveCompileInstanceFunctionRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Code& code = Code::Handle(
       ResolveCompileInstanceCallTarget(isolate, receiver));
   arguments.SetReturn(code);
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint.
 //   Arg0: function object of the static function that was about to be called.
 DEFINE_RUNTIME_ENTRY(BreakpointStaticHandler, 1) {
-  ASSERT(arguments.Count() ==
+  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.
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint at a return
 // in Dart code.
 DEFINE_RUNTIME_ENTRY(BreakpointReturnHandler, 0) {
-  ASSERT(arguments.Count() ==
+  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.Count() ==
+  ASSERT(arguments.ArgCount() ==
      kBreakpointDynamicHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
 }
 
 
 static RawFunction* InlineCacheMissHandler(
     Isolate* isolate, const GrowableArray<const Instance*>& args) {
   const Instance& receiver = *args[0];
   const Code& target_code =
@@ skipping 46 matching lines @@
   return target_function.raw();
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerOneArg, 1) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerOneArgRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   GrowableArray<const Instance*> args(1);
   args.Add(&receiver);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(isolate, args));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerTwoArgs, 2) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerTwoArgsRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Instance& other = Instance::CheckedHandle(arguments.At(1));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
+  const Instance& other = Instance::CheckedHandle(arguments.ArgAt(1));
   GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&other);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(isolate, args));
   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.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerThreeArgs, 3) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerThreeArgsRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Instance& arg1 = Instance::CheckedHandle(arguments.At(1));
-  const Instance& arg2 = Instance::CheckedHandle(arguments.At(2));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
+  const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
+  const Instance& arg2 = Instance::CheckedHandle(arguments.ArgAt(2));
   GrowableArray<const Instance*> args(3);
   args.Add(&receiver);
   args.Add(&arg1);
   args.Add(&arg2);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(isolate, args));
   arguments.SetReturn(result);
 }
 
 
 // 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.Count() ==
+  ASSERT(arguments.ArgCount() ==
       kUpdateICDataTwoArgsRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Instance& arg1 = Instance::CheckedHandle(arguments.At(1));
-  const String& target_name = String::CheckedHandle(arguments.At(2));
-  const ICData& ic_data = ICData::CheckedHandle(arguments.At(3));
+  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;
   const intptr_t kNumNamedArguments = 0;
   Function& target_function = Function::Handle();
   target_function = Resolver::ResolveDynamic(receiver,
                                              target_name,
                                              kNumArguments,
                                              kNumNamedArguments);
@@ skipping 31 matching lines @@
 
 
 // Resolve an implicit closure by checking if an instance function
 // of the same name exists and creating a closure object of the function.
 // Arg0: receiver object.
 // Arg1: ic-data.
 // Returns: Closure object or NULL (instance function not found).
 // This is called by the megamorphic stub when it is unable to resolve an
 // instance method. This is done just before the call to noSuchMethod.
 DEFINE_RUNTIME_ENTRY(ResolveImplicitClosureFunction, 2) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kResolveImplicitClosureFunctionRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const String& original_function_name = String::Handle(ic_data.target_name());
   Instance& closure = Instance::Handle();
   if (!Field::IsGetterName(original_function_name)) {
     // This is not a getter so can't be the case where we are trying to
     // create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   const Class& receiver_class = Class::Handle(receiver.clazz());
   ASSERT(!receiver_class.IsNull());
@@ skipping 24 matching lines @@
 
 
 // Resolve an implicit closure by invoking getter and checking if the return
 // value from getter is a closure.
 // Arg0: receiver object.
 // Arg1: ic-data.
 // Returns: Closure object or NULL (closure not found).
 // This is called by the megamorphic stub when it is unable to resolve an
 // instance method. This is done just before the call to noSuchMethod.
 DEFINE_RUNTIME_ENTRY(ResolveImplicitClosureThroughGetter, 2) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kResolveImplicitClosureThroughGetterRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const String& original_function_name = String::Handle(ic_data.target_name());
   const int kNumArguments = 1;
   const int kNumNamedArguments = 0;
   const String& getter_function_name =
       String::Handle(Field::GetterName(original_function_name));
   Function& function = Function::ZoneHandle(
       Resolver::ResolveDynamic(receiver,
                                getter_function_name,
                                kNumArguments,
                                kNumNamedArguments));
@@ skipping 68 matching lines @@
   Exceptions::ThrowByType(Exceptions::kNoSuchMethod, dart_arguments);
   UNREACHABLE();
 }
 
 
 // Invoke Implicit Closure function.
 // Arg0: closure object.
 // Arg1: arguments descriptor (originally passed as dart instance invocation).
 // Arg2: arguments array (originally passed to dart instance invocation).
 DEFINE_RUNTIME_ENTRY(InvokeImplicitClosureFunction, 3) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kInvokeImplicitClosureFunctionRuntimeEntry.argument_count());
-  const Instance& closure = Instance::CheckedHandle(arguments.At(0));
-  const Array& arg_descriptor = Array::CheckedHandle(arguments.At(1));
-  const Array& func_arguments = Array::CheckedHandle(arguments.At(2));
+  const Instance& closure = Instance::CheckedHandle(arguments.ArgAt(0));
+  const Array& arg_descriptor = Array::CheckedHandle(arguments.ArgAt(1));
+  const Array& func_arguments = Array::CheckedHandle(arguments.ArgAt(2));
   const Function& function = Function::Handle(Closure::function(closure));
   ASSERT(!function.IsNull());
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   const Context& context = Context::Handle(Closure::context(closure));
   const Code& code = Code::Handle(function.CurrentCode());
@@ skipping 25 matching lines @@
   arguments.SetReturn(result);
 }
 
 
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver.
 // Arg1: ic-data.
 // Arg2: original arguments descriptor array.
 // Arg3: original arguments array.
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodFunction, 4) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kInvokeNoSuchMethodFunctionRuntimeEntry.argument_count());
-  const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
+  const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const String& original_function_name = String::Handle(ic_data.target_name());
-  ASSERT(!Array::CheckedHandle(arguments.At(2)).IsNull());
-  const Array& orig_arguments = Array::CheckedHandle(arguments.At(3));
+  ASSERT(!Array::CheckedHandle(arguments.ArgAt(2)).IsNull());
+  const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(3));
   // Allocate an InvocationMirror object.
   // TODO(regis): Fill in the InvocationMirror object correctly at
   // this point we do not deal with named arguments and treat them
   // all as positional.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& invocation_mirror_name = String::Handle(
       Symbols::InvocationMirror());
   Class& invocation_mirror_class = Class::Handle(
       core_lib.LookupClassAllowPrivate(invocation_mirror_name));
   ASSERT(!invocation_mirror_class.IsNull());
@@ skipping 33 matching lines @@
   arguments.SetReturn(result);
 }
 
 
 // A non-closure object was invoked as a closure, so call the "call" method
 // on it.
 // Arg0: non-closure object.
 // Arg1: arguments array.
 // TODO(regis): Rename this entry?
 DEFINE_RUNTIME_ENTRY(ReportObjectNotClosure, 2) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kReportObjectNotClosureRuntimeEntry.argument_count());
-  const Instance& instance = Instance::CheckedHandle(arguments.At(0));
-  const Array& function_args = Array::CheckedHandle(arguments.At(1));
+  const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
+  const Array& function_args = Array::CheckedHandle(arguments.ArgAt(1));
   const String& function_name = String::Handle(Symbols::Call());
   GrowableArray<const Object*> dart_arguments(5);
   if (instance.IsNull()) {
     dart_arguments.Add(&function_name);
     dart_arguments.Add(&function_args);
     Exceptions::ThrowByType(Exceptions::kNullPointer, dart_arguments);
     UNREACHABLE();
   }
 
   // TODO(regis): Resolve and invoke "call" method, if existing.
@@ skipping 23 matching lines @@
     dart_arguments.Add(&array);
   }
   Exceptions::ThrowByType(Exceptions::kNoSuchMethod, dart_arguments);
   UNREACHABLE();
 }
 
 
 // A closure object was invoked with incompatible arguments.
 // TODO(regis): Deprecated. This case should be handled by a noSuchMethod call.
 DEFINE_RUNTIME_ENTRY(ClosureArgumentMismatch, 0) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kClosureArgumentMismatchRuntimeEntry.argument_count());
   const Instance& instance = Instance::Handle();  // Incorrect. OK for now.
   const Array& function_args = Array::Handle();  // Incorrect. OK for now.
   const String& function_name = String::Handle(Symbols::Call());
   GrowableArray<const Object*> dart_arguments(5);
 
   const Object& null_object = Object::Handle();
   dart_arguments.Add(&instance);
   dart_arguments.Add(&function_name);
   dart_arguments.Add(&function_args);
   dart_arguments.Add(&null_object);
   Exceptions::ThrowByType(Exceptions::kNoSuchMethod, dart_arguments);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kStackOverflowRuntimeEntry.argument_count());
   uword stack_pos = reinterpret_cast<uword>(&arguments);
 
   // 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
     // into dart code.
     const Instance& exception =
         Instance::Handle(isolate->object_store()->stack_overflow());
@@ skipping 42 matching lines @@
         caller_frame->LookupDartFunction());
     const Code& code = Code::Handle(caller_frame->LookupDartCode());
     OS::Print("  -> caller: %s (%s)\n",
         caller_function.ToFullyQualifiedCString(),
         code.is_optimized() ? "optimized" : "unoptimized");
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kTraceICCallRuntimeEntry.argument_count());
-  const ICData& ic_data = ICData::CheckedHandle(arguments.At(0));
-  const Function& function = Function::CheckedHandle(arguments.At(1));
+  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::Print("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).
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
-  ASSERT(arguments.Count() ==
+  ASSERT(arguments.ArgCount() ==
          kOptimizeInvokedFunctionRuntimeEntry.argument_count());
   const intptr_t kLowInvocationCount = -100000000;
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   if (isolate->debugger()->IsActive()) {
     // We cannot set breakpoints in optimized code, so do not optimize
     // the function.
     function.set_usage_counter(0);
     return;
   }
   if (function.deoptimization_counter() >=
       FLAG_deoptimization_counter_threshold) {
     if (FLAG_trace_failed_optimization_attempts) {
       PrintCaller("Too Many Deoptimizations");
@@ skipping 25 matching lines @@
     }
     // TODO(5442338): Abort as this should not happen.
     function.set_usage_counter(kLowInvocationCount);
   }
 }
 
 
 // The caller must be a static call in a Dart frame, or an entry frame.
 // Patch static call to point to 'new_entry_point'.
 DEFINE_RUNTIME_ENTRY(FixCallersTarget, 1) {
-  ASSERT(arguments.Count() == kFixCallersTargetRuntimeEntry.argument_count());
-  const Function& function = Function::CheckedHandle(arguments.At(0));
+  ASSERT(arguments.ArgCount() ==
+      kFixCallersTargetRuntimeEntry.argument_count());
+  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL && (frame->IsStubFrame() || frame->IsExitFrame())) {
     frame = iterator.NextFrame();
   }
   ASSERT(frame != NULL);
   if (!frame->IsEntryFrame()) {
@@ skipping 329 matching lines @@
     intptr_t line, column;
     script.GetTokenLocation(token_pos, &line, &column);
     String& line_string = String::Handle(script.GetLine(line));
     OS::Print("  Function: %s\n", top_function.ToFullyQualifiedCString());
     OS::Print("  Line %"Pd": '%s'\n", line, line_string.ToCString());
   }
 }
 
 
 }  // namespace dart