VM: Re-format to use at most one newline between functions

runtime/vm/runtime_entry.cc

 // Copyright (c) 2011, 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/runtime_entry.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
-#include "vm/object_store.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
+#include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/resolver.h"
 #include "vm/service_isolate.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/thread_registry.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
@@ skipping 55 matching lines @@
 DECLARE_FLAG(bool, reload_every_back_off);
 
 #ifdef DEBUG
 DEFINE_FLAG(charp,
             gc_at_instance_allocation,
             NULL,
             "Perform a GC before allocation of instances of "
             "the specified class");
 #endif
 
-
 #if defined(TESTING) || defined(DEBUG)
 void VerifyOnTransition() {
   Thread* thread = Thread::Current();
   TransitionGeneratedToVM transition(thread);
   thread->isolate()->heap()->WaitForSweeperTasks(thread);
   SafepointOperationScope safepoint_scope(thread);
   VerifyPointersVisitor::VerifyPointers();
   thread->isolate()->heap()->Verify();
 }
 #endif
 
-
 // Add function to a class and that class to the class dictionary so that
 // frame walking can be used.
 const Function& RegisterFakeFunction(const char* name, const Code& code) {
   Thread* thread = Thread::Current();
   const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
   const Script& script = Script::Handle();
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Class& owner_class = Class::Handle(
       Class::New(lib, class_name, script, TokenPosition::kNoSource));
   const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
   const Function& function = Function::ZoneHandle(Function::New(
       function_name, RawFunction::kRegularFunction, true, false, false, false,
       false, owner_class, TokenPosition::kMinSource));
   const Array& functions = Array::Handle(Array::New(1));
   functions.SetAt(0, function);
   owner_class.SetFunctions(functions);
   lib.AddClass(owner_class);
   function.AttachCode(code);
   return function;
 }
 
-
 DEFINE_RUNTIME_ENTRY(TraceFunctionEntry, 1) {
   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) {
   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());
 }
 
-
 DEFINE_RUNTIME_ENTRY(RangeError, 2) {
   const Instance& length = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& index = Instance::CheckedHandle(arguments.ArgAt(1));
   if (!length.IsInteger()) {
     // Throw: new ArgumentError.value(length, "length", "is not an integer");
     const Array& args = Array::Handle(Array::New(3));
     args.SetAt(0, length);
     args.SetAt(1, Symbols::Length());
     args.SetAt(2, String::Handle(String::New("is not an integer")));
     Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
   }
   if (!index.IsInteger()) {
     // Throw: new ArgumentError.value(index, "index", "is not an integer");
     const Array& args = Array::Handle(Array::New(3));
     args.SetAt(0, index);
     args.SetAt(1, Symbols::Index());
     args.SetAt(2, String::Handle(String::New("is not an integer")));
     Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
   }
   // Throw: new RangeError.range(index, 0, length, "length");
   const Array& args = Array::Handle(Array::New(4));
   args.SetAt(0, index);
   args.SetAt(1, Integer::Handle(Integer::New(0)));
   args.SetAt(2, length);
   args.SetAt(3, Symbols::Length());
   Exceptions::ThrowByType(Exceptions::kRange, args);
 }
 
-
 // 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) {
   const Instance& length = Instance::CheckedHandle(arguments.ArgAt(0));
   if (!length.IsInteger()) {
     // Throw: new ArgumentError.value(length, "length", "is not an integer");
@@ skipping 21 matching lines @@
   }
   // Throw: new RangeError.range(length, 0, Array::kMaxElements, "length");
   const Array& args = Array::Handle(Array::New(4));
   args.SetAt(0, length);
   args.SetAt(1, Integer::Handle(Integer::New(0)));
   args.SetAt(2, Integer::Handle(Integer::New(Array::kMaxElements)));
   args.SetAt(3, Symbols::Length());
   Exceptions::ThrowByType(Exceptions::kRange, args);
 }
 
-
 // Helper returning the token position of the Dart caller.
 static TokenPosition GetCallerLocation() {
   DartFrameIterator iterator(Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   return caller_frame->GetTokenPos();
 }
 
-
 // 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.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObject, 2) {
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
 
 #ifdef DEBUG
   if (FLAG_gc_at_instance_allocation != NULL) {
     const String& name = String::Handle(cls.Name());
@@ skipping 17 matching lines @@
       TypeArguments::CheckedHandle(arguments.ArgAt(1));
   // Unless null (for a raw type), the type argument vector may be longer than
   // necessary due to a type optimization reusing the type argument vector of
   // the instantiator.
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.IsInstantiated() &&
           (type_arguments.Length() >= cls.NumTypeArguments())));
   instance.SetTypeArguments(type_arguments);
 }
 
-
 // Instantiate type.
 // Arg0: uninstantiated type.
 // Arg1: instantiator type arguments.
 // Arg2: function type arguments.
 // Return value: instantiated type.
 DEFINE_RUNTIME_ENTRY(InstantiateType, 3) {
   AbstractType& type = AbstractType::CheckedHandle(zone, arguments.ArgAt(0));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& function_type_arguments =
@@ skipping 19 matching lines @@
   }
   if (type.IsTypeRef()) {
     type = TypeRef::Cast(type).type();
     ASSERT(!type.IsTypeRef());
     ASSERT(type.IsCanonical());
   }
   ASSERT(!type.IsNull() && type.IsInstantiated());
   arguments.SetReturn(type);
 }
 
-
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
 // Arg2: function type arguments.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 3) {
   TypeArguments& type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(0));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
@@ skipping 22 matching lines @@
       UNREACHABLE();
     }
   } else {
     type_arguments = type_arguments.InstantiateAndCanonicalizeFrom(
         instantiator_type_arguments, function_type_arguments, NULL);
   }
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   arguments.SetReturn(type_arguments);
 }
 
-
 // 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) {
   const Smi& num_variables = Smi::CheckedHandle(zone, 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) {
   const Context& ctx = Context::CheckedHandle(zone, arguments.ArgAt(0));
   Context& cloned_ctx =
       Context::Handle(zone, Context::New(ctx.num_variables()));
   cloned_ctx.set_parent(Context::Handle(ctx.parent()));
   Object& inst = Object::Handle(zone);
   for (int i = 0; i < ctx.num_variables(); i++) {
     inst = ctx.At(i);
     cloned_ctx.SetAt(i, inst);
   }
   arguments.SetReturn(cloned_ctx);
 }
 
-
 // Helper routine for tracing a type check.
 static void PrintTypeCheck(const char* message,
                            const Instance& instance,
                            const AbstractType& type,
                            const TypeArguments& instantiator_type_arguments,
                            const TypeArguments& function_type_arguments,
                            const Bool& result) {
   DartFrameIterator iterator(Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
@@ skipping 24 matching lines @@
                  String::Handle(type.Name()).ToCString(), caller_frame->pc());
     if (!bound_error.IsNull()) {
       OS::Print("  bound error: %s\n", bound_error.ToErrorCString());
     }
   }
   const Function& function =
       Function::Handle(caller_frame->LookupDartFunction());
   OS::PrintErr(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
-
 // This updates the type test cache, an array containing 5-value elements
 // (instance class (or function if the instance is a closure), instance type
 // arguments, instantiator type arguments, function type arguments,
 // and test_result). It can be applied to classes with type arguments in which
 // case it contains just the result of the class subtype test, not including the
 // evaluation of type arguments.
 // This operation is currently very slow (lookup of code is not efficient yet).
 static void UpdateTypeTestCache(
     const Instance& instance,
     const AbstractType& type,
@@ skipping 129 matching lines @@
         test_type.type_class(),
         String::Handle(Class::Handle(test_type.type_class()).Name())
             .ToCString(),
         Class::Handle(test_type.type_class()).id(),
         instantiator_type_arguments.raw(),
         instantiator_type_arguments.ToCString(), function_type_arguments.raw(),
         function_type_arguments.ToCString());
   }
 }
 
-
 // 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: type arguments of the instantiator of the type.
 // Arg3: type arguments of the function of the type.
 // Arg4: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
 DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
   const Instance& instance = Instance::CheckedHandle(zone, arguments.ArgAt(0));
@@ skipping 25 matching lines @@
     Exceptions::CreateAndThrowTypeError(location, AbstractType::Handle(zone),
                                         AbstractType::Handle(zone),
                                         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(instance, type, instantiator_type_arguments,
                       function_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
-
 // 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: type arguments of the instantiator of the type being assigned to.
 // Arg3: type arguments of the function 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) {
@@ skipping 42 matching lines @@
     }
     Exceptions::CreateAndThrowTypeError(location, src_type, dst_type, dst_name,
                                         bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(src_instance, dst_type, instantiator_type_arguments,
                       function_type_arguments, Bool::True(), cache);
   arguments.SetReturn(src_instance);
 }
 
-
 // Report that the type of the given object is not bool in conditional context.
 // Throw assertion error if the object is null. (cf. Boolean Conversion
 // in language Spec.)
 // Arg0: bad object.
 // Return value: none, throws TypeError or AssertionError.
 DEFINE_RUNTIME_ENTRY(NonBoolTypeError, 1) {
   const TokenPosition location = GetCallerLocation();
   const Instance& src_instance =
       Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
@@ skipping 19 matching lines @@
   const Type& bool_interface = Type::Handle(Type::BoolType());
   const AbstractType& src_type =
       AbstractType::Handle(zone, src_instance.GetType(Heap::kNew));
   const String& no_bound_error = String::Handle(zone);
   Exceptions::CreateAndThrowTypeError(location, src_type, bool_interface,
                                       Symbols::BooleanExpression(),
                                       no_bound_error);
   UNREACHABLE();
 }
 
-
 // Report that the type of the type check is malformed or malbounded.
 // Arg0: src value.
 // Arg1: name of destination being assigned to.
 // Arg2: type of destination being assigned to.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(BadTypeError, 3) {
   const TokenPosition location = GetCallerLocation();
   const Instance& src_value = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(1));
   const AbstractType& dst_type =
       AbstractType::CheckedHandle(zone, arguments.ArgAt(2));
   const AbstractType& src_type =
       AbstractType::Handle(zone, src_value.GetType(Heap::kNew));
   Exceptions::CreateAndThrowTypeError(location, src_type, dst_type, dst_name,
                                       String::Handle(zone));
   UNREACHABLE();
 }
 
-
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
   const Instance& exception = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   Exceptions::Throw(thread, exception);
 }
 
-
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
   const Instance& exception = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const Instance& stacktrace =
       Instance::CheckedHandle(zone, arguments.ArgAt(1));
   Exceptions::ReThrow(thread, exception, stacktrace);
 }
 
-
 // Patches static call in optimized code with the target's entry point.
 // Compiles target if necessary.
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
   DartFrameIterator iterator(thread,
                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
   ASSERT(caller_code.is_optimized());
@@ skipping 10 matching lines @@
     THR_Print("PatchStaticCall: patching caller pc %#" Px
               ""
               " to '%s' new entry point %#" Px " (%s)\n",
               caller_frame->pc(), target_function.ToFullyQualifiedCString(),
               target_code.UncheckedEntryPoint(),
               target_code.is_optimized() ? "optimized" : "unoptimized");
   }
   arguments.SetReturn(target_code);
 }
 
-
 // Result of an invoke may be an unhandled exception, in which case we
 // rethrow it.
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
-
 #if !defined(TARGET_ARCH_DBC)
 // Gets called from debug stub when code reaches a breakpoint
 // set on a runtime stub call.
 DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
   DartFrameIterator iterator(thread,
                              StackFrameIterator::kNoCrossThreadIteration);
@@ skipping 17 matching lines @@
     return;
   }
   const Error& error = Error::Handle(isolate->debugger()->PauseBreakpoint());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 }
 #endif  // !defined(TARGET_ARCH_DBC)
 
-
 DEFINE_RUNTIME_ENTRY(SingleStepHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
   const Error& error =
       Error::Handle(zone, isolate->debugger()->PauseStepping());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 }
 
-
 // An instance call of the form o.f(...) could not be resolved.  Check if
 // there is 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.
 static bool ResolveCallThroughGetter(const Instance& receiver,
                                      const Class& receiver_class,
                                      const String& target_name,
                                      const Array& arguments_descriptor,
                                      Function* result) {
   // 1. Check if there is a getter with the same name.
@@ skipping 16 matching lines @@
   if (FLAG_trace_ic) {
     OS::PrintErr(
         "InvokeField IC miss: adding <%s> id:%" Pd " -> <%s>\n",
         Class::Handle(receiver.clazz()).ToCString(), receiver.GetClassId(),
         target_function.IsNull() ? "null" : target_function.ToCString());
   }
   *result = target_function.raw();
   return true;
 }
 
-
 // Handle other invocations (implicit closures, noSuchMethod).
 RawFunction* InlineCacheMissHelper(const Instance& receiver,
                                    const Array& args_descriptor,
                                    const String& target_name) {
   const Class& receiver_class = Class::Handle(receiver.clazz());
 
   Function& result = Function::Handle();
   if (!ResolveCallThroughGetter(receiver, receiver_class, target_name,
                                 args_descriptor, &result)) {
     ArgumentsDescriptor desc(args_descriptor);
     const Function& target_function =
         Function::Handle(receiver_class.GetInvocationDispatcher(
             target_name, args_descriptor, RawFunction::kNoSuchMethodDispatcher,
             FLAG_lazy_dispatchers));
     if (FLAG_trace_ic) {
       OS::PrintErr(
           "NoSuchMethod IC miss: adding <%s> id:%" Pd " -> <%s>\n",
           Class::Handle(receiver.clazz()).ToCString(), receiver.GetClassId(),
           target_function.IsNull() ? "null" : target_function.ToCString());
     }
     result = target_function.raw();
   }
   // May be null if --no-lazy-dispatchers, in which case dispatch will be
   // handled by InvokeNoSuchMethodDispatcher.
   ASSERT(!result.IsNull() || !FLAG_lazy_dispatchers);
   return result.raw();
 }
 
-
 // Perform the subtype and return constant function based on the result.
 static RawFunction* ComputeTypeCheckTarget(const Instance& receiver,
                                            const AbstractType& type,
                                            const ArgumentsDescriptor& desc) {
   Error& error = Error::Handle();
   bool result = receiver.IsInstanceOf(type, Object::null_type_arguments(),
                                       Object::null_type_arguments(), &error);
   ASSERT(error.IsNull());
   ObjectStore* store = Isolate::Current()->object_store();
   const Function& target =
       Function::Handle(result ? store->simple_instance_of_true_function()
                               : store->simple_instance_of_false_function());
   ASSERT(!target.IsNull());
   return target.raw();
 }
 
-
 static RawFunction* InlineCacheMissHandler(
     const GrowableArray<const Instance*>& args,  // Checked arguments only.
     const ICData& ic_data) {
   const Instance& receiver = *args[0];
   ArgumentsDescriptor arguments_descriptor(
       Array::Handle(ic_data.arguments_descriptor()));
   String& function_name = String::Handle(ic_data.target_name());
   ASSERT(function_name.IsSymbol());
 
   Function& target_function = Function::Handle(
@@ skipping 50 matching lines @@
                    "' "
                    "adding <%s> id:%" Pd " -> <%s>\n",
                    args.length(), caller_frame->pc(),
                    Class::Handle(receiver.clazz()).ToCString(),
                    receiver.GetClassId(), target_function.ToCString());
     }
   }
   return target_function.raw();
 }
 
-
 // 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) {
   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) {
   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 a static call in unoptimized code that has one argument type not
 // seen before. Compile the target if necessary and update the ICData.
 // Arg0: argument.
 // Arg1: IC data object.
 DEFINE_RUNTIME_ENTRY(StaticCallMissHandlerOneArg, 2) {
   const Instance& arg = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   // IC data for static call is prepopulated with the statically known target.
   ASSERT(ic_data.NumberOfChecksIs(1));
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   target.EnsureHasCode();
   ASSERT(!target.IsNull() && target.HasCode());
   ic_data.AddReceiverCheck(arg.GetClassId(), target, 1);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator(thread,
                                StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ")\n",
                  caller_frame->pc(), target.ToCString(), arg.GetClassId());
   }
   arguments.SetReturn(target);
 }
 
-
 // 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) {
   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.NumberOfChecksIs(0));
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   target.EnsureHasCode();
   GrowableArray<intptr_t> cids(2);
   cids.Add(arg0.GetClassId());
   cids.Add(arg1.GetClassId());
   ic_data.AddCheck(cids, target);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator(thread,
                                StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ", %" Pd
                  ")\n",
                  caller_frame->pc(), target.ToCString(), cids[0], cids[1]);
   }
   arguments.SetReturn(target);
 }
 
-
 #if !defined(TARGET_ARCH_DBC)
 static bool IsSingleTarget(Isolate* isolate,
                            Zone* zone,
                            intptr_t lower_cid,
                            intptr_t upper_cid,
                            const Function& target,
                            const String& name) {
   Class& cls = Class::Handle(zone);
   ClassTable* table = isolate->class_table();
   Function& other_target = Function::Handle(zone);
   for (intptr_t cid = lower_cid; cid <= upper_cid; cid++) {
     if (!table->HasValidClassAt(cid)) continue;
     cls = table->At(cid);
     if (cls.is_abstract()) continue;
     if (!cls.is_allocated()) continue;
     other_target =
         Resolver::ResolveDynamicAnyArgs(zone, cls, name, false /* allow_add */);
     if (other_target.raw() != target.raw()) {
       return false;
     }
   }
   return true;
 }
 #endif
 
-
 // Handle a miss of a single target cache.
 //   Arg0: Receiver.
 //   Returns: the ICData used to continue with a polymorphic call.
 DEFINE_RUNTIME_ENTRY(SingleTargetMiss, 1) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use switchable calls.
   UNREACHABLE();
 #else
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
@@ skipping 70 matching lines @@
   ASSERT(!Isolate::Current()->compilation_allowed());
   CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code, ic_data,
                                      stub);
 
   // Return the ICData. The single target stub will jump to continue in the
   // IC call stub.
   arguments.SetReturn(ic_data);
 #endif
 }
 
-
 DEFINE_RUNTIME_ENTRY(UnlinkedCall, 2) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use switchable calls.
   UNREACHABLE();
 #else
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const UnlinkedCall& unlinked =
       UnlinkedCall::CheckedHandle(zone, arguments.ArgAt(1));
 
   DartFrameIterator iterator(thread,
@@ skipping 46 matching lines @@
   ASSERT(!Isolate::Current()->compilation_allowed());
   CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code, ic_data,
                                      stub);
 
   // Return the ICData. The miss stub will jump to continue in the IC lookup
   // stub.
   arguments.SetReturn(ic_data);
 #endif  // !DBC
 }
 
-
 // Handle a miss of a megamorphic cache.
 //   Arg0: Receiver.
 //   Returns: the ICData used to continue with a polymorphic call.
 DEFINE_RUNTIME_ENTRY(MonomorphicMiss, 1) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use switchable calls.
   UNREACHABLE();
 #else
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
@@ skipping 78 matching lines @@
   ASSERT(!Isolate::Current()->compilation_allowed());
   CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code, ic_data,
                                      stub);
 
   // Return the ICData. The miss stub will jump to continue in the IC lookup
   // stub.
   arguments.SetReturn(ic_data);
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
-
 // Handle a miss of a megamorphic cache.
 //   Arg0: Receiver.
 //   Arg1: ICData or MegamorphicCache.
 //   Arg2: Arguments descriptor array.
 //   Returns: target function to call.
 DEFINE_RUNTIME_ENTRY(MegamorphicCacheMissHandler, 3) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use megamorphic calls right now.
   UNREACHABLE();
 #else
@@ skipping 81 matching lines @@
     const MegamorphicCache& cache = MegamorphicCache::Cast(ic_data_or_cache);
     // Insert function found into cache and return it.
     cache.EnsureCapacity();
     const Smi& class_id = Smi::Handle(zone, Smi::New(cls.id()));
     cache.Insert(class_id, target_function);
   }
   arguments.SetReturn(target_function);
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
-
 // Invoke appropriate noSuchMethod or closure from getter.
 // Arg0: receiver
 // Arg1: ICData or MegamorphicCache
 // Arg2: arguments descriptor array
 // Arg3: arguments array
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodDispatcher, 4) {
   ASSERT(!FLAG_lazy_dispatchers);
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const Object& ic_data_or_cache = Object::Handle(zone, arguments.ArgAt(1));
   const Array& orig_arguments_desc =
@@ skipping 123 matching lines @@
       cls = cls.SuperClass();
     }
   }
 
   NO_SUCH_METHOD();
 
 #undef NO_SUCH_METHOD
 #undef CLOSURIZE
 }
 
-
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver (closure object)
 // Arg1: arguments descriptor array.
 // Arg2: arguments array.
 DEFINE_RUNTIME_ENTRY(InvokeClosureNoSuchMethod, 3) {
   const Closure& receiver = Closure::CheckedHandle(arguments.ArgAt(0));
   const Array& orig_arguments_desc = Array::CheckedHandle(arguments.ArgAt(1));
   const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(2));
 
   // 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(receiver.function());
   const String& original_function_name =
       String::Handle(function.QualifiedUserVisibleName());
   const Object& result = Object::Handle(DartEntry::InvokeNoSuchMethod(
       receiver, original_function_name, orig_arguments, orig_arguments_desc));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
-
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
 #if defined(USING_SIMULATOR)
   uword stack_pos = Simulator::Current()->get_sp();
 #else
   uword stack_pos = Thread::GetCurrentStackPointer();
 #endif
   // Always clear the stack overflow flags.  They are meant for this
   // particular stack overflow runtime call and are not meant to
   // persist.
   uword stack_overflow_flags = thread->GetAndClearStackOverflowFlags();
@@ skipping 168 matching lines @@
     if (!result.IsNull()) {
       const Code& code = Code::Cast(result);
       uword optimized_entry =
           Instructions::UncheckedEntryPoint(code.instructions());
       frame->set_pc(optimized_entry);
       frame->set_pc_marker(code.raw());
     }
   }
 }
 
-
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator(thread,
                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   OS::PrintErr("IC call @%#" Px ": ICData: %p cnt:%" Pd " nchecks: %" Pd
                " %s\n",
                frame->pc(), ic_data.raw(), function.usage_counter(),
                ic_data.NumberOfChecks(), 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) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   const Function& function = Function::CheckedHandle(zone, arguments.ArgAt(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
   if (Compiler::CanOptimizeFunction(thread, function)) {
@@ skipping 46 matching lines @@
     if (result.IsError()) {
       Exceptions::PropagateError(Error::Cast(result));
     }
   }
   arguments.SetReturn(function);
 #else
   UNREACHABLE();
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
-
 // 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) {
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames, thread,
                               StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   while (frame->IsStubFrame() || frame->IsExitFrame()) {
     frame = iterator.NextFrame();
     ASSERT(frame != NULL);
@@ skipping 17 matching lines @@
     OS::PrintErr("FixCallersTarget: caller %#" Px
                  " "
                  "target '%s' -> %#" Px "\n",
                  frame->pc(), target_function.ToFullyQualifiedCString(),
                  current_target_code.UncheckedEntryPoint());
   }
   ASSERT(!current_target_code.IsDisabled());
   arguments.SetReturn(current_target_code);
 }
 
-
 // The caller tried to allocate an instance via an invalidated allocation
 // stub.
 DEFINE_RUNTIME_ENTRY(FixAllocationStubTarget, 0) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames, thread,
                               StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   while (frame->IsStubFrame() || frame->IsExitFrame()) {
     frame = iterator.NextFrame();
@@ skipping 23 matching lines @@
                  " -> %#" Px "\n",
                  frame->pc(), alloc_class.ToCString(),
                  alloc_stub.UncheckedEntryPoint());
   }
   arguments.SetReturn(alloc_stub);
 #else
   UNREACHABLE();
 #endif
 }
 
-
 const char* DeoptReasonToCString(ICData::DeoptReasonId deopt_reason) {
   switch (deopt_reason) {
 #define DEOPT_REASON_TO_TEXT(name)                                             \
   case ICData::kDeopt##name:                                                   \
     return #name;
     DEOPT_REASONS(DEOPT_REASON_TO_TEXT)
 #undef DEOPT_REASON_TO_TEXT
     default:
       UNREACHABLE();
       return "";
   }
 }
 
-
 void DeoptimizeAt(const Code& optimized_code, StackFrame* frame) {
   ASSERT(optimized_code.is_optimized());
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Function& function = Function::Handle(zone, optimized_code.function());
   const Error& error =
       Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, function));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
@@ skipping 51 matching lines @@
       THR_Print("Lazy deopt scheduled for fp=%" Pp ", pc=%" Pp "\n",
                 frame->fp(), deopt_pc);
     }
   }
 #endif  // !DBC
 
   // Mark code as dead (do not GC its embedded objects).
   optimized_code.set_is_alive(false);
 }
 
-
 // Currently checks only that all optimized frames have kDeoptIndex
 // and unoptimized code has the kDeoptAfter.
 void DeoptimizeFunctionsOnStack() {
   DartFrameIterator iterator(Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   Code& optimized_code = Code::Handle();
   while (frame != NULL) {
     optimized_code = frame->LookupDartCode();
     if (optimized_code.is_optimized()) {
@@ skipping 31 matching lines @@
   ASSERT(cpu_registers_copy != NULL);
   for (intptr_t i = 0; i < kNumberOfSavedCpuRegisters; i++) {
     cpu_registers_copy[i] =
         *reinterpret_cast<intptr_t*>(saved_registers_address);
     saved_registers_address += kWordSize;
   }
   *cpu_registers = cpu_registers_copy;
 }
 #endif
 
-
 // Copies saved registers and caller's frame into temporary buffers.
 // Returns the stack size of unoptimized frame.
 // The calling code must be optimized, but its function may not have
 // have optimized code if the code is OSR code, or if the code was invalidated
 // through class loading/finalization or field guard.
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t,
                           DeoptimizeCopyFrame,
                           2,
                           uword saved_registers_address,
                           uword is_lazy_deopt) {
@@ skipping 63 matching lines @@
 
   // Stack size (FP - SP) in bytes.
   return deopt_context->DestStackAdjustment() * kWordSize;
 #else
   UNREACHABLE();
   return 0;
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 END_LEAF_RUNTIME_ENTRY
 
-
 // The stack has been adjusted to fit all values for unoptimized frame.
 // Fill the unoptimized frame.
 DEFINE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, 1, uword last_fp) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   StackZone zone(thread);
   HANDLESCOPE(thread);
 
   DeoptContext* deopt_context = isolate->deopt_context();
@@ skipping 22 matching lines @@
 
   deopt_context->set_dest_frame(caller_frame);
   deopt_context->FillDestFrame();
 
 #else
   UNREACHABLE();
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 END_LEAF_RUNTIME_ENTRY
 
-
 // This is the last step in the deoptimization, GC can occur.
 // Returns number of bytes to remove from the expression stack of the
 // bottom-most deoptimized frame. Those arguments were artificially injected
 // under return address to keep them discoverable by GC that can occur during
 // materialization phase.
 DEFINE_RUNTIME_ENTRY(DeoptimizeMaterialize, 0) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #if defined(DEBUG)
   {
     // We may rendezvous for a safepoint at entry or GC from the allocations
     // below. Check the stack is walkable.
     ValidateFrames();
   }
 #endif
   DeoptContext* deopt_context = isolate->deopt_context();
   intptr_t deopt_arg_count = deopt_context->MaterializeDeferredObjects();
   isolate->set_deopt_context(NULL);
   delete deopt_context;
 
   // Return value tells deoptimization stub to remove the given number of bytes
   // from the stack.
   arguments.SetReturn(Smi::Handle(Smi::New(deopt_arg_count * kWordSize)));
 #else
   UNREACHABLE();
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
-
 DEFINE_RUNTIME_ENTRY(RewindPostDeopt, 0) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #if !defined(PRODUCT)
   isolate->debugger()->RewindPostDeopt();
 #endif  // !PRODUCT
 #endif  // !DART_PRECOMPILED_RUNTIME
   UNREACHABLE();
 }
 
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t,
                           BigintCompare,
                           2,
                           RawBigint* left,
                           RawBigint* right) {
   Thread* thread = Thread::Current();
   StackZone zone(thread);
   HANDLESCOPE(thread);
   const Bigint& big_left = Bigint::Handle(left);
   const Bigint& big_right = Bigint::Handle(right);
   return big_left.CompareWith(big_right);
 }
 END_LEAF_RUNTIME_ENTRY
 
-
 double DartModulo(double left, double right) {
   double remainder = fmod_ieee(left, right);
   if (remainder == 0.0) {
     // We explicitly switch to the positive 0.0 (just in case it was negative).
     remainder = +0.0;
   } else if (remainder < 0.0) {
     if (right < 0) {
       remainder -= right;
     } else {
       remainder += right;
     }
   }
   return remainder;
 }
 
-
 // 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) {
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
   field.RecordStore(value);
 }
 
-
 DEFINE_RUNTIME_ENTRY(InitStaticField, 1) {
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   field.EvaluateInitializer();
 }
 
 // Use expected function signatures to help MSVC compiler resolve overloading.
 typedef double (*UnaryMathCFunction)(double x);
 typedef double (*BinaryMathCFunction)(double x, double y);
 
 DEFINE_RAW_LEAF_RUNTIME_ENTRY(
@@ skipping 70 matching lines @@
     true /* is_float */,
     reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&tan)));
 
 DEFINE_RAW_LEAF_RUNTIME_ENTRY(
     LibcAtan,
     1,
     true /* is_float */,
     reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&atan)));
 
 }  // namespace dart