clang-format runtime/vm

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 29 matching lines @@
 #include "vm/regexp_parser.h"
 #include "vm/regexp_assembler.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/timer.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, allocation_sinking, true,
-    "Attempt to sink temporary allocations to side exits");
-DEFINE_FLAG(bool, common_subexpression_elimination, true,
-    "Do common subexpression elimination.");
-DEFINE_FLAG(bool, constant_propagation, true,
+DEFINE_FLAG(bool,
+            allocation_sinking,
+            true,
+            "Attempt to sink temporary allocations to side exits");
+DEFINE_FLAG(bool,
+            common_subexpression_elimination,
+            true,
+            "Do common subexpression elimination.");
+DEFINE_FLAG(
+    bool,
+    constant_propagation,
+    true,
     "Do conditional constant propagation/unreachable code elimination.");
-DEFINE_FLAG(int, max_deoptimization_counter_threshold, 16,
+DEFINE_FLAG(
+    int,
+    max_deoptimization_counter_threshold,
+    16,
     "How many times we allow deoptimization before we disallow optimization.");
-DEFINE_FLAG(bool, loop_invariant_code_motion, true,
-    "Do loop invariant code motion.");
+DEFINE_FLAG(bool,
+            loop_invariant_code_motion,
+            true,
+            "Do loop invariant code motion.");
 DEFINE_FLAG(charp, optimization_filter, NULL, "Optimize only named function");
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
-DEFINE_FLAG(bool, print_flow_graph_optimized, false,
-    "Print the IR flow graph when optimizing.");
-DEFINE_FLAG(bool, print_ic_data_map, false,
-    "Print the deopt-id to ICData map in optimizing compiler.");
+DEFINE_FLAG(bool,
+            print_flow_graph_optimized,
+            false,
+            "Print the IR flow graph when optimizing.");
+DEFINE_FLAG(bool,
+            print_ic_data_map,
+            false,
+            "Print the deopt-id to ICData map in optimizing compiler.");
 DEFINE_FLAG(bool, print_code_source_map, false, "Print code source map.");
 DEFINE_FLAG(bool, range_analysis, true, "Enable range analysis");
-DEFINE_FLAG(bool, stress_test_background_compilation, false,
-    "Keep background compiler running all the time");
-DEFINE_FLAG(bool, stop_on_excessive_deoptimization, false,
-    "Debugging: stops program if deoptimizing same function too often");
+DEFINE_FLAG(bool,
+            stress_test_background_compilation,
+            false,
+            "Keep background compiler running all the time");
+DEFINE_FLAG(bool,
+            stop_on_excessive_deoptimization,
+            false,
+            "Debugging: stops program if deoptimizing same function too often");
 DEFINE_FLAG(bool, trace_compiler, false, "Trace compiler operations.");
-DEFINE_FLAG(bool, trace_failed_optimization_attempts, false,
-    "Traces all failed optimization attempts");
-DEFINE_FLAG(bool, trace_optimizing_compiler, false,
-    "Trace only optimizing compiler operations.");
+DEFINE_FLAG(bool,
+            trace_failed_optimization_attempts,
+            false,
+            "Traces all failed optimization attempts");
+DEFINE_FLAG(bool,
+            trace_optimizing_compiler,
+            false,
+            "Trace only optimizing compiler operations.");
 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");
+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);
 DECLARE_FLAG(bool, trace_irregexp);
 
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {
@@ skipping 13 matching lines @@
 
 
 FlowGraph* DartCompilationPipeline::BuildFlowGraph(
     Zone* zone,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     intptr_t osr_id) {
   if (UseKernelFrontEndFor(parsed_function)) {
     kernel::TreeNode* node = static_cast<kernel::TreeNode*>(
         parsed_function->function().kernel_function());
-    kernel::FlowGraphBuilder builder(
-        node, parsed_function, ic_data_array, NULL, osr_id);
+    kernel::FlowGraphBuilder builder(node, parsed_function, ic_data_array, NULL,
+                                     osr_id);
     FlowGraph* graph = builder.BuildGraph();
     ASSERT(graph != NULL);
     return graph;
   }
-  FlowGraphBuilder builder(*parsed_function,
-                           ic_data_array,
+  FlowGraphBuilder builder(*parsed_function, ic_data_array,
                            NULL,  // NULL = not inlining.
                            osr_id);
 
   return builder.BuildGraph();
 }
 
 
-void DartCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) { }
+void DartCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) {}
 
 
 void IrregexpCompilationPipeline::ParseFunction(
     ParsedFunction* parsed_function) {
   RegExpParser::ParseFunction(parsed_function);
   // 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);
+  RegExpEngine::CompilationResult result = RegExpEngine::CompileIR(
+      parsed_function->regexp_compile_data(), parsed_function, ic_data_array);
   backtrack_goto_ = result.backtrack_goto;
 
   // Allocate variables now that we know the number of locals.
   parsed_function->AllocateIrregexpVariables(result.num_stack_locals);
 
   // Build the flow graph.
-  FlowGraphBuilder builder(*parsed_function,
-                           ic_data_array,
+  FlowGraphBuilder builder(*parsed_function, ic_data_array,
                            NULL,  // NULL = not inlining.
                            osr_id);
 
-  return new(zone) FlowGraph(*parsed_function,
-                             result.graph_entry,
-                             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();
+    return new (zone) IrregexpCompilationPipeline();
   } else {
-    return new(zone) DartCompilationPipeline();
+    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 Error& error =
@@ skipping 17 matching lines @@
       // so do not optimize the function.
       function.set_usage_counter(0);
       return false;
     }
   }
   if (function.deoptimization_counter() >=
       FLAG_max_deoptimization_counter_threshold) {
     if (FLAG_trace_failed_optimization_attempts ||
         FLAG_stop_on_excessive_deoptimization) {
       THR_Print("Too many deoptimizations: %s\n",
-          function.ToFullyQualifiedCString());
+                function.ToFullyQualifiedCString());
       if (FLAG_stop_on_excessive_deoptimization) {
         FATAL("Stop on excessive deoptimization");
       }
     }
     // The function will not be optimized any longer. This situation can occur
     // mostly with small optimization counter thresholds.
     function.SetIsOptimizable(false);
     function.set_usage_counter(INT_MIN);
     return false;
   }
@@ skipping 120 matching lines @@
     return Error::null();
   }
   // If the class is already marked for parsing return immediately.
   if (cls.is_marked_for_parsing()) {
     return Error::null();
   }
   // If the class is a typedef class there is no need to try and
   // compile it. Just finalize it directly.
   if (cls.IsTypedefClass()) {
 #if defined(DEBUG)
-    const Class& closure_cls = Class::Handle(
-        Isolate::Current()->object_store()->closure_class());
+    const Class& closure_cls =
+        Class::Handle(Isolate::Current()->object_store()->closure_class());
     ASSERT(closure_cls.is_finalized());
 #endif
     LongJumpScope jump;
     if (setjmp(*jump.Set()) == 0) {
       ClassFinalizer::FinalizeClass(cls);
       return Error::null();
     } else {
       Thread* thread = Thread::Current();
       Error& error = Error::Handle(thread->zone());
       error = thread->sticky_error();
       thread->clear_sticky_error();
       return error.raw();
     }
   }
 
   Thread* const thread = Thread::Current();
   StackZone zone(thread);
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   VMTagScope tagScope(thread, VMTag::kCompileClassTagId);
-  TimelineDurationScope tds(thread,
-                            Timeline::GetCompilerStream(),
+  TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                             "CompileClass");
   if (tds.enabled()) {
     tds.SetNumArguments(1);
     tds.CopyArgument(0, "class", cls.ToCString());
   }
-)  // !PRODUCT
+#endif  // !defined(PRODUCT)
 
   // We remember all the classes that are being compiled in these lists. This
   // also allows us to reset the marked_for_parsing state in case we see an
   // error.
   GrowableHandlePtrArray<const Class> parse_list(thread->zone(), 4);
   GrowableHandlePtrArray<const Class> patch_list(thread->zone(), 4);
 
   // Parse the class and all the interfaces it implements and super classes.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
@@ skipping 11 matching lines @@
     // exists to the corresponding lists.
     // NOTE: The parse_list array keeps growing as more classes are added
     // to it by AddRelatedClassesToList. It is not OK to hoist
     // parse_list.Length() into a local variable and iterate using the local
     // variable.
     for (intptr_t i = 0; i < parse_list.length(); i++) {
       AddRelatedClassesToList(parse_list.At(i), &parse_list, &patch_list);
     }
 
     // Parse all the classes that have been added above.
-    for (intptr_t i = (parse_list.length() - 1); i >=0 ; i--) {
+    for (intptr_t i = (parse_list.length() - 1); i >= 0; i--) {
       const Class& parse_class = parse_list.At(i);
       ASSERT(!parse_class.IsNull());
       Parser::ParseClass(parse_class);
     }
 
     // Parse all the patch classes that have been added above.
     for (intptr_t i = 0; i < patch_list.length(); i++) {
       const Class& parse_class = patch_list.At(i);
       ASSERT(!parse_class.IsNull());
       Parser::ParseClass(parse_class);
     }
 
     // Finalize these classes.
-    for (intptr_t i = (parse_list.length() - 1); i >=0 ; i--) {
+    for (intptr_t i = (parse_list.length() - 1); i >= 0; i--) {
       const Class& parse_class = parse_list.At(i);
       ASSERT(!parse_class.IsNull());
       ClassFinalizer::FinalizeClass(parse_class);
       parse_class.reset_is_marked_for_parsing();
     }
-    for (intptr_t i = (patch_list.length() - 1); i >=0 ; i--) {
+    for (intptr_t i = (patch_list.length() - 1); i >= 0; i--) {
       const Class& parse_class = patch_list.At(i);
       ASSERT(!parse_class.IsNull());
       ClassFinalizer::FinalizeClass(parse_class);
       parse_class.reset_is_marked_for_parsing();
     }
 
     return Error::null();
   } else {
     // Reset the marked for parsing flags.
     for (intptr_t i = 0; i < parse_list.length(); i++) {
@@ skipping 21 matching lines @@
 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_(
-            isolate()->loading_invalidation_gen()) {
-  }
+            isolate()->loading_invalidation_gen()) {}
 
   bool Compile(CompilationPipeline* pipeline);
 
  private:
   ParsedFunction* parsed_function() const { return parsed_function_; }
   bool optimized() const { return optimized_; }
   intptr_t osr_id() const { return osr_id_; }
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
   intptr_t loading_invalidation_gen_at_start() const {
@@ skipping 24 matching lines @@
 
   CSTAT_TIMER_SCOPE(thread(), codefinalizer_timer);
   // CreateDeoptInfo uses the object pool and needs to be done before
   // FinalizeCode.
   const Array& deopt_info_array =
       Array::Handle(zone, graph_compiler->CreateDeoptInfo(assembler));
   INC_STAT(thread(), total_code_size,
            deopt_info_array.Length() * sizeof(uword));
   // Allocates instruction object. Since this occurs only at safepoint,
   // there can be no concurrent access to the instruction page.
-  const Code& code = Code::Handle(
-      Code::FinalizeCode(function, assembler, optimized()));
+  const Code& code =
+      Code::Handle(Code::FinalizeCode(function, assembler, optimized()));
   code.set_is_optimized(optimized());
   code.set_owner(function);
   if (!function.IsOptimizable()) {
     // A function with huge unoptimized code can become non-optimizable
     // after generating unoptimized code.
     function.set_usage_counter(INT_MIN);
   }
 
   const Array& intervals = graph_compiler->inlined_code_intervals();
-  INC_STAT(thread(), total_code_size,
-           intervals.Length() * sizeof(uword));
+  INC_STAT(thread(), total_code_size, intervals.Length() * sizeof(uword));
   code.SetInlinedIntervals(intervals);
 
   const Array& inlined_id_array =
       Array::Handle(zone, graph_compiler->InliningIdToFunction());
   INC_STAT(thread(), total_code_size,
            inlined_id_array.Length() * sizeof(uword));
   code.SetInlinedIdToFunction(inlined_id_array);
 
   const Array& caller_inlining_id_map_array =
       Array::Handle(zone, graph_compiler->CallerInliningIdMap());
   INC_STAT(thread(), total_code_size,
            caller_inlining_id_map_array.Length() * sizeof(uword));
   code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
 
   const Array& inlined_id_to_token_pos =
       Array::Handle(zone, graph_compiler->InliningIdToTokenPos());
   INC_STAT(thread(), total_code_size,
            inlined_id_to_token_pos.Length() * sizeof(uword));
   code.SetInlinedIdToTokenPos(inlined_id_to_token_pos);
 
   graph_compiler->FinalizePcDescriptors(code);
   code.set_deopt_info_array(deopt_info_array);
 
   graph_compiler->FinalizeStackmaps(code);
   graph_compiler->FinalizeVarDescriptors(code);
   graph_compiler->FinalizeExceptionHandlers(code);
   graph_compiler->FinalizeStaticCallTargetsTable(code);
 
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   // Set the code source map after setting the inlined information because
   // we use the inlined information when printing.
-  const CodeSourceMap& code_source_map =
-      CodeSourceMap::Handle(
-          zone,
-          graph_compiler->code_source_map_builder()->Finalize());
+  const CodeSourceMap& code_source_map = CodeSourceMap::Handle(
+      zone, graph_compiler->code_source_map_builder()->Finalize());
   code.set_code_source_map(code_source_map);
   if (FLAG_print_code_source_map) {
     CodeSourceMap::Dump(code_source_map, code, function);
   }
-);
+#endif  // !defined(PRODUCT)
+
   if (optimized()) {
     bool code_was_installed = false;
     // Installs code while at safepoint.
     if (thread()->IsMutatorThread()) {
       const bool is_osr = osr_id() != Compiler::kNoOSRDeoptId;
       function.InstallOptimizedCode(code, is_osr);
       code_was_installed = true;
     } else {
       // Background compilation.
       // Before installing code check generation counts if the code may
@@ skipping 82 matching lines @@
       (*prefixes)[i]->RegisterDependentCode(code);
     }
   }
 }
 
 
 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");
+    Compiler::AbortBackgroundCompilation(
+        Thread::kNoDeoptId, "Background compilation is being stopped");
   }
 }
 
 
 // Return false if bailed out.
 // If optimized_result_code is not NULL then it is caller's responsibility
 // to install code.
 bool CompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
   ASSERT(!FLAG_precompiled_mode);
   const Function& function = parsed_function()->function();
   if (optimized() && !function.IsOptimizable()) {
     return false;
   }
   bool is_compiled = false;
   Zone* const zone = thread()->zone();
-  NOT_IN_PRODUCT(
-      TimelineStream* compiler_timeline = Timeline::GetCompilerStream());
+  NOT_IN_PRODUCT(TimelineStream* compiler_timeline =
+                     Timeline::GetCompilerStream());
   CSTAT_TIMER_SCOPE(thread(), codegen_timer);
   HANDLESCOPE(thread());
 
   // We may reattempt compilation if the function needs to be assembled using
   // far branches on ARM and MIPS. In the else branch of the setjmp call,
   // done is set to false, and use_far_branches is set to true if there is a
   // longjmp from the ARM or MIPS assemblers. In all other paths through this
   // while loop, done is set to true. use_far_branches is always false on ia32
   // and x64.
   volatile bool done = false;
@@ skipping 11 matching lines @@
 
       // Class hierarchy analysis is registered with the thread in the
       // constructor and unregisters itself upon destruction.
       CHA cha(thread());
 
       // TimerScope needs an isolate to be properly terminated in case of a
       // LongJump.
       {
         CSTAT_TIMER_SCOPE(thread(), graphbuilder_timer);
         ZoneGrowableArray<const ICData*>* ic_data_array =
-            new(zone) ZoneGrowableArray<const ICData*>();
+            new (zone) ZoneGrowableArray<const ICData*>();
         if (optimized()) {
           // Extract type feedback before the graph is built, as the graph
           // builder uses it to attach it to nodes.
 
           // In background compilation the deoptimization counter may have
           // already reached the limit.
           ASSERT(Compiler::IsBackgroundCompilation() ||
                  (function.deoptimization_counter() <
-                     FLAG_max_deoptimization_counter_threshold));
+                  FLAG_max_deoptimization_counter_threshold));
 
           // 'Freeze' ICData in background compilation so that it does not
           // change while compiling.
           const bool clone_ic_data = Compiler::IsBackgroundCompilation();
           function.RestoreICDataMap(ic_data_array, clone_ic_data);
 
           if (Compiler::IsBackgroundCompilation() &&
               (function.ic_data_array() == Array::null())) {
-            Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
-                "RestoreICDataMap: ICData array cleared.");
+            Compiler::AbortBackgroundCompilation(
+                Thread::kNoDeoptId, "RestoreICDataMap: ICData array cleared.");
           }
           if (FLAG_print_ic_data_map) {
             for (intptr_t i = 0; i < ic_data_array->length(); i++) {
               if ((*ic_data_array)[i] != NULL) {
                 THR_Print("%" Pd " ", i);
                 FlowGraphPrinter::PrintICData(*(*ic_data_array)[i]);
               }
             }
           }
         }
 
-        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
-                                                 compiler_timeline,
-                                                 "BuildFlowGraph");)
-        flow_graph = pipeline->BuildFlowGraph(zone,
-                                              parsed_function(),
-                                              *ic_data_array,
-                                              osr_id());
+        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
+                                                 "BuildFlowGraph"));
+        flow_graph = pipeline->BuildFlowGraph(zone, parsed_function(),
+                                              *ic_data_array, osr_id());
       }
 
       const bool print_flow_graph =
           (FLAG_print_flow_graph ||
            (optimized() && FLAG_print_flow_graph_optimized)) &&
           FlowGraphPrinter::ShouldPrint(function);
 
       if (print_flow_graph) {
         if (osr_id() == Compiler::kNoOSRDeoptId) {
           FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
         } else {
           FlowGraphPrinter::PrintGraph("For OSR", flow_graph);
         }
       }
 
       BlockScheduler block_scheduler(flow_graph);
       const bool reorder_blocks =
           FlowGraph::ShouldReorderBlocks(function, optimized());
       if (reorder_blocks) {
         NOT_IN_PRODUCT(TimelineDurationScope tds(
             thread(), compiler_timeline, "BlockScheduler::AssignEdgeWeights"));
         block_scheduler.AssignEdgeWeights();
       }
 
       if (optimized()) {
-        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
-                                                 compiler_timeline,
+        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
                                                  "ComputeSSA"));
         CSTAT_TIMER_SCOPE(thread(), ssa_timer);
         // Transform to SSA (virtual register 0 and no inlining arguments).
         flow_graph->ComputeSSA(0, NULL);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
         if (print_flow_graph) {
           FlowGraphPrinter::PrintGraph("After SSA", flow_graph);
         }
       }
 
       // Maps inline_id_to_function[inline_id] -> function. Top scope
       // function has inline_id 0. The map is populated by the inliner.
       GrowableArray<const Function*> inline_id_to_function;
       // Token position where inlining occured.
       GrowableArray<TokenPosition> inline_id_to_token_pos;
       // For a given inlining-id(index) specifies the caller's inlining-id.
       GrowableArray<intptr_t> caller_inline_id;
       // Collect all instance fields that are loaded in the graph and
       // have non-generic type feedback attached to them that can
       // potentially affect optimizations.
       if (optimized()) {
-        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
-                                                 compiler_timeline,
+        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
                                                  "OptimizationPasses"));
         inline_id_to_function.Add(&function);
         // We do not add the token position now because we don't know the
         // position of the inlined call until later. A side effect of this
         // is that the length of |inline_id_to_function| is always larger
         // than the length of |inline_id_to_token_pos| by one.
         // Top scope function has no caller (-1). We do this because we expect
         // all token positions to be at an inlined call.
         caller_inline_id.Add(-1);
         CSTAT_TIMER_SCOPE(thread(), graphoptimizer_timer);
 
         JitOptimizer optimizer(flow_graph);
 
         optimizer.ApplyICData();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run early in order to have more opportunity to optimize left shifts.
         flow_graph->TryOptimizePatterns();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphInliner::SetInliningId(flow_graph, 0);
 
         // Inlining (mutates the flow graph)
         if (FLAG_use_inlining) {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "Inlining"));
           CSTAT_TIMER_SCOPE(thread(), graphinliner_timer);
           // Propagate types to create more inlining opportunities.
           FlowGraphTypePropagator::Propagate(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           // Use propagated class-ids to create more inlining opportunities.
           optimizer.ApplyClassIds();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
-          FlowGraphInliner inliner(flow_graph,
-                                   &inline_id_to_function,
-                                   &inline_id_to_token_pos,
-                                   &caller_inline_id,
+          FlowGraphInliner inliner(flow_graph, &inline_id_to_function,
+                                   &inline_id_to_token_pos, &caller_inline_id,
                                    use_speculative_inlining,
-                                   /*inlining_black_list=*/ NULL,
-                                   /*precompiler=*/ NULL);
+                                   /*inlining_black_list=*/NULL,
+                                   /*precompiler=*/NULL);
           inliner.Inline();
           // Use lists are maintained and validated by the inliner.
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types and eliminate more type tests.
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "ApplyClassIds"));
           // Use propagated class-ids to optimize further.
           optimizer.ApplyClassIds();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types for potentially newly added instructions by
         // ApplyClassIds(). Must occur before canonicalization.
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Do optimizations that depend on the propagated type information.
         if (flow_graph->Canonicalize()) {
           // Invoke Canonicalize twice in order to fully canonicalize patterns
           // like "if (a & const == 0) { }".
           flow_graph->Canonicalize();
         }
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "BranchSimplifier"));
           BranchSimplifier::Simplify(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           IfConverter::Simplify(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         if (FLAG_constant_propagation) {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "ConstantPropagation");
-          ConstantPropagator::Optimize(flow_graph));
+                         ConstantPropagator::Optimize(flow_graph));
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
           // A canonicalization pass to remove e.g. smi checks on smi constants.
           flow_graph->Canonicalize();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
           // Canonicalization introduced more opportunities for constant
           // propagation.
           ConstantPropagator::Optimize(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Optimistically convert loop phis that have a single non-smi input
         // coming from the loop pre-header into smi-phis.
         if (FLAG_loop_invariant_code_motion) {
           LICM licm(flow_graph);
           licm.OptimisticallySpecializeSmiPhis();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types and eliminate even more type tests.
         // Recompute types after constant propagation to infer more precise
         // types for uses that were previously reached by now eliminated phis.
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "SelectRepresentations"));
           // Where beneficial convert Smi operations into Int32 operations.
           // Only meanigful for 32bit platforms right now.
           flow_graph->WidenSmiToInt32();
 
           // Unbox doubles. Performed after constant propagation to minimize
           // interference from phis merging double values and tagged
           // values coming from dead paths.
           flow_graph->SelectRepresentations();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
@@ skipping 32 matching lines @@
           flow_graph->RemoveRedefinitions();
         }
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run after CSE in order to have more opportunity to merge
         // instructions that have same inputs.
         flow_graph->TryOptimizePatterns();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "DeadStoreElimination"));
           DeadStoreElimination::Optimize(flow_graph);
         }
 
         if (FLAG_range_analysis) {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "RangeAnalysis"));
           // Propagate types after store-load-forwarding. Some phis may have
           // become smi phis that can be processed by range analysis.
           FlowGraphTypePropagator::Propagate(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           // We have to perform range analysis after LICM because it
           // optimistically moves CheckSmi through phis into loop preheaders
           // making some phis smi.
           RangeAnalysis range_analysis(flow_graph);
@@ skipping 23 matching lines @@
           // Optimize try-blocks.
           TryCatchAnalyzer::Optimize(flow_graph);
         }
 
         // Detach environments from the instructions that can't deoptimize.
         // Do it before we attempt to perform allocation sinking to minimize
         // amount of materializations it has to perform.
         flow_graph->EliminateEnvironments();
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "EliminateDeadPhis"));
           DeadCodeElimination::EliminateDeadPhis(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         if (flow_graph->Canonicalize()) {
           flow_graph->Canonicalize();
         }
 
         // Attempt to sink allocations of temporary non-escaping objects to
         // the deoptimization path.
         AllocationSinking* sinking = NULL;
         if (FLAG_allocation_sinking &&
             (flow_graph->graph_entry()->SuccessorCount() == 1)) {
           NOT_IN_PRODUCT(TimelineDurationScope tds2(
               thread(), compiler_timeline, "AllocationSinking::Optimize"));
           // TODO(fschneider): Support allocation sinking with try-catch.
           sinking = new AllocationSinking(flow_graph);
           sinking->Optimize();
         }
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         DeadCodeElimination::EliminateDeadPhis(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "SelectRepresentations"));
           // Ensure that all phis inserted by optimization passes have
           // consistent representations.
           flow_graph->SelectRepresentations();
         }
 
         if (flow_graph->Canonicalize()) {
           // To fully remove redundant boxing (e.g. BoxDouble used only in
           // environments and UnboxDouble instructions) instruction we
           // first need to replace all their uses and then fold them away.
@@ skipping 12 matching lines @@
           // referenced only from environments. Register allocator will consider
           // them as part of a deoptimization environment.
           sinking->DetachMaterializations();
         }
 
         // Compute and store graph informations (call & instruction counts)
         // to be later used by the inliner.
         FlowGraphInliner::CollectGraphInfo(flow_graph, true);
 
         {
-          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(),
-                                                    compiler_timeline,
+          NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "AllocateRegisters"));
           // Perform register allocation on the SSA graph.
           FlowGraphAllocator allocator(*flow_graph);
           allocator.AllocateRegisters();
         }
 
         if (reorder_blocks) {
           NOT_IN_PRODUCT(TimelineDurationScope tds(
               thread(), compiler_timeline, "BlockScheduler::ReorderBlocks"));
           block_scheduler.ReorderBlocks();
         }
 
         if (print_flow_graph) {
           FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
         }
       }
 
       ASSERT(inline_id_to_function.length() == caller_inline_id.length());
       Assembler assembler(use_far_branches);
-      FlowGraphCompiler graph_compiler(&assembler, flow_graph,
-                                       *parsed_function(), optimized(),
-                                       inline_id_to_function,
-                                       inline_id_to_token_pos,
-                                       caller_inline_id);
+      FlowGraphCompiler graph_compiler(
+          &assembler, flow_graph, *parsed_function(), optimized(),
+          inline_id_to_function, inline_id_to_token_pos, caller_inline_id);
       {
         CSTAT_TIMER_SCOPE(thread(), graphcompiler_timer);
-        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
-                                                 compiler_timeline,
+        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
                                                  "CompileGraph"));
         graph_compiler.CompileGraph();
         pipeline->FinalizeCompilation(flow_graph);
       }
       {
-        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
-                                                 compiler_timeline,
+        NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
                                                  "FinalizeCompilation"));
         if (thread()->IsMutatorThread()) {
           FinalizeCompilation(&assembler, &graph_compiler, flow_graph);
         } else {
           // This part of compilation must be at a safepoint.
           // Stop mutator thread before creating the instruction object and
           // installing code.
           // Mutator thread may not run code while we are creating the
           // instruction object, since the creation of instruction object
           // changes code page access permissions (makes them temporary not
@@ skipping 52 matching lines @@
       }
       is_compiled = false;
     }
     // Reset global isolate state.
     thread()->set_deopt_id(prev_deopt_id);
   }
   return is_compiled;
 }
 
 
-DEBUG_ONLY(
+#if defined(DEBUG)
 // Verifies that the inliner is always in the list of inlined functions.
 // If this fails run with --trace-inlining-intervals to get more information.
 static void CheckInliningIntervals(const Function& function) {
   const Code& code = Code::Handle(function.CurrentCode());
   const Array& intervals = Array::Handle(code.GetInlinedIntervals());
   if (intervals.IsNull() || (intervals.Length() == 0)) return;
   Smi& start = Smi::Handle();
   GrowableArray<Function*> inlined_functions;
   for (intptr_t i = 0; i < intervals.Length(); i += Code::kInlIntNumEntries) {
     start ^= intervals.At(i + Code::kInlIntStart);
     ASSERT(!start.IsNull());
     if (start.IsNull()) continue;
     code.GetInlinedFunctionsAt(start.Value(), &inlined_functions);
     ASSERT(inlined_functions[inlined_functions.length() - 1]->raw() ==
            function.raw());
   }
 }
-)
+#endif  // defined(DEBUG)
 
 static RawError* 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();
     StackZone stack_zone(thread);
     Zone* const zone = stack_zone.GetZone();
     const bool trace_compiler =
-        FLAG_trace_compiler ||
-        (FLAG_trace_optimizing_compiler && optimized);
+        FLAG_trace_compiler || (FLAG_trace_optimizing_compiler && optimized);
     Timer per_compile_timer(trace_compiler, "Compilation time");
     per_compile_timer.Start();
 
-    ParsedFunction* parsed_function = new(zone) ParsedFunction(
-        thread, Function::ZoneHandle(zone, function.raw()));
+    ParsedFunction* parsed_function = new (zone)
+        ParsedFunction(thread, Function::ZoneHandle(zone, function.raw()));
     if (trace_compiler) {
-      const intptr_t token_size = function.end_token_pos().Pos() -
-                                  function.token_pos().Pos();
+      const intptr_t token_size =
+          function.end_token_pos().Pos() - function.token_pos().Pos();
       THR_Print("Compiling %s%sfunction %s: '%s' @ token %s, size %" Pd "\n",
                 (osr_id == Compiler::kNoOSRDeoptId ? "" : "osr "),
                 (optimized ? "optimized " : ""),
                 (Compiler::IsBackgroundCompilation() ? "(background)" : ""),
                 function.ToFullyQualifiedCString(),
-                function.token_pos().ToCString(),
-                token_size);
+                function.token_pos().ToCString(), token_size);
     }
     INC_STAT(thread, num_functions_compiled, 1);
     if (optimized) {
       INC_STAT(thread, num_functions_optimized, 1);
     }
     // Makes sure no classes are loaded during parsing in background.
     const intptr_t loading_invalidation_gen_at_start =
         isolate->loading_invalidation_gen();
     {
       HANDLESCOPE(thread);
       const int64_t num_tokens_before = STAT_VALUE(thread, num_tokens_consumed);
       pipeline->ParseFunction(parsed_function);
       const int64_t num_tokens_after = STAT_VALUE(thread, num_tokens_consumed);
-      INC_STAT(thread,
-               num_func_tokens_compiled,
+      INC_STAT(thread, num_func_tokens_compiled,
                num_tokens_after - num_tokens_before);
     }
 
     CompileParsedFunctionHelper helper(parsed_function, optimized, osr_id);
 
     if (Compiler::IsBackgroundCompilation()) {
       if (isolate->IsTopLevelParsing() ||
-              (loading_invalidation_gen_at_start !=
-               isolate->loading_invalidation_gen())) {
+          (loading_invalidation_gen_at_start !=
+           isolate->loading_invalidation_gen())) {
         // Loading occured while parsing. We need to abort here because state
         // changed while compiling.
-        Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
+        Compiler::AbortBackgroundCompilation(
+            Thread::kNoDeoptId,
             "Invalidated state during parsing because of script loading");
       }
     }
 
     const bool success = helper.Compile(pipeline);
     if (success) {
       if (!optimized) {
         function.set_was_compiled(true);
       }
     } else {
       if (optimized) {
         if (Compiler::IsBackgroundCompilation()) {
           // Try again later, background compilation may abort because of
           // state change during compilation.
           if (FLAG_trace_compiler) {
             THR_Print("Aborted background compilation: %s\n",
-                function.ToFullyQualifiedCString());
+                      function.ToFullyQualifiedCString());
           }
           {
             // If it was a bailout, then disable optimization.
             Error& error = Error::Handle();
             // We got an error during compilation.
             error = thread->sticky_error();
             thread->clear_sticky_error();
             if ((error.IsLanguageError() &&
                  LanguageError::Cast(error).kind() == Report::kBailout) ||
                 error.IsUnhandledException()) {
@@ skipping 41 matching lines @@
                 Code::Handle(function.CurrentCode()).Size(),
                 per_compile_timer.TotalElapsedTime());
     }
 
     if (FLAG_support_debugger) {
       isolate->debugger()->NotifyCompilation(function);
     }
 
     if (FLAG_disassemble && FlowGraphPrinter::ShouldPrint(function)) {
       Disassembler::DisassembleCode(function, optimized);
-    } else if (FLAG_disassemble_optimized &&
-               optimized &&
+    } else if (FLAG_disassemble_optimized && optimized &&
                FlowGraphPrinter::ShouldPrint(function)) {
       Disassembler::DisassembleCode(function, true);
     }
 
     DEBUG_ONLY(CheckInliningIntervals(function));
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     StackZone stack_zone(thread);
     Error& error = Error::Handle();
     // We got an error during compilation or it is a bailout from background
     // compilation (e.g., during parsing with EnsureIsFinalized).
     error = thread->sticky_error();
     thread->clear_sticky_error();
     if (error.raw() == Object::background_compilation_error().raw()) {
       // Exit compilation, retry it later.
       if (FLAG_trace_bailout) {
         THR_Print("Aborted background compilation: %s\n",
-            function.ToFullyQualifiedCString());
+                  function.ToFullyQualifiedCString());
       }
       return Error::null();
     }
     // Do not attempt to optimize functions that can cause errors.
     function.set_is_optimizable(false);
     return error.raw();
   }
   UNREACHABLE();
   return Error::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);
     Zone* const zone = stack_zone.GetZone();
     const bool trace_compiler =
-        FLAG_trace_compiler ||
-        (FLAG_trace_optimizing_compiler && optimized);
+        FLAG_trace_compiler || (FLAG_trace_optimizing_compiler && optimized);
 
     if (trace_compiler) {
-      const intptr_t token_size = function.end_token_pos().Pos() -
-                                  function.token_pos().Pos();
+      const intptr_t token_size =
+          function.end_token_pos().Pos() - function.token_pos().Pos();
       THR_Print("Parsing %s%sfunction %s: '%s' @ token %s, size %" Pd "\n",
                 (osr_id == Compiler::kNoOSRDeoptId ? "" : "osr "),
                 (optimized ? "optimized " : ""),
                 (Compiler::IsBackgroundCompilation() ? "(background)" : ""),
                 function.ToFullyQualifiedCString(),
-                function.token_pos().ToCString(),
-                token_size);
+                function.token_pos().ToCString(), token_size);
     }
-    ParsedFunction* parsed_function = new(zone) ParsedFunction(
-        thread, Function::ZoneHandle(zone, function.raw()));
+    ParsedFunction* parsed_function = new (zone)
+        ParsedFunction(thread, Function::ZoneHandle(zone, function.raw()));
     pipeline->ParseFunction(parsed_function);
-    // For now we just walk thru the AST nodes and in DEBUG mode we print
-    // them otherwise just skip through them, this will be need to be
-    // wired to generate the IR format.
+// For now we just walk thru the AST nodes and in DEBUG mode we print
+// them otherwise just skip through them, this will be need to be
+// wired to generate the IR format.
 #if !defined(PRODUCT)
 #if defined(DEBUG)
     AstPrinter ast_printer(true);
 #else
     AstPrinter ast_printer(false);
 #endif  // defined(DEBUG).
     ast_printer.PrintFunctionNodes(*parsed_function);
 #endif  // !defined(PRODUCT).
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     StackZone stack_zone(thread);
     Error& error = Error::Handle();
     // We got an error during compilation or it is a bailout from background
     // compilation (e.g., during parsing with EnsureIsFinalized).
     error = thread->sticky_error();
     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();
 }
 
 
-RawError* Compiler::CompileFunction(Thread* thread,
-                                    const Function& function) {
+RawError* 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();
-NOT_IN_PRODUCT(
+
+#if !defined(PRODUCT)
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "CompileFunction", function);
-)  // !PRODUCT
+#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);
+  return CompileFunctionHelper(pipeline, function,
+                               /* optimized = */ false, kNoOSRDeoptId);
 }
 
 
-RawError* Compiler::ParseFunction(Thread* thread,
-                                  const Function& function) {
+RawError* Compiler::ParseFunction(Thread* thread, const Function& function) {
   Isolate* isolate = thread->isolate();
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "ParseFunction", function);
-)  // !PRODUCT
+#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);
+  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 =
       CompilationPipeline::New(thread->zone(), function);
   const Error& error = Error::Handle(
-      CompileFunctionHelper(pipeline,
-                            function,
-                            false,  /* not optimized */
+      CompileFunctionHelper(pipeline, function, false, /* not optimized */
                             kNoOSRDeoptId));
   if (!error.IsNull()) {
     return error.raw();
   }
   // Since CompileFunctionHelper replaces the current code, re-attach the
   // the original code if the function was already compiled.
   if (!original_code.IsNull() &&
       (original_code.raw() != function.CurrentCode())) {
     function.AttachCode(original_code);
   }
   ASSERT(function.unoptimized_code() != Object::null());
   if (FLAG_trace_compiler) {
     THR_Print("Ensure unoptimized code for %s\n", function.ToCString());
   }
   return Error::null();
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(Thread* thread,
                                              const Function& function,
                                              intptr_t osr_id) {
-NOT_IN_PRODUCT(
+#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);
-)  // !PRODUCT
+#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) ||
+  ASSERT(!thread->IsMutatorThread() || (osr_id != kNoOSRDeoptId) ||
          !FLAG_background_compilation || BackgroundCompiler::IsDisabled());
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
-  return CompileFunctionHelper(pipeline,
-                               function,
-                               true,  /* optimized */
+  return CompileFunctionHelper(pipeline, function, true, /* optimized */
                                osr_id);
 }
 
 
 // This is only used from unit tests.
-RawError* Compiler::CompileParsedFunction(
-    ParsedFunction* parsed_function) {
+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) {
       Disassembler::DisassembleCode(parsed_function->function(), false);
     }
     return Error::null();
@@ skipping 44 matching lines @@
   // Class dynamic lives in the vm isolate. Its array fields cannot be set to
   // an empty array.
   if (functions.IsNull()) {
     ASSERT(cls.IsDynamicClass());
     return error.raw();
   }
   // Compile all the regular functions.
   for (int i = 0; i < functions.Length(); i++) {
     func ^= functions.At(i);
     ASSERT(!func.IsNull());
-    if (!func.HasCode() &&
-        !func.is_abstract() &&
+    if (!func.HasCode() && !func.is_abstract() &&
         !func.IsRedirectingFactory()) {
       if ((cls.is_mixin_app_alias() || cls.IsMixinApplication()) &&
           func.HasOptionalParameters()) {
         // Skipping optional parameters in mixin application.
         continue;
       }
       error = CompileFunction(thread, func);
       if (!error.IsNull()) {
         return error.raw();
       }
@@ skipping 52 matching lines @@
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     NoOOBMessageScope no_msg_scope(thread);
     NoReloadScope no_reload_scope(thread->isolate(), thread);
     // Under lazy compilation initializer has not yet been created, so create
     // it now, but don't bother remembering it because it won't be used again.
     ASSERT(!field.HasPrecompiledInitializer());
     Function& initializer = Function::Handle(thread->zone());
     {
-      NOT_IN_PRODUCT(
-        VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
-        TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
-                                  "CompileStaticInitializer");
-        if (tds.enabled()) {
-          tds.SetNumArguments(1);
-          tds.CopyArgument(0, "field", field.ToCString());
-        }
-      )
+#if !defined(PRODUCT)
+      VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
+      TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
+                                "CompileStaticInitializer");
+      if (tds.enabled()) {
+        tds.SetNumArguments(1);
+        tds.CopyArgument(0, "field", field.ToCString());
+      }
+#endif  // !defined(PRODUCT)
 
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
       ParsedFunction* parsed_function;
 
       // Create a one-time-use function to evaluate the initializer and invoke
       // it immediately.
       if (field.kernel_field() != NULL) {
         // kImplicitStaticFinalGetter is used for both implicit static getters
         // and static initializers.  The Kernel graph builder will tell the
         // difference by pattern matching on the name.
-        const String& name = String::Handle(zone,
-            Symbols::FromConcat(thread,
-                Symbols::InitPrefix(), String::Handle(zone, field.name())));
+        const String& name = String::Handle(
+            zone, Symbols::FromConcat(thread, Symbols::InitPrefix(),
+                                      String::Handle(zone, field.name())));
         const Script& script = Script::Handle(zone, field.Script());
         Object& owner = Object::Handle(zone, field.Owner());
         owner = PatchClass::New(Class::Cast(owner), script);
-        const Function& function = Function::ZoneHandle(zone,
-            Function::New(name,
-                          RawFunction::kImplicitStaticFinalGetter,
-                          true,  // is_static
-                          false,  // is_const
-                          false,  // is_abstract
-                          false,  // is_external
-                          false,  // is_native
-                          owner,
-                          TokenPosition::kNoSource));
+        const Function& function = Function::ZoneHandle(
+            zone, Function::New(name, RawFunction::kImplicitStaticFinalGetter,
+                                true,   // is_static
+                                false,  // is_const
+                                false,  // is_abstract
+                                false,  // is_external
+                                false,  // is_native
+                                owner, TokenPosition::kNoSource));
         function.set_kernel_function(field.kernel_field());
         function.set_result_type(AbstractType::Handle(zone, field.type()));
         function.set_is_reflectable(false);
         function.set_is_debuggable(false);
         function.set_is_inlinable(false);
-        parsed_function = new(zone) ParsedFunction(thread, function);
+        parsed_function = new (zone) ParsedFunction(thread, function);
       } else {
         parsed_function = Parser::ParseStaticFieldInitializer(field);
         parsed_function->AllocateVariables();
       }
 
       // Non-optimized code generator.
       DartCompilationPipeline pipeline;
       CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
       helper.Compile(&pipeline);
       initializer = parsed_function->function().raw();
-      Code::Handle(initializer.unoptimized_code()).set_var_descriptors(
-          Object::empty_var_descriptors());
+      Code::Handle(initializer.unoptimized_code())
+          .set_var_descriptors(Object::empty_var_descriptors());
     }
     // Invoke the function to evaluate the expression.
     return DartEntry::InvokeFunction(initializer, Object::empty_array());
   } else {
     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* 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 12 matching lines @@
       }
     }
 
     // Create a dummy function object for the code generator.
     // The function needs to be associated with a named Class: the interface
     // Function fits the bill.
     const char* kEvalConst = "eval_const";
     const Function& func = Function::ZoneHandle(Function::New(
         String::Handle(Symbols::New(thread, kEvalConst)),
         RawFunction::kRegularFunction,
-        true,  // static function
+        true,   // static function
         false,  // not const function
         false,  // not abstract
         false,  // not external
         false,  // not native
         Class::Handle(Type::Handle(Type::DartFunctionType()).type_class()),
         fragment->token_pos()));
 
     func.set_result_type(Object::dynamic_type());
     func.set_num_fixed_parameters(0);
     func.SetNumOptionalParameters(0, true);
     // Manually generated AST, do not recompile.
     func.SetIsOptimizable(false);
     func.set_is_debuggable(false);
 
     // We compile the function here, even though InvokeFunction() below
     // would compile func automatically. We are checking fewer invariants
     // here.
     ParsedFunction* parsed_function = new ParsedFunction(thread, func);
     parsed_function->SetNodeSequence(fragment);
     fragment->scope()->AddVariable(parsed_function->EnsureExpressionTemp());
-    fragment->scope()->AddVariable(
-        parsed_function->current_context_var());
+    fragment->scope()->AddVariable(parsed_function->current_context_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
     DartCompilationPipeline pipeline;
     CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
     helper.Compile(&pipeline);
-    Code::Handle(func.unoptimized_code()).set_var_descriptors(
-        Object::empty_var_descriptors());
+    Code::Handle(func.unoptimized_code())
+        .set_var_descriptors(Object::empty_var_descriptors());
 
     const Object& result = PassiveObject::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
     return result.raw();
   } 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 Compiler::AbortBackgroundCompilation(intptr_t deopt_id, const char* msg) {
   if (FLAG_trace_compiler) {
     THR_Print("ABORT background compilation: %s\n", msg);
   }
-NOT_IN_PRODUCT(
+#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();
   }
-)  // !PRODUCT
+#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()) {
-  }
+      : next_(NULL), function_(function.raw()) {}
 
   virtual ~QueueElement() {
     next_ = NULL;
     function_ = Function::null();
   }
 
   RawFunction* Function() const { return function_; }
 
 
   void set_next(QueueElement* elem) { next_ = elem; }
@@ skipping 10 matching lines @@
 
   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();
-  }
+  virtual ~BackgroundCompilationQueue() { Clear(); }
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     ASSERT(visitor != NULL);
     QueueElement* p = first_;
     while (p != NULL) {
       visitor->VisitPointer(p->function_ptr());
       p = p->next();
     }
   }
 
   bool IsEmpty() const { return first_ == NULL; }
 
   void Add(QueueElement* value) {
     ASSERT(value != NULL);
     ASSERT(value->next() == NULL);
     if (first_ == NULL) {
       first_ = value;
       ASSERT(last_ == NULL);
     } else {
       ASSERT(last_ != NULL);
       last_->set_next(value);
     }
     last_ = value;
     ASSERT(first_ != NULL && last_ != NULL);
   }
 
-  QueueElement* Peek() const {
-    return first_;
-  }
+  QueueElement* Peek() const { return first_; }
 
   RawFunction* PeekFunction() const {
     QueueElement* e = Peek();
     if (e == NULL) {
       return Function::null();
     } else {
       return e->Function();
     }
   }
 
@@ skipping 28 matching lines @@
 
  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()),
+    : 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();
       HANDLESCOPE(thread);
       Function& function = Function::Handle(zone);
-      { MonitorLocker ml(queue_monitor_);
+      {
+        MonitorLocker ml(queue_monitor_);
         function = function_queue()->PeekFunction();
       }
       while (running_ && !function.IsNull() && !isolate_->IsTopLevelParsing()) {
         // Check that we have aggregated and cleared the stats.
         ASSERT(thread->compiler_stats()->IsCleared());
-        Compiler::CompileOptimizedFunction(thread,
-                                           function,
+        Compiler::CompileOptimizedFunction(thread, function,
                                            Compiler::kNoOSRDeoptId);
 #ifndef PRODUCT
         Isolate* isolate = thread->isolate();
         isolate->aggregate_compiler_stats()->Add(*thread->compiler_stats());
         thread->compiler_stats()->Clear();
 #endif  // PRODUCT
 
         QueueElement* qelem = NULL;
-        { MonitorLocker ml(queue_monitor_);
+        {
+          MonitorLocker ml(queue_monitor_);
           if (function_queue()->IsEmpty()) {
             // We are shutting down, queue was cleared.
             function = Function::null();
           } else {
             qelem = function_queue()->Remove();
             const Function& old = Function::Handle(qelem->Function());
             if ((!old.HasOptimizedCode() && old.IsOptimizable()) ||
-                 FLAG_stress_test_background_compilation) {
+                FLAG_stress_test_background_compilation) {
               if (Compiler::CanOptimizeFunction(thread, old)) {
                 QueueElement* repeat_qelem = new QueueElement(old);
                 function_queue()->Add(repeat_qelem);
               }
             }
             function = function_queue()->PeekFunction();
           }
         }
         if (qelem != NULL) {
           delete qelem;
         }
       }
     }
     Thread::ExitIsolateAsHelper();
     {
       // Wait to be notified when the work queue is not empty.
       MonitorLocker ml(queue_monitor_);
-      while ((function_queue()->IsEmpty() || isolate_->IsTopLevelParsing())
-              && running_) {
+      while ((function_queue()->IsEmpty() || isolate_->IsTopLevelParsing()) &&
+             running_) {
         ml.Wait();
       }
     }
   }  // while running
 
   {
     // Notify that the thread is done.
     MonitorLocker ml_done(done_monitor_);
     *done_ = true;
     ml_done.Notify();
@@ skipping 37 matching lines @@
   Monitor* queue_monitor = task->queue_monitor_;
   Monitor* done_monitor = task->done_monitor_;
   bool* task_done = task->done_;
   // Wake up compiler task and stop it.
   {
     MonitorLocker ml(queue_monitor);
     task->running_ = false;
     function_queue->Clear();
     // 'task' will be deleted by thread pool.
     task = NULL;
-    ml.Notify();   // Stop waiting for the queue.
+    ml.Notify();  // Stop waiting for the queue.
   }
 
   {
     MonitorLocker ml_done(done_monitor);
     while (!(*task_done)) {
       ml_done.WaitWithSafepointCheck(Thread::Current());
     }
   }
   delete task_done;
   delete done_monitor;
@@ skipping 35 matching lines @@
   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()));
+  Class& cls = Class::Handle(
+      thread->zone(), Library::LookupCoreClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
-  Error& error = Error::Handle(thread->zone(),
-      cls.EnsureIsFinalized(thread));
+  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());
@@ skipping 50 matching lines @@
   return Error::null();
 }
 
 
 RawError* Compiler::CompileClass(const Class& cls) {
   UNREACHABLE();
   return Error::null();
 }
 
 
-RawError* Compiler::CompileFunction(Thread* thread,
-                                    const Function& function) {
+RawError* Compiler::CompileFunction(Thread* thread, const Function& function) {
   UNREACHABLE();
   return Error::null();
 }
 
 
-RawError* Compiler::ParseFunction(Thread* thread,
-                                  const Function& function) {
+RawError* Compiler::ParseFunction(Thread* thread, const Function& function) {
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                           const Function& function) {
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(Thread* thread,
                                              const Function& function,
                                              intptr_t osr_id) {
   UNREACHABLE();
   return Error::null();
 }
 
 
-RawError* Compiler::CompileParsedFunction(
-    ParsedFunction* parsed_function) {
+RawError* Compiler::CompileParsedFunction(ParsedFunction* parsed_function) {
   UNREACHABLE();
   return Error::null();
 }
 
 
 void Compiler::ComputeLocalVarDescriptors(const Code& code) {
   UNREACHABLE();
 }
 
 
@@ skipping 59 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart