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

runtime/vm/compiler.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 90 matching lines @@
 DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from ssa compiler.");
 DEFINE_FLAG(bool, use_inlining, true, "Enable call-site inlining");
 DEFINE_FLAG(bool,
             verify_compiler,
             false,
             "Enable compiler verification assertions");
 
 DECLARE_FLAG(bool, huge_method_cutoff_in_code_size);
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
 
-
 #ifndef DART_PRECOMPILED_RUNTIME
 
-
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {
   const Function& function = parsed_function->function();
   return (function.kernel_offset() > 0) ||
          (function.kind() == RawFunction::kNoSuchMethodDispatcher) ||
          (function.kind() == RawFunction::kInvokeFieldDispatcher);
 }
 
-
 void DartCompilationPipeline::ParseFunction(ParsedFunction* parsed_function) {
   if (!UseKernelFrontEndFor(parsed_function)) {
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
   }
 }
 
-
 FlowGraph* DartCompilationPipeline::BuildFlowGraph(
     Zone* zone,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     intptr_t osr_id) {
   if (UseKernelFrontEndFor(parsed_function)) {
     kernel::FlowGraphBuilder builder(
         parsed_function->function().kernel_offset(), parsed_function,
         ic_data_array,
         /* not building var desc */ NULL,
         /* not inlining */ NULL, osr_id);
     FlowGraph* graph = builder.BuildGraph();
     ASSERT(graph != NULL);
     return graph;
   }
   FlowGraphBuilder builder(*parsed_function, ic_data_array,
                            /* not building var desc */ NULL,
                            /* not inlining */ NULL, osr_id);
 
   return builder.BuildGraph();
 }
 
-
 void DartCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) {}
 
-
 void IrregexpCompilationPipeline::ParseFunction(
     ParsedFunction* parsed_function) {
   VMTagScope tagScope(parsed_function->thread(),
                       VMTag::kCompileParseRegExpTagId);
   Zone* zone = parsed_function->zone();
   RegExp& regexp = RegExp::Handle(parsed_function->function().regexp());
 
   const String& pattern = String::Handle(regexp.pattern());
   const bool multiline = regexp.is_multi_line();
 
   RegExpCompileData* compile_data = new (zone) RegExpCompileData();
   if (!RegExpParser::ParseRegExp(pattern, multiline, compile_data)) {
     // Parsing failures are handled in the RegExp factory constructor.
     UNREACHABLE();
   }
 
   regexp.set_num_bracket_expressions(compile_data->capture_count);
   if (compile_data->simple) {
     regexp.set_is_simple();
   } else {
     regexp.set_is_complex();
   }
 
   parsed_function->SetRegExpCompileData(compile_data);
 
   // Variables are allocated after compilation.
 }
 
-
 FlowGraph* IrregexpCompilationPipeline::BuildFlowGraph(
     Zone* zone,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     intptr_t osr_id) {
   // Compile to the dart IR.
   RegExpEngine::CompilationResult result =
       RegExpEngine::CompileIR(parsed_function->regexp_compile_data(),
                               parsed_function, ic_data_array, osr_id);
   backtrack_goto_ = result.backtrack_goto;
 
   // Allocate variables now that we know the number of locals.
   parsed_function->AllocateIrregexpVariables(result.num_stack_locals);
 
   // When compiling for OSR, use a depth first search to find the OSR
   // entry and make graph entry jump to it instead of normal entry.
   // Catch entries are always considered reachable, even if they
   // become unreachable after OSR.
   if (osr_id != Compiler::kNoOSRDeoptId) {
     result.graph_entry->RelinkToOsrEntry(zone, result.num_blocks);
   }
 
   return new (zone)
       FlowGraph(*parsed_function, result.graph_entry, result.num_blocks);
 }
 
-
 void IrregexpCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) {
   backtrack_goto_->ComputeOffsetTable();
 }
 
-
 CompilationPipeline* CompilationPipeline::New(Zone* zone,
                                               const Function& function) {
   if (function.IsIrregexpFunction()) {
     return new (zone) IrregexpCompilationPipeline();
   } else {
     return new (zone) DartCompilationPipeline();
   }
 }
 
-
 // Compile a function. Should call only if the function has not been compiled.
 //   Arg0: function object.
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(!function.HasCode());
   const Object& result =
       Object::Handle(Compiler::CompileFunction(thread, function));
   if (result.IsError()) {
     if (result.IsLanguageError()) {
       Exceptions::ThrowCompileTimeError(LanguageError::Cast(result));
       UNREACHABLE();
     }
     Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
-
 bool Compiler::CanOptimizeFunction(Thread* thread, const Function& function) {
   if (FLAG_support_debugger) {
     Isolate* isolate = thread->isolate();
     if (isolate->debugger()->IsStepping() ||
         isolate->debugger()->HasBreakpoint(function, thread->zone())) {
       // We cannot set breakpoints and single step in optimized code,
       // so do not optimize the function.
       function.set_usage_counter(0);
       return false;
     }
@@ skipping 42 matching lines @@
     // non-optimizable only after the code has been generated.
     if (FLAG_trace_failed_optimization_attempts) {
       THR_Print("Not optimizable: %s\n", function.ToFullyQualifiedCString());
     }
     function.set_usage_counter(INT_MIN);
     return false;
   }
   return true;
 }
 
-
 bool Compiler::IsBackgroundCompilation() {
   // For now: compilation in non mutator thread is the background compoilation.
   return !Thread::Current()->IsMutatorThread();
 }
 
-
 RawError* Compiler::Compile(const Library& library, const Script& script) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     StackZone zone(thread);
     if (FLAG_trace_compiler) {
       const String& script_url = String::Handle(script.url());
       // TODO(iposva): Extract script kind.
       THR_Print("Compiling %s '%s'\n", "", script_url.ToCString());
     }
     const String& library_key = String::Handle(library.private_key());
     script.Tokenize(library_key);
     Parser::ParseCompilationUnit(library, script);
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     StackZone zone(thread);
     Error& error = Error::Handle();
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
-
 static void AddRelatedClassesToList(
     const Class& cls,
     GrowableHandlePtrArray<const Class>* parse_list,
     GrowableHandlePtrArray<const Class>* patch_list) {
   Zone* zone = Thread::Current()->zone();
   Class& parse_class = Class::Handle(zone);
   AbstractType& interface_type = Type::Handle(zone);
   Array& interfaces = Array::Handle(zone);
 
   // Add all the interfaces implemented by the class that have not been
@@ skipping 26 matching lines @@
   // recursively add it back into the list.
   parse_class ^= cls.GetPatchClass();
   if (!parse_class.IsNull()) {
     if (!parse_class.is_finalized() && !parse_class.is_marked_for_parsing()) {
       patch_list->Add(parse_class);
       parse_class.set_is_marked_for_parsing();
     }
   }
 }
 
-
 RawError* Compiler::CompileClass(const Class& cls) {
   ASSERT(Thread::Current()->IsMutatorThread());
   // If class is a top level class it is already parsed.
   if (cls.IsTopLevel()) {
     return Error::null();
   }
   // If the class is already marked for parsing return immediately.
   if (cls.is_marked_for_parsing()) {
     return Error::null();
   }
@@ skipping 105 matching lines @@
     Thread* thread = Thread::Current();
     Error& error = Error::Handle(thread->zone());
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
-
 class CompileParsedFunctionHelper : public ValueObject {
  public:
   CompileParsedFunctionHelper(ParsedFunction* parsed_function,
                               bool optimized,
                               intptr_t osr_id)
       : parsed_function_(parsed_function),
         optimized_(optimized),
         osr_id_(osr_id),
         thread_(Thread::Current()),
         loading_invalidation_gen_at_start_(
@@ skipping 17 matching lines @@
 
   ParsedFunction* parsed_function_;
   const bool optimized_;
   const intptr_t osr_id_;
   Thread* const thread_;
   const intptr_t loading_invalidation_gen_at_start_;
 
   DISALLOW_COPY_AND_ASSIGN(CompileParsedFunctionHelper);
 };
 
-
 RawCode* CompileParsedFunctionHelper::FinalizeCompilation(
     Assembler* assembler,
     FlowGraphCompiler* graph_compiler,
     FlowGraph* flow_graph) {
   ASSERT(!FLAG_precompiled_mode);
   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
@@ skipping 145 matching lines @@
     ASSERT(!FLAG_load_deferred_eagerly);
     ZoneGrowableArray<const LibraryPrefix*>* prefixes =
         parsed_function()->deferred_prefixes();
     for (intptr_t i = 0; i < prefixes->length(); i++) {
       (*prefixes)[i]->RegisterDependentCode(code);
     }
   }
   return code.raw();
 }
 
-
 void CompileParsedFunctionHelper::CheckIfBackgroundCompilerIsBeingStopped() {
   ASSERT(Compiler::IsBackgroundCompilation());
   if (!isolate()->background_compiler()->is_running()) {
     // The background compiler is being stopped.
     Compiler::AbortBackgroundCompilation(
         Thread::kNoDeoptId, "Background compilation is being stopped");
   }
 }
 
-
 // Return null if bailed out.
 // If optimized_result_code is not NULL then it is caller's responsibility
 // to install code.
 RawCode* CompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
   ASSERT(!FLAG_precompiled_mode);
   const Function& function = parsed_function()->function();
   if (optimized() && !function.IsOptimizable()) {
     return Code::null();
   }
   Zone* const zone = thread()->zone();
@@ skipping 495 matching lines @@
           (LanguageError::Cast(error).kind() == Report::kBailout)) {
         thread()->clear_sticky_error();
       }
     }
     // Reset global isolate state.
     thread()->set_deopt_id(prev_deopt_id);
   }
   return result->raw();
 }
 
-
 static RawObject* CompileFunctionHelper(CompilationPipeline* pipeline,
                                         const Function& function,
                                         bool optimized,
                                         intptr_t osr_id) {
   ASSERT(!FLAG_precompiled_mode);
   ASSERT(!optimized || function.was_compiled());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
@@ skipping 145 matching lines @@
       return Object::null();
     }
     // Do not attempt to optimize functions that can cause errors.
     function.set_is_optimizable(false);
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
-
 static RawError* ParseFunctionHelper(CompilationPipeline* pipeline,
                                      const Function& function,
                                      bool optimized,
                                      intptr_t osr_id) {
   ASSERT(!FLAG_precompiled_mode);
   ASSERT(!optimized || function.was_compiled());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     StackZone stack_zone(thread);
@@ skipping 36 matching lines @@
     thread->clear_sticky_error();
     // Unoptimized compilation or precompilation may encounter compile-time
     // errors, but regular optimized compilation should not.
     ASSERT(!optimized);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
-
 RawObject* Compiler::CompileFunction(Thread* thread, const Function& function) {
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::CompileFunction(
         /* precompiler = */ NULL, thread, thread->zone(), function);
   }
 #endif
 
   Isolate* isolate = thread->isolate();
 
 #if !defined(PRODUCT)
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "CompileFunction", function);
 #endif  // !defined(PRODUCT)
 
   if (!isolate->compilation_allowed()) {
     FATAL3("Precompilation missed function %s (%s, %s)\n",
            function.ToLibNamePrefixedQualifiedCString(),
            function.token_pos().ToCString(),
            Function::KindToCString(function.kind()));
   }
 
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
 
   return CompileFunctionHelper(pipeline, function,
                                /* optimized = */ false, kNoOSRDeoptId);
 }
 
-
 RawError* Compiler::ParseFunction(Thread* thread, const Function& function) {
   Isolate* isolate = thread->isolate();
 #if !defined(PRODUCT)
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "ParseFunction", function);
 #endif  // !defined(PRODUCT)
 
   if (!isolate->compilation_allowed()) {
     FATAL3("Precompilation missed function %s (%s, %s)\n",
            function.ToLibNamePrefixedQualifiedCString(),
            function.token_pos().ToCString(),
            Function::KindToCString(function.kind()));
   }
 
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
 
   return ParseFunctionHelper(pipeline, function,
                              /* optimized = */ false, kNoOSRDeoptId);
 }
 
-
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                           const Function& function) {
   if (function.unoptimized_code() != Object::null()) {
     return Error::null();
   }
   Code& original_code = Code::ZoneHandle(thread->zone());
   if (function.HasCode()) {
     original_code = function.CurrentCode();
   }
   CompilationPipeline* pipeline =
@@ skipping 11 matching lines @@
     function.AttachCode(original_code);
   }
   ASSERT(function.unoptimized_code() != Object::null());
   ASSERT(function.unoptimized_code() == result.raw());
   if (FLAG_trace_compiler) {
     THR_Print("Ensure unoptimized code for %s\n", function.ToCString());
   }
   return Error::null();
 }
 
-
 RawObject* Compiler::CompileOptimizedFunction(Thread* thread,
                                               const Function& function,
                                               intptr_t osr_id) {
 #if !defined(PRODUCT)
   VMTagScope tagScope(thread, VMTag::kCompileOptimizedTagId);
   const char* event_name;
   if (osr_id != kNoOSRDeoptId) {
     event_name = "CompileFunctionOptimizedOSR";
   } else if (IsBackgroundCompilation()) {
     event_name = "CompileFunctionOptimizedBackground";
   } else {
     event_name = "CompileFunctionOptimized";
   }
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, event_name, function);
 #endif  // !defined(PRODUCT)
 
   // If we are in the optimizing in the mutator/Dart thread, then
   // this is either an OSR compilation or background compilation is
   // not currently allowed.
   ASSERT(!thread->IsMutatorThread() || (osr_id != kNoOSRDeoptId) ||
          !FLAG_background_compilation || BackgroundCompiler::IsDisabled());
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
   return CompileFunctionHelper(pipeline, function, true, /* optimized */
                                osr_id);
 }
 
-
 // This is only used from unit tests.
 RawError* Compiler::CompileParsedFunction(ParsedFunction* parsed_function) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Non-optimized code generator.
     DartCompilationPipeline pipeline;
     CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
     helper.Compile(&pipeline);
     if (FLAG_disassemble) {
       Code& code = Code::Handle(parsed_function->function().CurrentCode());
       Disassembler::DisassembleCode(parsed_function->function(), code, false);
     }
     return Error::null();
   } else {
     Error& error = Error::Handle();
     Thread* thread = Thread::Current();
     // We got an error during compilation.
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
-
 void Compiler::ComputeLocalVarDescriptors(const Code& code) {
   ASSERT(!code.is_optimized());
   const Function& function = Function::Handle(code.function());
   ParsedFunction* parsed_function = new ParsedFunction(
       Thread::Current(), Function::ZoneHandle(function.raw()));
   ASSERT(code.var_descriptors() == Object::null());
   // IsIrregexpFunction have eager var descriptors generation.
   ASSERT(!function.IsIrregexpFunction());
   // In background compilation, parser can produce 'errors": bailouts
   // if state changed while compiling in background.
@@ skipping 27 matching lines @@
             function, context_level_array));
     ASSERT(!var_descs.IsNull());
     code.set_var_descriptors(var_descs);
   } else {
     // Only possible with background compilation.
     ASSERT(Compiler::IsBackgroundCompilation());
   }
   Thread::Current()->set_deopt_id(prev_deopt_id);
 }
 
-
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Object& result = Object::Handle(zone);
   Array& functions = Array::Handle(zone, cls.functions());
   Function& func = Function::Handle(zone);
   // Class dynamic lives in the vm isolate. Its array fields cannot be set to
   // an empty array.
   if (functions.IsNull()) {
     ASSERT(cls.IsDynamicClass());
@@ skipping 15 matching lines @@
         return Error::Cast(result).raw();
       }
       ASSERT(!result.IsNull());
       func.ClearICDataArray();
       func.ClearCode();
     }
   }
   return Error::null();
 }
 
-
 RawError* Compiler::ParseAllFunctions(const Class& cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Error& error = Error::Handle(zone);
   Array& functions = Array::Handle(zone, cls.functions());
   Function& func = Function::Handle(zone);
   // Class dynamic lives in the vm isolate. Its array fields cannot be set to
   // an empty array.
   if (functions.IsNull()) {
     ASSERT(cls.IsDynamicClass());
@@ skipping 13 matching lines @@
       if (!error.IsNull()) {
         return error.raw();
       }
       func.ClearICDataArray();
       func.ClearCode();
     }
   }
   return error.raw();
 }
 
-
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::EvaluateStaticInitializer(field);
   }
 #endif
   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());
@@ skipping 42 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();
 }
 
-
 RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::ExecuteOnce(fragment);
   }
 #endif
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
 
@@ skipping 54 matching lines @@
       return result.raw();
     }
   }
 
   Thread* const thread = Thread::Current();
   const Object& result = PassiveObject::Handle(thread->sticky_error());
   thread->clear_sticky_error();
   return result.raw();
 }
 
-
 void Compiler::AbortBackgroundCompilation(intptr_t deopt_id, const char* msg) {
   if (FLAG_trace_compiler) {
     THR_Print("ABORT background compilation: %s\n", msg);
   }
 #if !defined(PRODUCT)
   TimelineStream* stream = Timeline::GetCompilerStream();
   ASSERT(stream != NULL);
   TimelineEvent* event = stream->StartEvent();
   if (event != NULL) {
     event->Instant("AbortBackgroundCompilation");
     event->SetNumArguments(1);
     event->CopyArgument(0, "reason", msg);
     event->Complete();
   }
 #endif  // !defined(PRODUCT)
   ASSERT(Compiler::IsBackgroundCompilation());
   Thread::Current()->long_jump_base()->Jump(
       deopt_id, Object::background_compilation_error());
 }
 
-
 // C-heap allocated background compilation queue element.
 class QueueElement {
  public:
   explicit QueueElement(const Function& function)
       : next_(NULL), function_(function.raw()) {}
 
   virtual ~QueueElement() {
     next_ = NULL;
     function_ = Function::null();
   }
 
   RawFunction* Function() const { return function_; }
 
-
   void set_next(QueueElement* elem) { next_ = elem; }
   QueueElement* next() const { return next_; }
 
   RawObject* function() const { return function_; }
   RawObject** function_ptr() {
     return reinterpret_cast<RawObject**>(&function_);
   }
 
  private:
   QueueElement* next_;
   RawFunction* function_;
 
   DISALLOW_COPY_AND_ASSIGN(QueueElement);
 };
 
-
 // Allocated in C-heap. Handles both input and output of background compilation.
 // It implements a FIFO queue, using Peek, Add, Remove operations.
 class BackgroundCompilationQueue {
  public:
   BackgroundCompilationQueue() : first_(NULL), last_(NULL) {}
   virtual ~BackgroundCompilationQueue() { Clear(); }
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     ASSERT(visitor != NULL);
     QueueElement* p = first_;
@@ skipping 59 matching lines @@
     ASSERT((first_ == NULL) && (last_ == NULL));
   }
 
  private:
   QueueElement* first_;
   QueueElement* last_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundCompilationQueue);
 };
 
-
 BackgroundCompiler::BackgroundCompiler(Isolate* isolate)
     : isolate_(isolate),
       running_(true),
       done_(new bool()),
       queue_monitor_(new Monitor()),
       done_monitor_(new Monitor()),
       function_queue_(new BackgroundCompilationQueue()) {
   *done_ = false;
 }
 
-
 // Fields all deleted in ::Stop; here clear them.
 BackgroundCompiler::~BackgroundCompiler() {
   isolate_ = NULL;
   running_ = false;
   done_ = NULL;
   queue_monitor_ = NULL;
   done_monitor_ = NULL;
   function_queue_ = NULL;
 }
 
-
 void BackgroundCompiler::Run() {
   while (running_) {
     // Maybe something is already in the queue, check first before waiting
     // to be notified.
     bool result = Thread::EnterIsolateAsHelper(isolate_, Thread::kCompilerTask);
     ASSERT(result);
     {
       Thread* thread = Thread::Current();
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
@@ skipping 50 matching lines @@
   }  // while running
 
   {
     // Notify that the thread is done.
     MonitorLocker ml_done(done_monitor_);
     *done_ = true;
     ml_done.Notify();
   }
 }
 
-
 void BackgroundCompiler::CompileOptimized(const Function& function) {
   ASSERT(Thread::Current()->IsMutatorThread());
   // TODO(srdjan): Checking different strategy for collecting garbage
   // accumulated by background compiler.
   if (isolate_->heap()->NeedsGarbageCollection()) {
     isolate_->heap()->CollectAllGarbage();
   }
   {
     MonitorLocker ml(queue_monitor_);
     ASSERT(running_);
     if (function_queue()->ContainsObj(function)) {
       return;
     }
     QueueElement* elem = new QueueElement(function);
     function_queue()->Add(elem);
     ml.Notify();
   }
 }
 
-
 void BackgroundCompiler::VisitPointers(ObjectPointerVisitor* visitor) {
   function_queue_->VisitObjectPointers(visitor);
 }
 
-
 void BackgroundCompiler::Stop(Isolate* isolate) {
   BackgroundCompiler* task = isolate->background_compiler();
   if (task == NULL) {
     // Nothing to stop.
     return;
   }
   BackgroundCompilationQueue* function_queue = task->function_queue();
 
   Monitor* queue_monitor = task->queue_monitor_;
   Monitor* done_monitor = task->done_monitor_;
@@ skipping 14 matching lines @@
       ml_done.WaitWithSafepointCheck(Thread::Current());
     }
   }
   delete task_done;
   delete done_monitor;
   delete queue_monitor;
   delete function_queue;
   isolate->set_background_compiler(NULL);
 }
 
-
 void BackgroundCompiler::Disable() {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   MutexLocker ml(isolate->mutex());
   BackgroundCompiler* task = isolate->background_compiler();
   if (task != NULL) {
     // We should only ever have to stop the task if this is the first call to
     // Disable.
     ASSERT(!isolate->is_background_compiler_disabled());
     BackgroundCompiler::Stop(isolate);
   }
   ASSERT(isolate->background_compiler() == NULL);
   isolate->disable_background_compiler();
 }
 
-
 bool BackgroundCompiler::IsDisabled() {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   MutexLocker ml(isolate->mutex());
   return isolate->is_background_compiler_disabled();
 }
 
-
 void BackgroundCompiler::Enable() {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   MutexLocker ml(isolate->mutex());
   isolate->enable_background_compiler();
 }
 
-
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   ASSERT(thread->IsMutatorThread());
   // Finalize NoSuchMethodError, _Mint; occasionally needed in optimized
   // compilation.
   Class& cls = Class::Handle(
       thread->zone(), Library::LookupCoreClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   Error& error = Error::Handle(thread->zone(), cls.EnsureIsFinalized(thread));
   ASSERT(error.IsNull());
   cls = Library::LookupCoreClass(Symbols::_Mint());
   ASSERT(!cls.IsNull());
   error = cls.EnsureIsFinalized(thread);
   ASSERT(error.IsNull());
 
   bool start_task = false;
   Isolate* isolate = thread->isolate();
   {
     MutexLocker ml(isolate->mutex());
     if (isolate->background_compiler() == NULL) {
       BackgroundCompiler* task = new BackgroundCompiler(isolate);
       isolate->set_background_compiler(task);
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
-
 #else  // DART_PRECOMPILED_RUNTIME
 
-
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {
   UNREACHABLE();
   return false;
 }
 
-
 CompilationPipeline* CompilationPipeline::New(Zone* zone,
                                               const Function& function) {
   UNREACHABLE();
   return NULL;
 }
 
-
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   FATAL3("Precompilation missed function %s (%" Pd ", %s)\n",
          function.ToLibNamePrefixedQualifiedCString(),
          function.token_pos().value(),
          Function::KindToCString(function.kind()));
 }
 
-
 bool Compiler::IsBackgroundCompilation() {
   return false;
 }
 
-
 bool Compiler::CanOptimizeFunction(Thread* thread, const Function& function) {
   UNREACHABLE();
   return false;
 }
 
-
 RawError* Compiler::Compile(const Library& library, const Script& script) {
   FATAL1("Attempt to compile script %s", script.ToCString());
   return Error::null();
 }
 
-
 RawError* Compiler::CompileClass(const Class& cls) {
   FATAL1("Attempt to compile class %s", cls.ToCString());
   return Error::null();
 }
 
-
 RawObject* Compiler::CompileFunction(Thread* thread, const Function& function) {
   FATAL1("Attempt to compile function %s", function.ToCString());
   return Error::null();
 }
 
-
 RawError* Compiler::ParseFunction(Thread* thread, const Function& function) {
   FATAL1("Attempt to parse function %s", function.ToCString());
   return Error::null();
 }
 
-
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                           const Function& function) {
   FATAL1("Attempt to compile function %s", function.ToCString());
   return Error::null();
 }
 
-
 RawObject* Compiler::CompileOptimizedFunction(Thread* thread,
                                               const Function& function,
                                               intptr_t osr_id) {
   FATAL1("Attempt to compile function %s", function.ToCString());
   return Error::null();
 }
 
-
 RawError* Compiler::CompileParsedFunction(ParsedFunction* parsed_function) {
   FATAL1("Attempt to compile function %s",
          parsed_function->function().ToCString());
   return Error::null();
 }
 
-
 void Compiler::ComputeLocalVarDescriptors(const Code& code) {
   UNREACHABLE();
 }
 
-
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   FATAL1("Attempt to compile class %s", cls.ToCString());
   return Error::null();
 }
 
-
 RawError* Compiler::ParseAllFunctions(const Class& cls) {
   FATAL1("Attempt to parse class %s", cls.ToCString());
   return Error::null();
 }
 
-
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.HasPrecompiledInitializer());
   const Function& initializer =
       Function::Handle(field.PrecompiledInitializer());
   return DartEntry::InvokeFunction(initializer, Object::empty_array());
 }
 
-
 RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
   UNREACHABLE();
   return Object::null();
 }
 
-
 void Compiler::AbortBackgroundCompilation(intptr_t deopt_id, const char* msg) {
   UNREACHABLE();
 }
 
-
 void BackgroundCompiler::CompileOptimized(const Function& function) {
   UNREACHABLE();
 }
 
-
 void BackgroundCompiler::VisitPointers(ObjectPointerVisitor* visitor) {
   UNREACHABLE();
 }
 
-
 void BackgroundCompiler::Stop(Isolate* isolate) {
   UNREACHABLE();
 }
 
-
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
-
 void BackgroundCompiler::Disable() {
   UNREACHABLE();
 }
 
-
 void BackgroundCompiler::Enable() {
   UNREACHABLE();
 }
 
-
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart