clang-format runtime/vm

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/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 10 matching lines @@
 #include "vm/resolver.h"
 #include "vm/runtime_entry.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 {
 
-DEFINE_FLAG(int, max_subtype_cache_entries, 100,
+DEFINE_FLAG(
+    int,
+    max_subtype_cache_entries,
+    100,
     "Maximum number of subtype cache entries (number of checks cached).");
-DEFINE_FLAG(int, regexp_optimization_counter_threshold, 1000,
+DEFINE_FLAG(
+    int,
+    regexp_optimization_counter_threshold,
+    1000,
     "RegExp's usage-counter value before it is optimized, -1 means never");
-DEFINE_FLAG(int, reoptimization_counter_threshold, 4000,
-    "Counter threshold before a function gets reoptimized.");
+DEFINE_FLAG(int,
+            reoptimization_counter_threshold,
+            4000,
+            "Counter threshold before a function gets reoptimized.");
 DEFINE_FLAG(bool, trace_deoptimization, false, "Trace deoptimization");
-DEFINE_FLAG(bool, trace_deoptimization_verbose, false,
-    "Trace deoptimization verbose");
+DEFINE_FLAG(bool,
+            trace_deoptimization_verbose,
+            false,
+            "Trace deoptimization verbose");
 DEFINE_FLAG(bool, trace_ic, false, "Trace IC handling");
-DEFINE_FLAG(bool, trace_ic_miss_in_optimized, false,
-    "Trace IC miss in optimized code");
-DEFINE_FLAG(bool, trace_optimized_ic_calls, false,
-    "Trace IC calls in optimized code.");
+DEFINE_FLAG(bool,
+            trace_ic_miss_in_optimized,
+            false,
+            "Trace IC miss in optimized code");
+DEFINE_FLAG(bool,
+            trace_optimized_ic_calls,
+            false,
+            "Trace IC calls in optimized code.");
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(bool, trace_type_checks, false, "Trace runtime type checks.");
 
 DECLARE_FLAG(int, max_deoptimization_counter_threshold);
 DECLARE_FLAG(bool, enable_inlining_annotations);
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, trace_optimizing_compiler);
 DECLARE_FLAG(int, max_polymorphic_checks);
 
 DEFINE_FLAG(bool, trace_osr, false, "Trace attempts at on-stack replacement.");
 
-DEFINE_FLAG(int, stacktrace_every, 0,
+DEFINE_FLAG(int,
+            stacktrace_every,
+            0,
             "Compute debugger stacktrace on every N stack overflow checks");
-DEFINE_FLAG(charp, stacktrace_filter, NULL,
+DEFINE_FLAG(charp,
+            stacktrace_filter,
+            NULL,
             "Compute stacktrace in named function on stack overflow checks");
-DEFINE_FLAG(charp, deoptimize_filter, NULL,
+DEFINE_FLAG(charp,
+            deoptimize_filter,
+            NULL,
             "Deoptimize in named function on stack overflow checks");
 
 DECLARE_FLAG(int, reload_every);
 DECLARE_FLAG(bool, reload_every_optimized);
 DECLARE_FLAG(bool, reload_every_back_off);
 
 #ifdef DEBUG
-DEFINE_FLAG(charp, gc_at_instance_allocation, NULL,
+DEFINE_FLAG(charp,
+            gc_at_instance_allocation,
+            NULL,
             "Perform a GC before allocation of instances of "
             "the specified class");
 #endif
 
 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());
+  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());
+  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);
@@ skipping 117 matching lines @@
   const TypeArguments& instantiator =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
   ASSERT(!type.IsNull() && !type.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   Error& bound_error = Error::Handle(zone);
   type =
       type.InstantiateFrom(instantiator, &bound_error, NULL, NULL, Heap::kOld);
   if (!bound_error.IsNull()) {
     // Throw a dynamic type error.
     const TokenPosition location = GetCallerLocation();
-    String& bound_error_message =  String::Handle(
-        zone, String::New(bound_error.ToErrorCString()));
-    Exceptions::CreateAndThrowTypeError(
-        location, AbstractType::Handle(zone), AbstractType::Handle(zone),
-        Symbols::Empty(), bound_error_message);
+    String& bound_error_message =
+        String::Handle(zone, String::New(bound_error.ToErrorCString()));
+    Exceptions::CreateAndThrowTypeError(location, AbstractType::Handle(zone),
+                                        AbstractType::Handle(zone),
+                                        Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   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.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
   TypeArguments& type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(0));
   const TypeArguments& instantiator =
       TypeArguments::CheckedHandle(zone, 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());
   if (isolate->type_checks()) {
     Error& bound_error = Error::Handle(zone);
-    type_arguments =
-        type_arguments.InstantiateAndCanonicalizeFrom(instantiator,
-                                                      &bound_error);
+    type_arguments = type_arguments.InstantiateAndCanonicalizeFrom(
+        instantiator, &bound_error);
     if (!bound_error.IsNull()) {
       // Throw a dynamic type error.
       const TokenPosition location = GetCallerLocation();
-      String& bound_error_message =  String::Handle(
-          zone, String::New(bound_error.ToErrorCString()));
+      String& bound_error_message =
+          String::Handle(zone, String::New(bound_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
           location, AbstractType::Handle(zone), AbstractType::Handle(zone),
           Symbols::Empty(), bound_error_message);
       UNREACHABLE();
     }
   } else {
     type_arguments =
         type_arguments.InstantiateAndCanonicalizeFrom(instantiator, NULL);
   }
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
@@ skipping 22 matching lines @@
   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 Bool& result) {
+static void PrintTypeCheck(const char* message,
+                           const Instance& instance,
+                           const AbstractType& type,
+                           const TypeArguments& instantiator_type_arguments,
+                           const Bool& result) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const AbstractType& instance_type = AbstractType::Handle(instance.GetType());
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
-    OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n",
-                 message,
+    OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n", message,
                  String::Handle(instance_type.Name()).ToCString(),
                  Class::Handle(instance_type.type_class()).id(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(type.Name()).ToCString(),
-                 Class::Handle(type.type_class()).id(),
-                 caller_frame->pc());
+                 Class::Handle(type.type_class()).id(), caller_frame->pc());
   } else {
     // Instantiate type before printing.
     Error& bound_error = Error::Handle();
-    const AbstractType& instantiated_type = AbstractType::Handle(
-        type.InstantiateFrom(instantiator_type_arguments, &bound_error,
-                             NULL, NULL, Heap::kOld));
+    const AbstractType& instantiated_type =
+        AbstractType::Handle(type.InstantiateFrom(
+            instantiator_type_arguments, &bound_error, NULL, NULL, Heap::kOld));
     OS::PrintErr("%s: '%s' %s '%s' instantiated from '%s' (pc: %#" Px ").\n",
-                 message,
-                 String::Handle(instance_type.Name()).ToCString(),
+                 message, String::Handle(instance_type.Name()).ToCString(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(instantiated_type.Name()).ToCString(),
-                 String::Handle(type.Name()).ToCString(),
-                 caller_frame->pc());
+                 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());
+  const Function& function =
+      Function::Handle(caller_frame->LookupDartFunction());
   OS::PrintErr(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
 
 // This updates the type test cache, an array containing 4-value elements
 // (instance class (or function if the instance is a closure), instance type
 // arguments, instantiator 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).
@@ skipping 38 matching lines @@
 #if defined(DEBUG)
   ASSERT(instance_type_arguments.IsNull() ||
          instance_type_arguments.IsCanonical());
   ASSERT(instantiator_type_arguments.IsNull() ||
          instantiator_type_arguments.IsCanonical());
   Object& last_instance_class_id_or_function = Object::Handle();
   TypeArguments& last_instance_type_arguments = TypeArguments::Handle();
   TypeArguments& last_instantiator_type_arguments = TypeArguments::Handle();
   Bool& last_result = Bool::Handle();
   for (intptr_t i = 0; i < len; ++i) {
-    new_cache.GetCheck(
-        i,
-        &last_instance_class_id_or_function,
-        &last_instance_type_arguments,
-        &last_instantiator_type_arguments,
-        &last_result);
+    new_cache.GetCheck(i, &last_instance_class_id_or_function,
+                       &last_instance_type_arguments,
+                       &last_instantiator_type_arguments, &last_result);
     if ((last_instance_class_id_or_function.raw() ==
          instance_class_id_or_function.raw()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
       OS::PrintErr("  Error in test cache %p ix: %" Pd ",", new_cache.raw(), i);
       PrintTypeCheck(" duplicate cache entry", instance, type,
-          instantiator_type_arguments, result);
+                     instantiator_type_arguments, result);
       UNREACHABLE();
       return;
     }
   }
 #endif
-  new_cache.AddCheck(instance_class_id_or_function,
-                     instance_type_arguments,
-                     instantiator_type_arguments,
-                     result);
+  new_cache.AddCheck(instance_class_id_or_function, instance_type_arguments,
+                     instantiator_type_arguments, result);
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       Error& bound_error = Error::Handle();
       test_type = type.InstantiateFrom(instantiator_type_arguments,
-                                       &bound_error,
-                                       NULL, NULL, Heap::kNew);
+                                       &bound_error, NULL, NULL, Heap::kNew);
       ASSERT(bound_error.IsNull());  // Malbounded types are not optimized.
     }
-    OS::PrintErr("  Updated test cache %p ix: %" Pd " with "
+    OS::PrintErr(
+        "  Updated test cache %p ix: %" Pd
+        " with "
         "(cid-or-fun: %p, type-args: %p, instantiator: %p, result: %s)\n"
-        "    instance  [class: (%p '%s' cid: %" Pd "),    type-args: %p %s]\n"
+        "    instance  [class: (%p '%s' cid: %" Pd
+        "),    type-args: %p %s]\n"
         "    test-type [class: (%p '%s' cid: %" Pd "), in-type-args: %p %s]\n",
-        new_cache.raw(),
-        len,
+        new_cache.raw(), len,
 
-        instance_class_id_or_function.raw(),
-        instance_type_arguments.raw(),
-        instantiator_type_arguments.raw(),
-        result.ToCString(),
+        instance_class_id_or_function.raw(), instance_type_arguments.raw(),
+        instantiator_type_arguments.raw(), result.ToCString(),
 
-        instance_class.raw(),
-        String::Handle(instance_class.Name()).ToCString(),
-        instance_class.id(),
-        instance_type_arguments.raw(),
+        instance_class.raw(), String::Handle(instance_class.Name()).ToCString(),
+        instance_class.id(), instance_type_arguments.raw(),
         instance_type_arguments.ToCString(),
 
         test_type.type_class(),
-        String::Handle(Class::Handle(test_type.type_class()).Name()).
-            ToCString(),
+        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());
   }
 }
 
 
 // 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: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
 DEFINE_RUNTIME_ENTRY(Instanceof, 4) {
   const Instance& instance = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const AbstractType& type =
       AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(3));
   ASSERT(type.IsFinalized());
-  ASSERT(!type.IsMalformed());  // Already checked in code generator.
-  ASSERT(!type.IsMalbounded());  // Already checked in code generator.
+  ASSERT(!type.IsMalformed());    // Already checked in code generator.
+  ASSERT(!type.IsMalbounded());   // Already checked in code generator.
   ASSERT(!type.IsDynamicType());  // No need to check assignment.
   Error& bound_error = Error::Handle(zone);
-  const Bool& result =
-      Bool::Get(instance.IsInstanceOf(type,
-                                      instantiator_type_arguments,
-                                      &bound_error));
+  const Bool& result = Bool::Get(
+      instance.IsInstanceOf(type, instantiator_type_arguments, &bound_error));
   if (FLAG_trace_type_checks) {
-    PrintTypeCheck("InstanceOf",
-        instance, type, instantiator_type_arguments, result);
+    PrintTypeCheck("InstanceOf", instance, type, instantiator_type_arguments,
+                   result);
   }
   if (!result.value() && !bound_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const TokenPosition location = GetCallerLocation();
-    String& bound_error_message =  String::Handle(
-        zone, String::New(bound_error.ToErrorCString()));
-    Exceptions::CreateAndThrowTypeError(
-        location, AbstractType::Handle(zone), AbstractType::Handle(zone),
-        Symbols::Empty(), bound_error_message);
+    String& bound_error_message =
+        String::Handle(zone, String::New(bound_error.ToErrorCString()));
+    Exceptions::CreateAndThrowTypeError(location, AbstractType::Handle(zone),
+                                        AbstractType::Handle(zone),
+                                        Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
-  UpdateTypeTestCache(
-      instance, type, instantiator_type_arguments, result, cache);
+  UpdateTypeTestCache(instance, type, instantiator_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: name of variable being assigned to.
 // Arg4: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
 DEFINE_RUNTIME_ENTRY(TypeCheck, 5) {
   const Instance& src_instance =
       Instance::CheckedHandle(zone, arguments.ArgAt(0));
   AbstractType& dst_type =
       AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
   const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(3));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(4));
-  ASSERT(!dst_type.IsMalformed());  // Already checked in code generator.
-  ASSERT(!dst_type.IsMalbounded());  // Already checked in code generator.
+  ASSERT(!dst_type.IsMalformed());    // Already checked in code generator.
+  ASSERT(!dst_type.IsMalbounded());   // Already checked in code generator.
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
-  ASSERT(!src_instance.IsNull());  // Already checked in inlined code.
+  ASSERT(!src_instance.IsNull());     // Already checked in inlined code.
 
   Error& bound_error = Error::Handle(zone);
   const bool is_instance_of = src_instance.IsInstanceOf(
       dst_type, instantiator_type_arguments, &bound_error);
 
   if (FLAG_trace_type_checks) {
-    PrintTypeCheck("TypeCheck",
-                   src_instance, dst_type, instantiator_type_arguments,
-                   Bool::Get(is_instance_of));
+    PrintTypeCheck("TypeCheck", src_instance, dst_type,
+                   instantiator_type_arguments, Bool::Get(is_instance_of));
   }
   if (!is_instance_of) {
     // Throw a dynamic type error.
     const TokenPosition location = GetCallerLocation();
     const AbstractType& src_type =
         AbstractType::Handle(zone, src_instance.GetType());
     if (!dst_type.IsInstantiated()) {
       // Instantiate dst_type before reporting the error.
       dst_type = dst_type.InstantiateFrom(instantiator_type_arguments, NULL,
                                           NULL, NULL, Heap::kNew);
       // Note that instantiated dst_type may be malbounded.
     }
-    String& bound_error_message =  String::Handle(zone);
+    String& bound_error_message = String::Handle(zone);
     if (!bound_error.IsNull()) {
       ASSERT(isolate->type_checks());
       bound_error_message = String::New(bound_error.ToErrorCString());
     }
-    Exceptions::CreateAndThrowTypeError(location, src_type, dst_type,
-                                        dst_name, bound_error_message);
+    Exceptions::CreateAndThrowTypeError(location, src_type, dst_type, dst_name,
+                                        bound_error_message);
     UNREACHABLE();
   }
-  UpdateTypeTestCache(
-      src_instance, dst_type, instantiator_type_arguments, Bool::True(), cache);
+  UpdateTypeTestCache(src_instance, dst_type, instantiator_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));
 
   if (src_instance.IsNull()) {
     const Array& args = Array::Handle(zone, Array::New(4));
-    args.SetAt(0, String::Handle(zone,
-        String::New("Failed assertion: boolean expression must not be null")));
+    args.SetAt(
+        0, String::Handle(
+               zone,
+               String::New(
+                   "Failed assertion: boolean expression must not be null")));
 
     // No source code for this assertion, set url to null.
     args.SetAt(1, String::Handle(zone, String::null()));
     args.SetAt(2, Smi::Handle(zone, Smi::New(0)));
     args.SetAt(3, Smi::Handle(zone, Smi::New(0)));
 
     Exceptions::ThrowByType(Exceptions::kAssertion, args);
     UNREACHABLE();
   }
 
@@ skipping 15 matching lines @@
 // 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());
-  Exceptions::CreateAndThrowTypeError(
-      location, src_type, dst_type, dst_name, String::Handle(zone));
+  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));
+  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& 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;
   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());
   const Function& target_function = Function::Handle(
       zone, caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
   if (!target_function.HasCode()) {
     const Error& error =
         Error::Handle(zone, Compiler::CompileFunction(thread, target_function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   const Code& target_code = Code::Handle(zone, target_function.CurrentCode());
   // Before patching verify that we are not repeatedly patching to the same
   // target.
   ASSERT(target_code.raw() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code));
-  CodePatcher::PatchStaticCallAt(caller_frame->pc(),
-                                 caller_code,
-                                 target_code);
+  CodePatcher::PatchStaticCallAt(caller_frame->pc(), caller_code, target_code);
   caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   if (FLAG_trace_patching) {
-    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");
+    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));
@@ skipping 59 matching lines @@
 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.
   const String& getter_name = String::Handle(Field::GetterName(target_name));
   const int kNumArguments = 1;
   ArgumentsDescriptor args_desc(
       Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
-  const Function& getter = Function::Handle(
-      Resolver::ResolveDynamicForReceiverClass(receiver_class,
-                                               getter_name,
-                                               args_desc));
+  const Function& getter =
+      Function::Handle(Resolver::ResolveDynamicForReceiverClass(
+          receiver_class, getter_name, args_desc));
   if (getter.IsNull() || getter.IsMethodExtractor()) {
     return false;
   }
   const Function& target_function =
       Function::Handle(receiver_class.GetInvocationDispatcher(
-          target_name,
-          arguments_descriptor,
-          RawFunction::kInvokeFieldDispatcher,
-          FLAG_lazy_dispatchers));
+          target_name, arguments_descriptor,
+          RawFunction::kInvokeFieldDispatcher, FLAG_lazy_dispatchers));
   ASSERT(!target_function.IsNull() || !FLAG_lazy_dispatchers);
   if (FLAG_trace_ic) {
-    OS::PrintErr("InvokeField IC miss: adding <%s> id:%" Pd " -> <%s>\n",
-        Class::Handle(receiver.clazz()).ToCString(),
-        receiver.GetClassId(),
+    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) {
+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)) {
+  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,
+            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(),
+      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) {
   const TypeArguments& checked_type_arguments = TypeArguments::Handle();
   Error& error = Error::Handle();
   bool result = receiver.IsInstanceOf(type, checked_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());
+  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,
     const ICData& ic_data) {
   const Instance& receiver = *args[0];
-  ArgumentsDescriptor
-      arguments_descriptor(Array::Handle(ic_data.arguments_descriptor()));
+  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(
       Resolver::ResolveDynamic(receiver, function_name, arguments_descriptor));
 
   ObjectStore* store = Isolate::Current()->object_store();
   if (target_function.raw() == store->simple_instance_of_function()) {
     // Replace the target function with constant function.
     const AbstractType& type = AbstractType::Cast(*args[1]);
-    target_function
-        = ComputeTypeCheckTarget(receiver, type, arguments_descriptor);
+    target_function =
+        ComputeTypeCheckTarget(receiver, type, arguments_descriptor);
   }
   if (target_function.IsNull()) {
     if (FLAG_trace_ic) {
       OS::PrintErr("InlineCacheMissHandler NULL function for %s receiver: %s\n",
                    String::Handle(ic_data.target_name()).ToCString(),
                    receiver.ToCString());
     }
     const Array& args_descriptor =
         Array::Handle(ic_data.arguments_descriptor());
     const String& target_name = String::Handle(ic_data.target_name());
-    target_function = InlineCacheMissHelper(receiver,
-                                            args_descriptor,
-                                            target_name);
+    target_function =
+        InlineCacheMissHelper(receiver, args_descriptor, target_name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
     return target_function.raw();
   }
   if (args.length() == 1) {
     ic_data.AddReceiverCheck(args[0]->GetClassId(), target_function);
   } else {
     GrowableArray<intptr_t> class_ids(args.length());
     ASSERT(ic_data.NumArgsTested() == args.length());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(args[i]->GetClassId());
     }
     ic_data.AddCheck(class_ids, target_function);
   }
   if (FLAG_trace_ic_miss_in_optimized || FLAG_trace_ic) {
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     if (FLAG_trace_ic_miss_in_optimized) {
       const Code& caller = Code::Handle(Code::LookupCode(caller_frame->pc()));
       if (caller.is_optimized()) {
         OS::PrintErr("IC miss in optimized code; call %s -> %s\n",
-            Function::Handle(caller.function()).ToCString(),
-            target_function.ToCString());
+                     Function::Handle(caller.function()).ToCString(),
+                     target_function.ToCString());
       }
     }
     if (FLAG_trace_ic) {
-      OS::PrintErr("InlineCacheMissHandler %" Pd " call at %#" Px "' "
+      OS::PrintErr("InlineCacheMissHandler %" Pd " call at %#" Px
+                   "' "
                    "adding <%s> id:%" Pd " -> <%s>\n",
-          args.length(),
-          caller_frame->pc(),
-          Class::Handle(receiver.clazz()).ToCString(),
-          receiver.GetClassId(),
-          target_function.ToCString());
+                   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.
@@ skipping 54 matching lines @@
 // 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.NumberOfChecks() == 1);
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (!target.HasCode()) {
-    const Error& error = Error::Handle(Compiler::CompileFunction(thread,
-                                                                 target));
+    const Error& error =
+        Error::Handle(Compiler::CompileFunction(thread, target));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   ASSERT(!target.IsNull() && target.HasCode());
   ic_data.AddReceiverCheck(arg.GetClassId(), target, 1);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
-    OS::PrintErr("StaticCallMissHandler at %#" Px
-                 " target %s (%" Pd ")\n",
+    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.NumberOfChecks() > 0);
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (!target.HasCode()) {
-    const Error& error = Error::Handle(Compiler::CompileFunction(thread,
-                                                                 target));
+    const Error& error =
+        Error::Handle(Compiler::CompileFunction(thread, target));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   ASSERT(!target.IsNull() && target.HasCode());
   GrowableArray<intptr_t> cids(2);
   cids.Add(arg0.GetClassId());
   cids.Add(arg1.GetClassId());
   ic_data.AddCheck(cids, target);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
-    OS::PrintErr("StaticCallMissHandler at %#" Px
-                 " target %s (%" Pd ", %" Pd ")\n",
+    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 */);
+    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));
 
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame->IsDartFrame());
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   const Function& caller_function =
       Function::Handle(zone, caller_frame->LookupDartFunction());
 
   SingleTargetCache& cache = SingleTargetCache::Handle(zone);
-  cache ^= CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(),
-                                                caller_code);
+  cache ^=
+      CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
   Code& old_target_code = Code::Handle(zone, cache.target());
   Function& old_target = Function::Handle(zone);
   old_target ^= old_target_code.owner();
 
   // We lost the original ICData when we patched to the monomorphic case.
   const String& name = String::Handle(zone, old_target.name());
   ASSERT(!old_target.HasOptionalParameters());
-  const Array& descriptor = Array::Handle(zone,
-      ArgumentsDescriptor::New(old_target.num_fixed_parameters()));
+  const Array& descriptor = Array::Handle(
+      zone, ArgumentsDescriptor::New(old_target.num_fixed_parameters()));
   const ICData& ic_data =
-      ICData::Handle(zone, ICData::New(caller_function,
-                                       name,
-                                       descriptor,
-                                       Thread::kNoDeoptId,
-                                       1, /* args_tested */
+      ICData::Handle(zone, ICData::New(caller_function, name, descriptor,
+                                       Thread::kNoDeoptId, 1, /* args_tested */
                                        false /* static_call */));
 
   // Maybe add the new target.
   Class& cls = Class::Handle(zone, receiver.clazz());
   ArgumentsDescriptor args_desc(descriptor);
-  Function& target_function = Function::Handle(zone,
-      Resolver::ResolveDynamicForReceiverClass(cls,
-                                               name,
-                                               args_desc));
+  Function& target_function = Function::Handle(
+      zone, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
   if (target_function.IsNull()) {
     target_function = InlineCacheMissHelper(receiver, descriptor, name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
   } else {
     ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
   }
 
   if (old_target.raw() == target_function.raw()) {
@@ skipping 18 matching lines @@
       // IC call stub.
       arguments.SetReturn(ic_data);
       return;
     }
   }
 
   // Call site is not single target, switch to call using ICData.
   const Code& stub =
       Code::Handle(zone, StubCode::ICCallThroughCode_entry()->code());
   ASSERT(!Isolate::Current()->compilation_allowed());
-  CodePatcher::PatchSwitchableCallAt(caller_frame->pc(),
-                                     caller_code,
-                                     ic_data,
+  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;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame->IsDartFrame());
-  const Code& caller_code =
-      Code::Handle(zone, caller_frame->LookupDartCode());
+  const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   const Function& caller_function =
       Function::Handle(zone, caller_frame->LookupDartFunction());
 
   const String& name = String::Handle(zone, unlinked.target_name());
   const Array& descriptor = Array::Handle(zone, unlinked.args_descriptor());
   const ICData& ic_data =
-      ICData::Handle(zone, ICData::New(caller_function,
-                                       name,
-                                       descriptor,
-                                       Thread::kNoDeoptId,
-                                       1, /* args_tested */
+      ICData::Handle(zone, ICData::New(caller_function, name, descriptor,
+                                       Thread::kNoDeoptId, 1, /* args_tested */
                                        false /* static_call */));
 
   Class& cls = Class::Handle(zone, receiver.clazz());
   ArgumentsDescriptor args_desc(descriptor);
-  Function& target_function = Function::Handle(zone,
-      Resolver::ResolveDynamicForReceiverClass(cls,
-                                               name,
-                                               args_desc));
+  Function& target_function = Function::Handle(
+      zone, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
   if (target_function.IsNull()) {
     target_function = InlineCacheMissHelper(receiver, descriptor, name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
   } else {
     ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
   }
 
-  if (!target_function.IsNull() &&
-      !target_function.HasOptionalParameters()) {
+  if (!target_function.IsNull() && !target_function.HasOptionalParameters()) {
     // Patch to monomorphic call.
     ASSERT(target_function.HasCode());
-    const Code& target_code =
-        Code::Handle(zone, target_function.CurrentCode());
+    const Code& target_code = Code::Handle(zone, target_function.CurrentCode());
     const Smi& expected_cid =
         Smi::Handle(zone, Smi::New(receiver.GetClassId()));
     CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code,
                                        expected_cid, target_code);
 
     // Return the ICData. The miss stub will jump to continue in the IC call
     // stub.
     arguments.SetReturn(ic_data);
     return;
   }
 
   // Patch to call through stub.
   const Code& stub =
       Code::Handle(zone, StubCode::ICCallThroughCode_entry()->code());
   ASSERT(!Isolate::Current()->compilation_allowed());
-  CodePatcher::PatchSwitchableCallAt(caller_frame->pc(),
-                                     caller_code,
-                                     ic_data,
+  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));
 
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame->IsDartFrame());
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   const Function& caller_function =
       Function::Handle(zone, caller_frame->LookupDartFunction());
 
   Smi& old_expected_cid = Smi::Handle(zone);
-  old_expected_cid ^= CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(),
-                                                          caller_code);
-  const Code& old_target_code =
-      Code::Handle(CodePatcher::GetSwitchableCallTargetAt(caller_frame->pc(),
-                                                          caller_code));
+  old_expected_cid ^=
+      CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
+  const Code& old_target_code = Code::Handle(
+      CodePatcher::GetSwitchableCallTargetAt(caller_frame->pc(), caller_code));
   Function& old_target = Function::Handle(zone);
   old_target ^= old_target_code.owner();
 
   // We lost the original ICData when we patched to the monomorphic case.
   const String& name = String::Handle(zone, old_target.name());
   ASSERT(!old_target.HasOptionalParameters());
-  const Array& descriptor = Array::Handle(zone,
-      ArgumentsDescriptor::New(old_target.num_fixed_parameters()));
+  const Array& descriptor = Array::Handle(
+      zone, ArgumentsDescriptor::New(old_target.num_fixed_parameters()));
   const ICData& ic_data =
-      ICData::Handle(zone, ICData::New(caller_function,
-                                       name,
-                                       descriptor,
-                                       Thread::kNoDeoptId,
-                                       1, /* args_tested */
+      ICData::Handle(zone, ICData::New(caller_function, name, descriptor,
+                                       Thread::kNoDeoptId, 1, /* args_tested */
                                        false /* static_call */));
 
   // Add the first target.
   ic_data.AddReceiverCheck(old_expected_cid.Value(), old_target);
 
   // Maybe add the new target.
   Class& cls = Class::Handle(zone, receiver.clazz());
   ArgumentsDescriptor args_desc(descriptor);
-  Function& target_function = Function::Handle(zone,
-      Resolver::ResolveDynamicForReceiverClass(cls,
-                                               name,
-                                               args_desc));
+  Function& target_function = Function::Handle(
+      zone, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
   if (target_function.IsNull()) {
     target_function = InlineCacheMissHelper(receiver, descriptor, name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
   } else {
     ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
   }
 
   if (old_target.raw() == target_function.raw()) {
     intptr_t lower, upper;
     if (old_expected_cid.Value() < receiver.GetClassId()) {
       lower = old_expected_cid.Value();
       upper = receiver.GetClassId();
     } else {
       lower = receiver.GetClassId();
       upper = old_expected_cid.Value();
     }
 
     if (IsSingleTarget(isolate, zone, lower, upper, target_function, name)) {
       const SingleTargetCache& cache =
           SingleTargetCache::Handle(SingleTargetCache::New());
       const Code& code = Code::Handle(target_function.CurrentCode());
       cache.set_target(code);
       cache.set_entry_point(code.UncheckedEntryPoint());
       cache.set_lower_limit(lower);
       cache.set_upper_limit(upper);
-      const Code& stub = Code::Handle(zone,
-          StubCode::SingleTargetCall_entry()->code());
-      CodePatcher::PatchSwitchableCallAt(caller_frame->pc(),
-                                         caller_code,
-                                         cache,
+      const Code& stub =
+          Code::Handle(zone, StubCode::SingleTargetCall_entry()->code());
+      CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code, cache,
                                          stub);
       // Return the ICData. The miss stub will jump to continue in the IC call
       // stub.
       arguments.SetReturn(ic_data);
       return;
     }
   }
 
   // Patch to call through stub.
   const Code& stub =
       Code::Handle(zone, StubCode::ICCallThroughCode_entry()->code());
   ASSERT(!Isolate::Current()->compilation_allowed());
-  CodePatcher::PatchSwitchableCallAt(caller_frame->pc(),
-                                     caller_code,
-                                     ic_data,
+  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.
@@ skipping 17 matching lines @@
     name = MegamorphicCache::Cast(ic_data_or_cache).target_name();
   }
   Class& cls = Class::Handle(zone, 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",
                  cls.ToCString(), name.ToCString());
   }
 
   ArgumentsDescriptor args_desc(descriptor);
-  Function& target_function = Function::Handle(zone,
-      Resolver::ResolveDynamicForReceiverClass(cls,
-                                               name,
-                                               args_desc));
+  Function& target_function = Function::Handle(
+      zone, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
   if (target_function.IsNull()) {
     target_function = InlineCacheMissHelper(receiver, descriptor, name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
     arguments.SetReturn(target_function);
     return;
   }
 
   if (ic_data_or_cache.IsICData()) {
     const ICData& ic_data = ICData::Cast(ic_data_or_cache);
 
     if ((ic_data.NumberOfChecks() == 0) &&
         !target_function.HasOptionalParameters() &&
         !Isolate::Current()->compilation_allowed()) {
       // This call site is unlinked: transition to a monomorphic direct call.
       // Note we cannot do this if the target has optional parameters because
       // the monomorphic direct call does not load the arguments descriptor.
       // We cannot do this if we are still in the middle of precompiling because
       // the monomorphic case hides an live instance selector from the
       // treeshaker.
 
       if (!target_function.HasCode()) {
         const Error& error =
-          Error::Handle(Compiler::CompileFunction(thread, target_function));
+            Error::Handle(Compiler::CompileFunction(thread, target_function));
         if (!error.IsNull()) {
           Exceptions::PropagateError(error);
         }
       }
 
       DartFrameIterator iterator;
       StackFrame* miss_function_frame = iterator.NextFrame();
       ASSERT(miss_function_frame->IsDartFrame());
       StackFrame* caller_frame = iterator.NextFrame();
       ASSERT(caller_frame->IsDartFrame());
       const Code& caller_code =
           Code::Handle(zone, caller_frame->LookupDartCode());
       const Code& target_code =
           Code::Handle(zone, target_function.CurrentCode());
       const Smi& expected_cid =
           Smi::Handle(zone, Smi::New(receiver.GetClassId()));
 
       CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code,
                                          expected_cid, target_code);
     } else {
       ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
       if (ic_data.NumberOfChecks() > FLAG_max_polymorphic_checks) {
         // Switch to megamorphic call.
-        const MegamorphicCache& cache = MegamorphicCache::Handle(zone,
-            MegamorphicCacheTable::Lookup(isolate, name, descriptor));
+        const MegamorphicCache& cache = MegamorphicCache::Handle(
+            zone, MegamorphicCacheTable::Lookup(isolate, name, descriptor));
         DartFrameIterator iterator;
         StackFrame* miss_function_frame = iterator.NextFrame();
         ASSERT(miss_function_frame->IsDartFrame());
         StackFrame* caller_frame = iterator.NextFrame();
         ASSERT(caller_frame->IsDartFrame());
         const Code& caller_code =
             Code::Handle(zone, caller_frame->LookupDartCode());
         const Code& stub =
             Code::Handle(zone, StubCode::MegamorphicCall_entry()->code());
 
@@ skipping 29 matching lines @@
   if (ic_data_or_cache.IsICData()) {
     target_name = ICData::Cast(ic_data_or_cache).target_name();
   } else {
     ASSERT(ic_data_or_cache.IsMegamorphicCache());
     target_name = MegamorphicCache::Cast(ic_data_or_cache).target_name();
   }
 
   Class& cls = Class::Handle(zone, receiver.clazz());
   Function& function = Function::Handle(zone);
 
-  // Dart distinguishes getters and regular methods and allows their calls
-  // to mix with conversions, and its selectors are independent of arity. So do
-  // a zigzagged lookup to see if this call failed because of an arity mismatch,
-  // need for conversion, or there really is no such method.
+// Dart distinguishes getters and regular methods and allows their calls
+// to mix with conversions, and its selectors are independent of arity. So do
+// a zigzagged lookup to see if this call failed because of an arity mismatch,
+// need for conversion, or there really is no such method.
 
 #define NO_SUCH_METHOD()                                                       \
-  const Object& result = Object::Handle(zone,                                  \
-      DartEntry::InvokeNoSuchMethod(receiver,                                  \
-                                    target_name,                               \
-                                    orig_arguments,                            \
-                                    orig_arguments_desc));                     \
+  const Object& result = Object::Handle(                                       \
+      zone, DartEntry::InvokeNoSuchMethod(                                     \
+                receiver, target_name, orig_arguments, orig_arguments_desc));  \
   CheckResultError(result);                                                    \
-  arguments.SetReturn(result);                                                 \
+  arguments.SetReturn(result);
 
 #define CLOSURIZE(some_function)                                               \
   const Function& closure_function =                                           \
       Function::Handle(zone, some_function.ImplicitClosureFunction());         \
-  const Object& result =                                                       \
-      Object::Handle(zone, closure_function.ImplicitInstanceClosure(receiver));\
-  arguments.SetReturn(result);                                                 \
+  const Object& result = Object::Handle(                                       \
+      zone, closure_function.ImplicitInstanceClosure(receiver));               \
+  arguments.SetReturn(result);
 
   const bool is_getter = Field::IsGetterName(target_name);
   if (is_getter) {
     // o.foo (o.get:foo) failed, closurize o.foo() if it exists. Or,
     // o#foo (o.get:#foo) failed, closurizee o.foo or o.foo(), whichever is
     // encountered first on the inheritance chain. Or,
     // o#foo= (o.get:#set:foo) failed, closurize o.foo= if it exists.
     String& field_name =
         String::Handle(zone, Field::NameFromGetter(target_name));
 
@@ skipping 39 matching lines @@
 
     // Fall through for noSuchMethod
   } else {
     // o.foo(...) failed, invoke noSuchMethod is foo exists but has the wrong
     // number of arguments, or try (o.foo).call(...)
 
     if ((target_name.raw() == Symbols::Call().raw()) && receiver.IsClosure()) {
       // Special case: closures are implemented with a call getter instead of a
       // call method and with lazy dispatchers the field-invocation-dispatcher
       // would perform the closure call.
-      const Object& result =
-        Object::Handle(zone, DartEntry::InvokeClosure(orig_arguments,
-                                                      orig_arguments_desc));
+      const Object& result = Object::Handle(
+          zone, DartEntry::InvokeClosure(orig_arguments, orig_arguments_desc));
       CheckResultError(result);
       arguments.SetReturn(result);
       return;
     }
 
     const String& getter_name =
         String::Handle(zone, Field::GetterName(target_name));
     while (!cls.IsNull()) {
       function ^= cls.LookupDynamicFunction(target_name);
       if (!function.IsNull()) {
         ArgumentsDescriptor args_desc(orig_arguments_desc);
         ASSERT(!function.AreValidArguments(args_desc, NULL));
         break;  // mismatch, invoke noSuchMethod
       }
       function ^= cls.LookupDynamicFunction(getter_name);
       if (!function.IsNull()) {
         const Array& getter_arguments = Array::Handle(Array::New(1));
         getter_arguments.SetAt(0, receiver);
-        const Object& getter_result =
-          Object::Handle(zone, DartEntry::InvokeFunction(function,
-                                                         getter_arguments));
+        const Object& getter_result = Object::Handle(
+            zone, DartEntry::InvokeFunction(function, getter_arguments));
         CheckResultError(getter_result);
         ASSERT(getter_result.IsNull() || getter_result.IsInstance());
 
         orig_arguments.SetAt(0, getter_result);
-        const Object& call_result =
-          Object::Handle(zone, DartEntry::InvokeClosure(orig_arguments,
-                                                        orig_arguments_desc));
+        const Object& call_result = Object::Handle(
+            zone,
+            DartEntry::InvokeClosure(orig_arguments, orig_arguments_desc));
         CheckResultError(call_result);
         arguments.SetReturn(call_result);
         return;
       }
       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));
+  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();
@@ skipping 15 matching lines @@
     UNREACHABLE();
   }
 
   // The following code is used to stress test deoptimization and
   // debugger stack tracing.
   bool do_deopt = false;
   bool do_stacktrace = false;
   bool do_reload = false;
   const intptr_t isolate_reload_every =
       isolate->reload_every_n_stack_overflow_checks();
-  if ((FLAG_deoptimize_every > 0) ||
-      (FLAG_stacktrace_every > 0) ||
+  if ((FLAG_deoptimize_every > 0) || (FLAG_stacktrace_every > 0) ||
       (isolate_reload_every > 0)) {
     // TODO(turnidge): To make --deoptimize_every and
     // --stacktrace-every faster we could move this increment/test to
     // the generated code.
     int32_t count = thread->IncrementAndGetStackOverflowCount();
-    if (FLAG_deoptimize_every > 0 &&
-        (count % FLAG_deoptimize_every) == 0) {
+    if (FLAG_deoptimize_every > 0 && (count % FLAG_deoptimize_every) == 0) {
       do_deopt = true;
     }
-    if (FLAG_stacktrace_every > 0 &&
-        (count % FLAG_stacktrace_every) == 0) {
+    if (FLAG_stacktrace_every > 0 && (count % FLAG_stacktrace_every) == 0) {
       do_stacktrace = true;
     }
-    if ((isolate_reload_every > 0) &&
-        (count % isolate_reload_every) == 0) {
+    if ((isolate_reload_every > 0) && (count % isolate_reload_every) == 0) {
       do_reload = isolate->CanReload();
     }
   }
-  if ((FLAG_deoptimize_filter != NULL) ||
-      (FLAG_stacktrace_filter != NULL) ||
-       FLAG_reload_every_optimized) {
+  if ((FLAG_deoptimize_filter != NULL) || (FLAG_stacktrace_filter != NULL) ||
+      FLAG_reload_every_optimized) {
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     ASSERT(frame != NULL);
     const Code& code = Code::Handle(frame->LookupDartCode());
     ASSERT(!code.IsNull());
     const Function& function = Function::Handle(code.function());
     ASSERT(!function.IsNull());
     const char* function_name = function.ToFullyQualifiedCString();
     ASSERT(function_name != NULL);
     if (!code.is_optimized() && FLAG_reload_every_optimized) {
       // Don't do the reload if we aren't inside optimized code.
       do_reload = false;
     }
-    if (code.is_optimized() &&
-        FLAG_deoptimize_filter != NULL &&
+    if (code.is_optimized() && FLAG_deoptimize_filter != NULL &&
         strstr(function_name, FLAG_deoptimize_filter) != NULL) {
       OS::PrintErr("*** Forcing deoptimization (%s)\n",
                    function.ToFullyQualifiedCString());
       do_deopt = true;
     }
     if (FLAG_stacktrace_filter != NULL &&
         strstr(function_name, FLAG_stacktrace_filter) != NULL) {
       OS::PrintErr("*** Computing stacktrace (%s)\n",
                    function.ToFullyQualifiedCString());
       do_stacktrace = true;
@@ skipping 29 matching lines @@
     DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
     intptr_t num_frames = stack->Length();
     for (intptr_t i = 0; i < num_frames; i++) {
       ActivationFrame* frame = stack->FrameAt(i);
 #ifndef DART_PRECOMPILED_RUNTIME
       // Ensure that we have unoptimized code.
       frame->function().EnsureHasCompiledUnoptimizedCode();
 #endif
       // Variable locations and number are unknown when precompiling.
       const int num_vars =
-         FLAG_precompiled_runtime ? 0 : frame->NumLocalVariables();
+          FLAG_precompiled_runtime ? 0 : frame->NumLocalVariables();
       TokenPosition unused = TokenPosition::kNoSource;
       for (intptr_t v = 0; v < num_vars; v++) {
         frame->VariableAt(v, &var_name, &unused, &unused, &unused, &var_value);
       }
     }
     FLAG_stacktrace_every = saved_stacktrace_every;
   }
 
   const Error& error = Error::Handle(thread->HandleInterrupts());
   if (!error.IsNull()) {
@@ skipping 29 matching lines @@
     }
 
     // The unoptimized code is on the stack and should never be detached from
     // the function at this point.
     ASSERT(function.unoptimized_code() != Object::null());
     intptr_t osr_id =
         Code::Handle(function.unoptimized_code()).GetDeoptIdForOsr(frame->pc());
     ASSERT(osr_id != Compiler::kNoOSRDeoptId);
     if (FLAG_trace_osr) {
       OS::Print("Attempting OSR for %s at id=%" Pd ", count=%" Pd "\n",
-                function.ToFullyQualifiedCString(),
-                osr_id,
+                function.ToFullyQualifiedCString(), osr_id,
                 function.usage_counter());
     }
 
     const Code& original_code = Code::Handle(function.CurrentCode());
     // Since the code is referenced from the frame and the ZoneHandle,
     // it cannot have been removed from the function.
     ASSERT(!original_code.IsNull());
-    const Error& error = Error::Handle(Compiler::CompileOptimizedFunction(
-        thread, function, osr_id));
+    const Error& error = Error::Handle(
+        Compiler::CompileOptimizedFunction(thread, function, osr_id));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
 
     const Code& optimized_code = Code::Handle(function.CurrentCode());
     // The current code will not be changed in the case that the compiler
     // bailed out during OSR compilation.
     if (optimized_code.raw() != original_code.raw()) {
       // The OSR code does not work for calling the function, so restore the
       // unoptimized code.  Patch the stack frame to return into the OSR
       // code.
       uword optimized_entry =
           Instructions::UncheckedEntryPoint(optimized_code.instructions());
       function.AttachCode(original_code);
       frame->set_pc(optimized_entry);
       frame->set_pc_marker(optimized_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;
   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());
+               " %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));
+  const Function& function = Function::CheckedHandle(zone, arguments.ArgAt(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
   if (Compiler::CanOptimizeFunction(thread, function)) {
     if (FLAG_background_compilation) {
       Field& field = Field::Handle(zone, isolate->GetDeoptimizingBoxedField());
       while (!field.IsNull()) {
         if (FLAG_trace_optimization || FLAG_trace_field_guards) {
           THR_Print("Lazy disabling unboxing of %s\n", field.ToCString());
         }
@@ skipping 64 matching lines @@
     // Since function's current code is always unpatched, the entry frame always
     // calls to unpatched code.
     UNREACHABLE();
   }
   ASSERT(frame->IsDartFrame());
   const Code& caller_code = Code::Handle(zone, frame->LookupDartCode());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       zone, caller_code.GetStaticCallTargetFunctionAt(frame->pc()));
   if (!target_function.HasCode()) {
-    const Error& error = Error::Handle(
-        zone, Compiler::CompileFunction(thread, target_function));
+    const Error& error =
+        Error::Handle(zone, Compiler::CompileFunction(thread, target_function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   ASSERT(target_function.HasCode());
 
-  const Code& current_target_code = Code::Handle(
-      zone, target_function.CurrentCode());
-  CodePatcher::PatchStaticCallAt(frame->pc(),
-                                 caller_code,
-                                 current_target_code);
+  const Code& current_target_code =
+      Code::Handle(zone, target_function.CurrentCode());
+  CodePatcher::PatchStaticCallAt(frame->pc(), caller_code, current_target_code);
   caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
   if (FLAG_trace_patching) {
-    OS::PrintErr("FixCallersTarget: caller %#" Px " "
+    OS::PrintErr("FixCallersTarget: caller %#" Px
+                 " "
                  "target '%s' -> %#" Px "\n",
-                 frame->pc(),
-                 target_function.ToFullyQualifiedCString(),
+                 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) {
@@ skipping 14 matching lines @@
   ASSERT(!caller_code.IsNull());
   const Code& stub = Code::Handle(
       CodePatcher::GetStaticCallTargetAt(frame->pc(), caller_code));
   Class& alloc_class = Class::ZoneHandle(zone);
   alloc_class ^= stub.owner();
   Code& alloc_stub = Code::Handle(zone, alloc_class.allocation_stub());
   if (alloc_stub.IsNull()) {
     alloc_stub = StubCode::GetAllocationStubForClass(alloc_class);
     ASSERT(!alloc_stub.IsDisabled());
   }
-  CodePatcher::PatchStaticCallAt(frame->pc(),
-                                 caller_code,
-                                 alloc_stub);
+  CodePatcher::PatchStaticCallAt(frame->pc(), caller_code, alloc_stub);
   caller_code.SetStubCallTargetCodeAt(frame->pc(), alloc_stub);
   if (FLAG_trace_patching) {
-    OS::PrintErr("FixAllocationStubTarget: caller %#" Px " alloc-class %s "
-        " -> %#" Px "\n",
-        frame->pc(),
-        alloc_class.ToCString(),
-        alloc_stub.UncheckedEntryPoint());
+    OS::PrintErr("FixAllocationStubTarget: caller %#" Px
+                 " alloc-class %s "
+                 " -> %#" 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)
+#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());
@@ skipping 14 matching lines @@
   }
 
 #if defined(TARGET_ARCH_DBC)
   const Instructions& instrs =
       Instructions::Handle(zone, optimized_code.instructions());
   {
     WritableInstructionsScope writable(instrs.PayloadStart(), instrs.size());
     CodePatcher::InsertDeoptimizationCallAt(frame->pc());
     if (FLAG_trace_patching) {
       const String& name = String::Handle(function.name());
-      OS::PrintErr(
-          "InsertDeoptimizationCallAt: 0x%" Px " for %s\n",
-          frame->pc(), name.ToCString());
+      OS::PrintErr("InsertDeoptimizationCallAt: 0x%" Px " for %s\n",
+                   frame->pc(), name.ToCString());
     }
     const ExceptionHandlers& handlers =
         ExceptionHandlers::Handle(zone, optimized_code.exception_handlers());
     RawExceptionHandlers::HandlerInfo info;
     for (intptr_t i = 0; i < handlers.num_entries(); ++i) {
       handlers.GetHandlerInfo(i, &info);
       const uword patch_pc = instrs.PayloadStart() + info.handler_pc_offset;
       CodePatcher::InsertDeoptimizationCallAt(patch_pc);
       if (FLAG_trace_patching) {
         OS::PrintErr("  at handler 0x%" Px "\n", patch_pc);
@@ skipping 80 matching lines @@
   *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,
+DEFINE_LEAF_RUNTIME_ENTRY(intptr_t,
+                          DeoptimizeCopyFrame,
                           2,
                           uword saved_registers_address,
                           uword is_lazy_deopt) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   StackZone zone(thread);
   HANDLESCOPE(thread);
 
   // All registers have been saved below last-fp as if they were locals.
-  const uword last_fp = saved_registers_address
-                        + (kNumberOfSavedCpuRegisters * kWordSize)
-                        + (kNumberOfSavedFpuRegisters * kFpuRegisterSize)
-                        - ((kFirstLocalSlotFromFp + 1) * kWordSize);
+  const uword last_fp = saved_registers_address +
+                        (kNumberOfSavedCpuRegisters * kWordSize) +
+                        (kNumberOfSavedFpuRegisters * kFpuRegisterSize) -
+                        ((kFirstLocalSlotFromFp + 1) * kWordSize);
 
   // Get optimized code and frame that need to be deoptimized.
   DartFrameIterator iterator(last_fp);
 
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(optimized_code.is_optimized());
   const Function& top_function =
       Function::Handle(thread->zone(), optimized_code.function());
   const bool deoptimizing_code = top_function.HasOptimizedCode();
   if (FLAG_trace_deoptimization) {
     const Function& function = Function::Handle(optimized_code.function());
     THR_Print("== Deoptimizing code for '%s', %s, %s\n",
-       function.ToFullyQualifiedCString(),
-       deoptimizing_code ? "code & frame" : "frame",
-       is_lazy_deopt ? "lazy-deopt" : "");
+              function.ToFullyQualifiedCString(),
+              deoptimizing_code ? "code & frame" : "frame",
+              is_lazy_deopt ? "lazy-deopt" : "");
   }
 
 #if !defined(TARGET_ARCH_DBC)
   if (is_lazy_deopt) {
     uword deopt_pc = isolate->FindPendingDeopt(caller_frame->fp());
     if (FLAG_trace_deoptimization) {
-      THR_Print("Lazy deopt fp=%" Pp " pc=%" Pp "\n",
-                caller_frame->fp(), deopt_pc);
+      THR_Print("Lazy deopt fp=%" Pp " pc=%" Pp "\n", caller_frame->fp(),
+                deopt_pc);
     }
 
     // N.B.: Update frame before updating pending deopt table. The profiler
     // may attempt a stack walk in between.
     caller_frame->set_pc(deopt_pc);
     ASSERT(caller_frame->pc() == deopt_pc);
     ASSERT(optimized_code.ContainsInstructionAt(caller_frame->pc()));
     isolate->ClearPendingDeoptsAtOrBelow(caller_frame->fp());
   } else {
     if (FLAG_trace_deoptimization) {
-      THR_Print("Eager deopt fp=%" Pp " pc=%" Pp "\n",
-                caller_frame->fp(), caller_frame->pc());
+      THR_Print("Eager deopt fp=%" Pp " pc=%" Pp "\n", caller_frame->fp(),
+                caller_frame->pc());
     }
   }
 #endif  // !DBC
 
   // Copy the saved registers from the stack.
   fpu_register_t* fpu_registers;
   intptr_t* cpu_registers;
   CopySavedRegisters(saved_registers_address, &fpu_registers, &cpu_registers);
 
   // Create the DeoptContext.
-  DeoptContext* deopt_context =
-      new DeoptContext(caller_frame,
-                       optimized_code,
-                       DeoptContext::kDestIsOriginalFrame,
-                       fpu_registers,
-                       cpu_registers,
-                       is_lazy_deopt != 0,
-                       deoptimizing_code);
+  DeoptContext* deopt_context = new DeoptContext(
+      caller_frame, optimized_code, DeoptContext::kDestIsOriginalFrame,
+      fpu_registers, cpu_registers, is_lazy_deopt != 0, deoptimizing_code);
   isolate->set_deopt_context(deopt_context);
 
   // Stack size (FP - SP) in bytes.
   return deopt_context->DestStackAdjustment() * kWordSize;
 #else
   UNREACHABLE();
   return 0;
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 END_LEAF_RUNTIME_ENTRY
@@ skipping 136 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart