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

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 35 matching lines @@
 #include "vm/timer.h"
 #include "vm/type_table.h"
 #include "vm/version.h"
 
 namespace dart {
 
 #define T (thread())
 #define I (isolate())
 #define Z (zone())
 
-
 DEFINE_FLAG(bool, print_unique_targets, false, "Print unique dynamic targets");
 DEFINE_FLAG(bool, trace_precompiler, false, "Trace precompiler.");
 DEFINE_FLAG(
     int,
     max_speculative_inlining_attempts,
     1,
     "Max number of attempts with speculative inlining (precompilation only)");
 DEFINE_FLAG(int, precompiler_rounds, 1, "Number of precompiler iterations");
 
 DECLARE_FLAG(bool, allocation_sinking);
@@ skipping 13 matching lines @@
 DECLARE_FLAG(bool, trace_inlining_intervals);
 DECLARE_FLAG(int, inlining_hotness);
 DECLARE_FLAG(int, inlining_size_threshold);
 DECLARE_FLAG(int, inlining_callee_size_threshold);
 DECLARE_FLAG(int, inline_getters_setters_smaller_than);
 DECLARE_FLAG(int, inlining_depth_threshold);
 DECLARE_FLAG(int, inlining_caller_size_threshold);
 DECLARE_FLAG(int, inlining_constant_arguments_max_size_threshold);
 DECLARE_FLAG(int, inlining_constant_arguments_min_size_threshold);
 
-
 #ifdef DART_PRECOMPILER
 
 class DartPrecompilationPipeline : public DartCompilationPipeline {
  public:
   explicit DartPrecompilationPipeline(Zone* zone,
                                       FieldTypeMap* field_map = NULL)
       : zone_(zone), result_type_(CompileType::None()), field_map_(field_map) {}
 
   virtual void FinalizeCompilation(FlowGraph* flow_graph) {
     if ((field_map_ != NULL) &&
@@ skipping 59 matching lines @@
   }
 
   CompileType result_type() { return result_type_; }
 
  private:
   Zone* zone_;
   CompileType result_type_;
   FieldTypeMap* field_map_;
 };
 
-
 class PrecompileParsedFunctionHelper : public ValueObject {
  public:
   PrecompileParsedFunctionHelper(Precompiler* precompiler,
                                  ParsedFunction* parsed_function,
                                  bool optimized)
       : precompiler_(precompiler),
         parsed_function_(parsed_function),
         optimized_(optimized),
         thread_(Thread::Current()) {}
 
@@ skipping 10 matching lines @@
                            FlowGraph* flow_graph);
 
   Precompiler* precompiler_;
   ParsedFunction* parsed_function_;
   const bool optimized_;
   Thread* const thread_;
 
   DISALLOW_COPY_AND_ASSIGN(PrecompileParsedFunctionHelper);
 };
 
-
 static void Jump(const Error& error) {
   Thread::Current()->long_jump_base()->Jump(1, error);
 }
 
-
 TypeRangeCache::TypeRangeCache(Precompiler* precompiler,
                                Thread* thread,
                                intptr_t num_cids)
     : precompiler_(precompiler),
       thread_(thread),
       lower_limits_(thread->zone()->Alloc<intptr_t>(num_cids)),
       upper_limits_(thread->zone()->Alloc<intptr_t>(num_cids)) {
   for (intptr_t i = 0; i < num_cids; i++) {
     lower_limits_[i] = kNotComputed;
     upper_limits_[i] = kNotComputed;
   }
   ASSERT(precompiler->type_range_cache() == NULL);
   precompiler->set_type_range_cache(this);
 }
 
-
 TypeRangeCache::~TypeRangeCache() {
   ASSERT(precompiler_->type_range_cache() == this);
   precompiler_->set_type_range_cache(NULL);
 }
 
-
 RawError* Precompiler::CompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[],
     uint8_t* jit_feedback,
     intptr_t jit_feedback_length) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Precompiler precompiler(Thread::Current());
     precompiler.LoadFeedback(jit_feedback, jit_feedback_length);
     precompiler.DoCompileAll(embedder_entry_points);
     return Error::null();
   } else {
     Thread* thread = Thread::Current();
     const Error& error = Error::Handle(thread->sticky_error());
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
-
 bool TypeRangeCache::InstanceOfHasClassRange(const AbstractType& type,
                                              intptr_t* lower_limit,
                                              intptr_t* upper_limit) {
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
 
   if (!type.IsInstantiated()) return false;
   if (type.IsFunctionType()) return false;
   if (type.IsDartFunctionType()) return false;
 
   Zone* zone = thread_->zone();
   const TypeArguments& type_arguments =
       TypeArguments::Handle(zone, type.arguments());
   if (!type_arguments.IsNull() &&
       !type_arguments.IsRaw(0, type_arguments.Length()))
     return false;
 
-
   intptr_t type_cid = type.type_class_id();
   if (lower_limits_[type_cid] == kNotContiguous) return false;
   if (lower_limits_[type_cid] != kNotComputed) {
     *lower_limit = lower_limits_[type_cid];
     *upper_limit = upper_limits_[type_cid];
     return true;
   }
 
-
   *lower_limit = -1;
   *upper_limit = -1;
   intptr_t last_matching_cid = -1;
 
   ClassTable* table = thread_->isolate()->class_table();
   Class& cls = Class::Handle(zone);
   AbstractType& cls_type = AbstractType::Handle(zone);
   for (intptr_t cid = kInstanceCid; cid < table->NumCids(); cid++) {
     // Create local zone because deep hierarchies may allocate lots of handles
     // within one iteration of this loop.
@@ skipping 47 matching lines @@
   if (FLAG_trace_precompiler) {
     THR_Print("Type check for %s is cid range [%" Pd ", %" Pd "]\n",
               type.ToCString(), *lower_limit, *upper_limit);
   }
 
   lower_limits_[type_cid] = *lower_limit;
   upper_limits_[type_cid] = *upper_limit;
   return true;
 }
 
-
 Precompiler::Precompiler(Thread* thread)
     : thread_(thread),
       zone_(NULL),
       isolate_(thread->isolate()),
       jit_feedback_(NULL),
       changed_(false),
       retain_root_library_caches_(false),
       function_count_(0),
       class_count_(0),
       selector_count_(0),
@@ skipping 12 matching lines @@
       functions_to_retain_(),
       classes_to_retain_(),
       typeargs_to_retain_(),
       types_to_retain_(),
       consts_to_retain_(),
       field_type_map_(),
       type_range_cache_(NULL),
       error_(Error::Handle()),
       get_runtime_type_is_unique_(false) {}
 
-
 void Precompiler::LoadFeedback(uint8_t* buffer, intptr_t length) {
   if (buffer == NULL) {
     if (FLAG_trace_precompiler) {
       THR_Print("Precompiler running without JIT feedback\n");
     }
 
     // Flags affecting compilation only:
     // There is no counter feedback in precompilation, so ignore the counter
     // when making inlining decisions.
     FLAG_inlining_hotness = 0;
@@ skipping 20 matching lines @@
     ParsedJSONError* error = static_cast<ParsedJSONError*>(root);
     THR_Print("Error parsing JIT feedback: %s:%" Pd "\n", error->message(),
               error->position());
   } else if (!root->IsObject()) {
     THR_Print("Error parsing JIT feedback: object expected\n");
   } else {
     jit_feedback_ = static_cast<ParsedJSONObject*>(root);
   }
 }
 
-
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
   ASSERT(I->compilation_allowed());
 
   {
     StackZone stack_zone(T);
     zone_ = stack_zone.GetZone();
 
     {
       HANDLESCOPE(T);
@@ skipping 100 matching lines @@
     THR_Print("Dropped %" Pd " functions,", dropped_function_count_);
     THR_Print(" %" Pd " fields,", dropped_field_count_);
     THR_Print(" %" Pd " symbols,", symbols_before - symbols_after);
     THR_Print(" %" Pd " types,", dropped_type_count_);
     THR_Print(" %" Pd " type arguments,", dropped_typearg_count_);
     THR_Print(" %" Pd " classes,", dropped_class_count_);
     THR_Print(" %" Pd " libraries.\n", dropped_library_count_);
   }
 }
 
-
 static void CompileStaticInitializerIgnoreErrors(const Field& field) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Precompiler::CompileStaticInitializer(field, /* compute_type = */ true);
   } else {
     // Ignore compile-time errors here. If the field is actually used,
     // the error will be reported later during Iterate().
   }
 }
 
-
 void Precompiler::PrecompileStaticInitializers() {
   class StaticInitializerVisitor : public ClassVisitor {
    public:
     explicit StaticInitializerVisitor(Zone* zone)
         : fields_(Array::Handle(zone)),
           field_(Field::Handle(zone)),
           function_(Function::Handle(zone)) {}
     void Visit(const Class& cls) {
       fields_ = cls.fields();
       for (intptr_t j = 0; j < fields_.Length(); j++) {
@@ skipping 12 matching lines @@
     Array& fields_;
     Field& field_;
     Function& function_;
   };
 
   HANDLESCOPE(T);
   StaticInitializerVisitor visitor(Z);
   ProgramVisitor::VisitClasses(&visitor);
 }
 
-
 void Precompiler::PrecompileConstructors() {
   class ConstructorVisitor : public FunctionVisitor {
    public:
     explicit ConstructorVisitor(Precompiler* precompiler, Zone* zone)
         : precompiler_(precompiler), zone_(zone) {}
     void Visit(const Function& function) {
       if (!function.IsGenerativeConstructor()) return;
       if (function.HasCode()) {
         // Const constructors may have been visited before. Recompile them here
         // to collect type information for final fields for them as well.
@@ skipping 22 matching lines @@
     current->field_->set_guarded_cid(cid);
     current->field_->set_is_nullable(cid == kNullCid || cid == kDynamicCid);
     if (FLAG_trace_precompiler) {
       THR_Print(
           "Field %s <- Type %s\n", current->field_->ToCString(),
           Class::Handle(T->isolate()->class_table()->At(cid)).ToCString());
     }
   }
 }
 
-
 void Precompiler::AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]) {
   // Note that <rootlibrary>.main is not a root. The appropriate main will be
   // discovered through _getMainClosure.
 
   AddSelector(Symbols::NoSuchMethod());
 
   AddSelector(Symbols::Call());  // For speed, not correctness.
 
   // Allocated from C++.
   Class& cls = Class::Handle(Z);
@@ skipping 71 matching lines @@
   } else if (main_closure.IsError()) {
     const Error& error = Error::Cast(main_closure);
     String& msg =
         String::Handle(Z, String::NewFormatted("Cannot find main closure %s\n",
                                                error.ToErrorCString()));
     Jump(Error::Handle(Z, ApiError::New(msg)));
     UNREACHABLE();
   }
 }
 
-
 void Precompiler::AddEntryPoints(Dart_QualifiedFunctionName entry_points[]) {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Function& func = Function::Handle(Z);
   Field& field = Field::Handle(Z);
   String& library_uri = String::Handle(Z);
   String& class_name = String::Handle(Z);
   String& function_name = String::Handle(Z);
 
   for (intptr_t i = 0; entry_points[i].library_uri != NULL; i++) {
@@ skipping 59 matching lines @@
         // code and only instantiated from C++.
         AddInstantiatedClass(cls);
       }
     }
     if (!field.IsNull()) {
       AddField(field);
     }
   }
 }
 
-
 void Precompiler::Iterate() {
   Function& function = Function::Handle(Z);
 
   while (changed_) {
     changed_ = false;
 
     while (pending_functions_.Length() > 0) {
       function ^= pending_functions_.RemoveLast();
       ProcessFunction(function);
     }
 
     CheckForNewDynamicFunctions();
     if (!changed_) {
       TraceConstFunctions();
     }
     CollectCallbackFields();
   }
 }
 
-
 void Precompiler::CollectCallbackFields() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Class& subcls = Class::Handle(Z);
   Array& fields = Array::Handle(Z);
   Field& field = Field::Handle(Z);
   Function& function = Function::Handle(Z);
   Function& dispatcher = Function::Handle(Z);
   Array& args_desc = Array::Handle(Z);
   AbstractType& field_type = AbstractType::Handle(Z);
@@ skipping 41 matching lines @@
               }
               AddFunction(dispatcher);
             }
           }
         }
       }
     }
   }
 }
 
-
 void Precompiler::ProcessFunction(const Function& function) {
   if (!function.HasCode()) {
     function_count_++;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Precompiling %" Pd " %s (%s, %s)\n", function_count_,
                 function.ToLibNamePrefixedQualifiedCString(),
                 function.token_pos().ToCString(),
                 Function::KindToCString(function.kind()));
     }
@@ skipping 15 matching lines @@
                 function.ToLibNamePrefixedQualifiedCString(),
                 function.token_pos().ToCString(),
                 Function::KindToCString(function.kind()));
     }
   }
 
   ASSERT(function.HasCode());
   AddCalleesOf(function);
 }
 
-
 void Precompiler::AddCalleesOf(const Function& function) {
   ASSERT(function.HasCode());
 
   const Code& code = Code::Handle(Z, function.CurrentCode());
 
   const Array& table = Array::Handle(Z, code.static_calls_target_table());
   Object& entry = Object::Handle(Z);
   Function& target = Function::Handle(Z);
   for (intptr_t i = 0; i < table.Length(); i++) {
     entry = table.At(i);
@@ skipping 71 matching lines @@
   }
 
   const Array& inlined_functions =
       Array::Handle(Z, code.inlined_id_to_function());
   for (intptr_t i = 0; i < inlined_functions.Length(); i++) {
     target ^= inlined_functions.At(i);
     AddTypesOf(target);
   }
 }
 
-
 void Precompiler::AddTypesOf(const Class& cls) {
   if (cls.IsNull()) return;
   if (classes_to_retain_.HasKey(&cls)) return;
   classes_to_retain_.Insert(&Class::ZoneHandle(Z, cls.raw()));
 
   Array& interfaces = Array::Handle(Z, cls.interfaces());
   AbstractType& type = AbstractType::Handle(Z);
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     type ^= interfaces.At(i);
     AddType(type);
   }
 
   AddTypeArguments(TypeArguments::Handle(Z, cls.type_parameters()));
 
   type = cls.super_type();
   AddType(type);
 
   type = cls.mixin();
   AddType(type);
 
   if (cls.IsTypedefClass()) {
     AddTypesOf(Function::Handle(Z, cls.signature_function()));
   }
 }
 
-
 void Precompiler::AddTypesOf(const Function& function) {
   if (function.IsNull()) return;
   if (functions_to_retain_.HasKey(&function)) return;
   // We don't expect to see a reference to a redirecting factory. Only its
   // target should remain.
   ASSERT(!function.IsRedirectingFactory());
   functions_to_retain_.Insert(&Function::ZoneHandle(Z, function.raw()));
 
   AbstractType& type = AbstractType::Handle(Z);
   type = function.result_type();
@@ skipping 29 matching lines @@
     type = function.ExistingSignatureType();
     if (!type.IsNull()) {
       AddType(type);
     }
   }
   // A class may have all functions inlined except a local function.
   const Class& owner = Class::Handle(Z, function.Owner());
   AddTypesOf(owner);
 }
 
-
 void Precompiler::AddType(const AbstractType& abstype) {
   if (abstype.IsNull()) return;
 
   if (types_to_retain_.HasKey(&abstype)) return;
   types_to_retain_.Insert(&AbstractType::ZoneHandle(Z, abstype.raw()));
 
   if (abstype.IsType()) {
     const Type& type = Type::Cast(abstype);
     const Class& cls = Class::Handle(Z, type.type_class());
     AddTypesOf(cls);
@@ skipping 16 matching lines @@
   } else if (abstype.IsTypeParameter()) {
     const AbstractType& type =
         AbstractType::Handle(Z, TypeParameter::Cast(abstype).bound());
     AddType(type);
     const Class& cls =
         Class::Handle(Z, TypeParameter::Cast(abstype).parameterized_class());
     AddTypesOf(cls);
   }
 }
 
-
 void Precompiler::AddTypeArguments(const TypeArguments& args) {
   if (args.IsNull()) return;
 
   if (typeargs_to_retain_.HasKey(&args)) return;
   typeargs_to_retain_.Insert(&TypeArguments::ZoneHandle(Z, args.raw()));
 
   AbstractType& arg = AbstractType::Handle(Z);
   for (intptr_t i = 0; i < args.Length(); i++) {
     arg = args.TypeAt(i);
     AddType(arg);
   }
 }
 
-
 void Precompiler::AddConstObject(const Instance& instance) {
   const Class& cls = Class::Handle(Z, instance.clazz());
   AddInstantiatedClass(cls);
 
   if (instance.IsClosure()) {
     // An implicit static closure.
     const Function& func =
         Function::Handle(Z, Closure::Cast(instance).function());
     ASSERT(func.is_static());
     AddFunction(func);
@@ skipping 39 matching lines @@
 
    private:
     Precompiler* precompiler_;
     Object& subinstance_;
   };
 
   ConstObjectVisitor visitor(this, I);
   instance.raw()->VisitPointers(&visitor);
 }
 
-
 void Precompiler::AddClosureCall(const Array& arguments_descriptor) {
   const Class& cache_class =
       Class::Handle(Z, I->object_store()->closure_class());
   const Function& dispatcher = Function::Handle(
       Z, cache_class.GetInvocationDispatcher(
              Symbols::Call(), arguments_descriptor,
              RawFunction::kInvokeFieldDispatcher, true /* create_if_absent */));
   AddFunction(dispatcher);
 }
 
-
 void Precompiler::AddField(const Field& field) {
   if (fields_to_retain_.HasKey(&field)) return;
 
   fields_to_retain_.Insert(&Field::ZoneHandle(Z, field.raw()));
 
   if (field.is_static()) {
     const Object& value = Object::Handle(Z, field.StaticValue());
     if (value.IsInstance()) {
       AddConstObject(Instance::Cast(value));
     }
@@ skipping 11 matching lines @@
         const Function& initializer = Function::Handle(
             Z, CompileStaticInitializer(field, /* compute_type = */ true));
         ASSERT(!initializer.IsNull());
         field.SetPrecompiledInitializer(initializer);
         AddCalleesOf(initializer);
       }
     }
   }
 }
 
-
 RawFunction* Precompiler::CompileStaticInitializer(const Field& field,
                                                    bool compute_type) {
   ASSERT(field.is_static());
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   Zone* zone = stack_zone.GetZone();
 
   ParsedFunction* parsed_function;
   // Check if this field is coming from the Kernel binary.
   if (field.kernel_offset() > 0) {
     parsed_function = kernel::ParseStaticFieldInitializer(zone, field);
   } else {
     parsed_function = Parser::ParseStaticFieldInitializer(field);
     parsed_function->AllocateVariables();
   }
 
-
   DartPrecompilationPipeline pipeline(zone);
   PrecompileParsedFunctionHelper helper(/* precompiler = */ NULL,
                                         parsed_function,
                                         /* optimized = */ true);
   bool success = helper.Compile(&pipeline);
   ASSERT(success);
 
   if (compute_type && field.is_final()) {
     intptr_t result_cid = pipeline.result_type().ToCid();
     if (result_cid != kDynamicCid) {
 #ifndef PRODUCT
       if (FLAG_trace_precompiler && FLAG_support_il_printer) {
         THR_Print("Setting guarded_cid of %s to %s\n", field.ToCString(),
                   pipeline.result_type().ToCString());
       }
 #endif  // !PRODUCT
       field.set_guarded_cid(result_cid);
     }
   }
 
   if ((FLAG_disassemble || FLAG_disassemble_optimized) &&
       FlowGraphPrinter::ShouldPrint(parsed_function->function())) {
     Code& code = Code::Handle(parsed_function->function().CurrentCode());
     Disassembler::DisassembleCode(parsed_function->function(), code,
                                   /* optimized = */ true);
   }
   return parsed_function->function().raw();
 }
 
-
 RawObject* Precompiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
   ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Under precompilation, the initializer may have already been compiled, in
     // which case use it. Under lazy compilation or early in precompilation, the
     // initializer has not yet been created, so create it now, but don't bother
@@ skipping 10 matching lines @@
     Thread* const thread = Thread::Current();
     StackZone zone(thread);
     const Error& error = Error::Handle(thread->zone(), thread->sticky_error());
     thread->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
-
 RawObject* Precompiler::ExecuteOnce(SequenceNode* fragment) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     if (FLAG_support_ast_printer && FLAG_trace_compiler) {
       THR_Print("compiling expression: ");
       AstPrinter ast_printer;
       ast_printer.PrintNode(fragment);
     }
 
@@ skipping 43 matching lines @@
   } else {
     Thread* const thread = Thread::Current();
     const Object& result = PassiveObject::Handle(thread->sticky_error());
     thread->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
-
 void Precompiler::AddFunction(const Function& function) {
   if (enqueued_functions_.HasKey(&function)) return;
 
   enqueued_functions_.Insert(&Function::ZoneHandle(Z, function.raw()));
   pending_functions_.Add(function);
   changed_ = true;
 }
 
-
 bool Precompiler::IsSent(const String& selector) {
   if (selector.IsNull()) {
     return false;
   }
   return sent_selectors_.HasKey(&selector);
 }
 
-
 void Precompiler::AddSelector(const String& selector) {
   ASSERT(!selector.IsNull());
 
   if (!IsSent(selector)) {
     sent_selectors_.Insert(&String::ZoneHandle(Z, selector.raw()));
     selector_count_++;
     changed_ = true;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Enqueueing selector %" Pd " %s\n", selector_count_,
                 selector.ToCString());
     }
   }
 }
 
-
 void Precompiler::AddInstantiatedClass(const Class& cls) {
   if (cls.is_allocated()) return;
 
   class_count_++;
   cls.set_is_allocated(true);
   error_ = cls.EnsureIsFinalized(T);
   if (!error_.IsNull()) {
     Jump(error_);
   }
 
   changed_ = true;
 
   if (FLAG_trace_precompiler) {
     THR_Print("Allocation %" Pd " %s\n", class_count_, cls.ToCString());
   }
 
   const Class& superclass = Class::Handle(cls.SuperClass());
   if (!superclass.IsNull()) {
     AddInstantiatedClass(superclass);
   }
 }
 
-
 void Precompiler::CheckForNewDynamicFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
   Function& function2 = Function::Handle(Z);
   String& selector = String::Handle(Z);
   String& selector2 = String::Handle(Z);
   String& selector3 = String::Handle(Z);
 
@@ skipping 81 matching lines @@
             // Add corresponding method extractor get:#foo
             function2 = function.GetMethodExtractor(selector2);
             AddFunction(function2);
           }
         }
       }
     }
   }
 }
 
-
 class NameFunctionsTraits {
  public:
   static const char* Name() { return "NameFunctionsTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     return a.IsString() && b.IsString() &&
            String::Cast(a).Equals(String::Cast(b));
   }
   static uword Hash(const Object& obj) { return String::Cast(obj).Hash(); }
   static RawObject* NewKey(const String& str) { return str.raw(); }
 };
 
 typedef UnorderedHashMap<NameFunctionsTraits> Table;
 
-
 static void AddNameToFunctionsTable(Zone* zone,
                                     Table* table,
                                     const String& fname,
                                     const Function& function) {
   Array& farray = Array::Handle(zone);
   farray ^= table->InsertNewOrGetValue(fname, Array::empty_array());
   farray = Array::Grow(farray, farray.Length() + 1);
   farray.SetAt(farray.Length() - 1, function);
   table->UpdateValue(fname, farray);
 }
 
-
 void Precompiler::CollectDynamicFunctionNames() {
   if (!FLAG_collect_dynamic_function_names) {
     return;
   }
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
   String& fname = String::Handle(Z);
   Array& farray = Array::Handle(Z);
@@ skipping 64 matching lines @@
     }
     THR_Print("%" Pd " of %" Pd " dynamic selectors are unique\n",
               functions_set.NumOccupied(), table.NumOccupied());
   }
 
   isolate()->object_store()->set_unique_dynamic_targets(
       functions_set.Release());
   table.Release();
 }
 
-
 void Precompiler::TraceConstFunctions() {
   // Compilation of const accessors happens outside of the treeshakers
   // queue, so we haven't previously scanned its literal pool.
 
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
 
       functions = cls.functions();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         function ^= functions.At(j);
         if (function.is_const() && function.HasCode()) {
           AddCalleesOf(function);
         }
       }
     }
   }
 }
 
-
 void Precompiler::TraceForRetainedFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
   Function& function2 = Function::Handle(Z);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
@@ skipping 39 matching lines @@
       // parents and their enclosing classes and libraries.
       function = function.parent_function();
       while (!function.IsNull()) {
         AddTypesOf(function);
         function = function.parent_function();
       }
     }
   }
 }
 
-
 void Precompiler::DropFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
   GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
@@ skipping 41 matching lines @@
       dropped_function_count_++;
       if (FLAG_trace_precompiler) {
         THR_Print("Dropping function %s\n",
                   function.ToLibNamePrefixedQualifiedCString());
       }
     }
   }
   isolate()->object_store()->set_closure_functions(retained_functions);
 }
 
-
 void Precompiler::DropFields() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& fields = Array::Handle(Z);
   Field& field = Field::Handle(Z);
   GrowableObjectArray& retained_fields = GrowableObjectArray::Handle(Z);
   AbstractType& type = AbstractType::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
@@ skipping 24 matching lines @@
       if (retained_fields.Length() > 0) {
         fields = Array::MakeFixedLength(retained_fields);
         cls.SetFields(fields);
       } else {
         cls.SetFields(Object::empty_array());
       }
     }
   }
 }
 
-
 void Precompiler::DropTypes() {
   ObjectStore* object_store = I->object_store();
   GrowableObjectArray& retained_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   Array& types_array = Array::Handle(Z);
   Type& type = Type::Handle(Z);
   // First drop all the types that are not referenced.
   {
     CanonicalTypeSet types_table(Z, object_store->canonical_types());
     types_array = HashTables::ToArray(types_table, false);
@@ skipping 16 matching lines @@
   CanonicalTypeSet types_table(Z, types_array.raw());
   bool present;
   for (intptr_t i = 0; i < retained_types.Length(); i++) {
     type ^= retained_types.At(i);
     present = types_table.Insert(type);
     ASSERT(!present);
   }
   object_store->set_canonical_types(types_table.Release());
 }
 
-
 void Precompiler::DropTypeArguments() {
   ObjectStore* object_store = I->object_store();
   Array& typeargs_array = Array::Handle(Z);
   GrowableObjectArray& retained_typeargs =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   TypeArguments& typeargs = TypeArguments::Handle(Z);
   // First drop all the type arguments that are not referenced.
   {
     CanonicalTypeArgumentsSet typeargs_table(
         Z, object_store->canonical_type_arguments());
@@ skipping 18 matching lines @@
   CanonicalTypeArgumentsSet typeargs_table(Z, typeargs_array.raw());
   bool present;
   for (intptr_t i = 0; i < retained_typeargs.Length(); i++) {
     typeargs ^= retained_typeargs.At(i);
     present = typeargs_table.Insert(typeargs);
     ASSERT(!present);
   }
   object_store->set_canonical_type_arguments(typeargs_table.Release());
 }
 
-
 void Precompiler::DropScriptData() {
   Library& lib = Library::Handle(Z);
   Array& scripts = Array::Handle(Z);
   Script& script = Script::Handle(Z);
   const TokenStream& null_tokens = TokenStream::Handle(Z);
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     scripts = lib.LoadedScripts();
     for (intptr_t j = 0; j < scripts.Length(); j++) {
       script ^= scripts.At(j);
       script.set_compile_time_constants(Array::null_array());
       script.set_source(String::null_string());
       script.set_tokens(null_tokens);
     }
   }
 }
 
-
 void Precompiler::TraceTypesFromRetainedClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& members = Array::Handle(Z);
   Array& constants = Array::Handle(Z);
   GrowableObjectArray& retained_constants = GrowableObjectArray::Handle(Z);
   Instance& constant = Instance::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
@@ skipping 53 matching lines @@
         retain = true;
       }
 
       if (retain) {
         AddTypesOf(cls);
       }
     }
   }
 }
 
-
 void Precompiler::DropLibraryEntries() {
   Library& lib = Library::Handle(Z);
   Array& dict = Array::Handle(Z);
   Object& entry = Object::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
 
     dict = lib.dictionary();
     intptr_t dict_size = dict.Length() - 1;
@@ skipping 25 matching lines @@
       dict.SetAt(j, Object::null_object());
     }
     lib.RehashDictionary(dict, used * 4 / 3 + 1);
     if (!(retain_root_library_caches_ &&
           (lib.raw() == I->object_store()->root_library()))) {
       lib.DropDependenciesAndCaches();
     }
   }
 }
 
-
 void Precompiler::DropClasses() {
   Class& cls = Class::Handle(Z);
   Array& constants = Array::Handle(Z);
 
 #if defined(DEBUG)
   // We are about to remove classes from the class table. For this to be safe,
   // there must be no instances of these classes on the heap, not even
   // corpses because the class table entry may be used to find the size of
   // corpses. Request a full GC and wait for the sweeper tasks to finish before
   // we continue.
@@ skipping 42 matching lines @@
       THR_Print("Dropping class %" Pd " %s\n", cid, cls.ToCString());
     }
 
 #if defined(DEBUG)
     class_table->Unregister(cid);
 #endif
     cls.set_id(kIllegalCid);  // We check this when serializing.
   }
 }
 
-
 void Precompiler::DropLibraries() {
   const GrowableObjectArray& retained_libraries =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   const Library& root_lib =
       Library::Handle(Z, I->object_store()->root_library());
   Library& lib = Library::Handle(Z);
   Class& toplevel_class = Class::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
@@ skipping 38 matching lines @@
       if (FLAG_trace_precompiler) {
         THR_Print("Dropping library %s\n", lib.ToCString());
       }
     }
   }
 
   Library::RegisterLibraries(T, retained_libraries);
   libraries_ = retained_libraries.raw();
 }
 
-
 void Precompiler::BindStaticCalls() {
   class BindStaticCallsVisitor : public FunctionVisitor {
    public:
     explicit BindStaticCallsVisitor(Zone* zone)
         : code_(Code::Handle(zone)),
           table_(Array::Handle(zone)),
           pc_offset_(Smi::Handle(zone)),
           target_(Function::Handle(zone)),
           target_code_(Code::Handle(zone)) {}
 
@@ skipping 36 matching lines @@
     Array& table_;
     Smi& pc_offset_;
     Function& target_;
     Code& target_code_;
   };
 
   BindStaticCallsVisitor visitor(Z);
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
-
 void Precompiler::SwitchICCalls() {
 #if !defined(TARGET_ARCH_DBC)
   // Now that all functions have been compiled, we can switch to an instance
   // call sequence that loads the Code object and entry point directly from
   // the ic data array instead indirectly through a Function in the ic data
   // array. Iterate all the object pools and rewrite the ic data from
   // (cid, target function, count) to (cid, target code, entry point), and
   // replace the ICCallThroughFunction stub with ICCallThroughCode.
 
   class SwitchICCallsVisitor : public FunctionVisitor {
@@ skipping 69 matching lines @@
     Code& target_code_;
     UnlinkedCallSet canonical_unlinked_calls_;
   };
 
   ASSERT(!I->compilation_allowed());
   SwitchICCallsVisitor visitor(Z);
   ProgramVisitor::VisitFunctions(&visitor);
 #endif
 }
 
-
 void Precompiler::FinalizeAllClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     if (!lib.Loaded()) {
       String& uri = String::Handle(Z, lib.url());
       String& msg = String::Handle(
           Z,
@@ skipping 11 matching lines @@
       }
       error_ = cls.EnsureIsFinalized(T);
       if (!error_.IsNull()) {
         Jump(error_);
       }
     }
   }
   I->set_all_classes_finalized(true);
 }
 
-
-
 void Precompiler::VerifyJITFeedback() {
   if (jit_feedback_ == NULL) return;
 
   ParsedJSONString* js_vmversion = jit_feedback_->StringAt("vmVersion");
   if ((js_vmversion == NULL) ||
       strcmp(js_vmversion->value(), Version::CommitString()) != 0) {
     THR_Print(
         "JIT feedback contains invalid vm version "
         "(saw %s, expected %s).\n",
         js_vmversion->value(), Version::CommitString());
@@ skipping 110 matching lines @@
     }
 
    private:
     Precompiler* precompiler_;
   };
 
   ApplyUsageVisitor visitor(this);
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
-
 ParsedJSONObject* Precompiler::LookupFeedback(const Function& function) {
   const Class& owner = Class::Handle(Z, function.Owner());
 
   FunctionFeedbackKey key(owner.id(), function.token_pos().value(),
                           function.kind());
   FunctionFeedbackPair* pair = function_feedback_map_.Lookup(key);
   if (pair == NULL) {
     return NULL;
   }
   return pair->value_;
 }
 
-
 RawScript* Precompiler::LookupScript(const char* uri) {
   String& dart_uri = String::Handle(Z, String::New(uri));
   Library& lib = Library::Handle(Z);
   Script& script = Script::Handle(Z);
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     script = lib.LookupScript(dart_uri);
     if (!script.IsNull()) {
       return script.raw();
     }
   }
   return Script::null();
 }
 
-
 intptr_t Precompiler::MapCid(intptr_t feedback_cid) {
   if (feedback_cid < kNumPredefinedCids) {
     return feedback_cid;
   }
   IntptrPair* pair = feedback_cid_map_.Lookup(feedback_cid);
   if (pair == NULL) return kIllegalCid;
   return pair->value_;
 }
 
-
 void Precompiler::PopulateWithICData(const Function& function,
                                      FlowGraph* graph) {
   Zone* zone = Thread::Current()->zone();
 
   for (BlockIterator block_it = graph->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     ForwardInstructionIterator it(block_it.Current());
     for (; !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (instr->IsInstanceCall()) {
@@ skipping 30 matching lines @@
                                 arguments_descriptor, call->deopt_id(),
                                 num_args_checked, true));
           ic_data.AddTarget(target);
           call->set_ic_data(&ic_data);
         }
       }
     }
   }
 }
 
-
 void Precompiler::TryApplyFeedback(const Function& function, FlowGraph* graph) {
   ParsedJSONObject* js_function = LookupFeedback(function);
   if (js_function == NULL) {
     if (FLAG_trace_precompiler) {
       THR_Print("No feedback available for %s\n",
                 function.ToQualifiedCString());
     }
     return;
   }
 
   ParsedJSONArray* js_icdatas = js_function->ArrayAt("ics");
   ASSERT(js_icdatas != NULL);
 
   for (BlockIterator block_it = graph->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     ForwardInstructionIterator it(block_it.Current());
     for (; !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (instr->IsInstanceCall()) {
         InstanceCallInstr* call = instr->AsInstanceCall();
         TryApplyFeedback(js_icdatas, *call->ic_data());
       } else if (instr->IsStaticCall()) {
         StaticCallInstr* call = instr->AsStaticCall();
         TryApplyFeedback(js_icdatas, *call->ic_data());
       }
     }
   }
 }
 
-
 void Precompiler::TryApplyFeedback(ParsedJSONArray* js_icdatas,
                                    const ICData& ic) {
   for (intptr_t j = 0; j < js_icdatas->Length(); j++) {
     ParsedJSONObject* js_icdata = js_icdatas->ObjectAt(j);
     ASSERT(js_icdata != NULL);
 
     ParsedJSONNumber* js_deoptid = js_icdata->NumberAt("deoptId");
     ASSERT(js_deoptid != NULL);
     if (js_deoptid->value() != ic.deopt_id()) continue;
 
@@ skipping 63 matching lines @@
             }
           }
         }
       }
     }
 
     return;
   }
 }
 
-
 void Precompiler::ResetPrecompilerState() {
   changed_ = false;
   function_count_ = 0;
   class_count_ = 0;
   selector_count_ = 0;
   dropped_function_count_ = 0;
   dropped_field_count_ = 0;
   ASSERT(pending_functions_.Length() == 0);
   sent_selectors_.Clear();
   enqueued_functions_.Clear();
@@ skipping 14 matching lines @@
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
       cls.set_is_allocated(false);
     }
   }
 }
 
-
 void PrecompileParsedFunctionHelper::FinalizeCompilation(
     Assembler* assembler,
     FlowGraphCompiler* graph_compiler,
     FlowGraph* flow_graph) {
   const Function& function = parsed_function()->function();
   Zone* const zone = thread()->zone();
 
   CSTAT_TIMER_SCOPE(thread(), codefinalizer_timer);
   // CreateDeoptInfo uses the object pool and needs to be done before
   // FinalizeCode.
@@ skipping 28 matching lines @@
     ASSERT(thread()->IsMutatorThread());
     function.InstallOptimizedCode(code);
   } else {  // not optimized.
     function.set_unoptimized_code(code);
     function.AttachCode(code);
   }
   ASSERT(!parsed_function()->HasDeferredPrefixes());
   ASSERT(FLAG_load_deferred_eagerly);
 }
 
-
 // Return false if bailed out.
 // If optimized_result_code is not NULL then it is caller's responsibility
 // to install code.
 bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
   ASSERT(FLAG_precompiled_mode);
   const Function& function = parsed_function()->function();
   if (optimized() && !function.IsOptimizable()) {
     // All functions compiled by precompiler must be optimizable.
     UNREACHABLE();
     return false;
@@ skipping 490 matching lines @@
         thread()->clear_sticky_error();
       }
       is_compiled = false;
     }
     // Reset global isolate state.
     thread()->set_deopt_id(prev_deopt_id);
   }
   return is_compiled;
 }
 
-
 static RawError* PrecompileFunctionHelper(Precompiler* precompiler,
                                           CompilationPipeline* pipeline,
                                           const Function& function,
                                           bool optimized) {
   // Check that we optimize, except if the function is not optimizable.
   ASSERT(FLAG_precompiled_mode);
   ASSERT(!function.IsOptimizable() || optimized);
   ASSERT(!function.HasCode());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
@@ skipping 68 matching lines @@
     thread->clear_sticky_error();
     // Precompilation may encounter compile-time errors.
     // Do not attempt to optimize functions that can cause errors.
     function.set_is_optimizable(false);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
-
 RawError* Precompiler::CompileFunction(Precompiler* precompiler,
                                        Thread* thread,
                                        Zone* zone,
                                        const Function& function,
                                        FieldTypeMap* field_type_map) {
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "CompileFunction", function);
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart