clang-format runtime/vm

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 12 matching lines @@
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, enable_simd_inline, true,
-    "Enable inlining of SIMD related method calls.");
-DEFINE_FLAG(bool, inline_smi_string_hashcode, true,
+DEFINE_FLAG(bool,
+            enable_simd_inline,
+            true,
+            "Enable inlining of SIMD related method calls.");
+DEFINE_FLAG(
+    bool,
+    inline_smi_string_hashcode,
+    true,
     "Inline hashcode for Smi and one-byte strings in case of megamorphic call");
-DEFINE_FLAG(int, inline_smi_string_hashcode_ratio, 50,
+DEFINE_FLAG(
+    int,
+    inline_smi_string_hashcode_ratio,
+    50,
     "Minimal hotness (0..100) of one-byte-string before inlining its hashcode");
-DEFINE_FLAG(int, min_optimization_counter_threshold, 5000,
-    "The minimum invocation count for a function.");
-DEFINE_FLAG(int, optimization_counter_scale, 2000,
-    "The scale of invocation count, by size of the function.");
+DEFINE_FLAG(int,
+            min_optimization_counter_threshold,
+            5000,
+            "The minimum invocation count for a function.");
+DEFINE_FLAG(int,
+            optimization_counter_scale,
+            2000,
+            "The scale of invocation count, by size of the function.");
 DEFINE_FLAG(bool, source_lines, false, "Emit source line as assembly comment.");
-DEFINE_FLAG(bool, trace_inlining_intervals, false,
-    "Inlining interval diagnostics");
+DEFINE_FLAG(bool,
+            trace_inlining_intervals,
+            false,
+            "Inlining interval diagnostics");
 
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(charp, deoptimize_filter);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(int, regexp_optimization_counter_threshold);
 DECLARE_FLAG(int, reoptimization_counter_threshold);
 DECLARE_FLAG(int, stacktrace_every);
 DECLARE_FLAG(charp, stacktrace_filter);
 DECLARE_FLAG(bool, trace_compiler);
@@ skipping 101 matching lines @@
     }
   }
 }
 
 
 // Returns true if OnebyteString is a frequent receiver class. We inline
 // Smi check as well, since a Smi check must be done anyway.
 // TODO(srdjan): Add check and code if Smi class is hot.
 bool FlowGraphCompiler::ShouldInlineSmiStringHashCode(const ICData& ic_data) {
   if (!FLAG_inline_smi_string_hashcode ||
-     (ic_data.target_name() != Symbols::hashCode().raw())) {
+      (ic_data.target_name() != Symbols::hashCode().raw())) {
     return false;
   }
   // Precompiled code has no ICData, optimistically inline it.
   if (ic_data.IsNull() || (ic_data.NumberOfChecks() == 0)) {
     return true;
   }
   // Check if OneByteString is hot enough.
   const ICData& ic_data_sorted =
       ICData::Handle(ic_data.AsUnaryClassChecksSortedByCount());
   ASSERT(ic_data_sorted.NumberOfChecks() > 0);
   if (ic_data_sorted.GetReceiverClassIdAt(0) == kOneByteStringCid) {
     const intptr_t total_count = ic_data_sorted.AggregateCount();
     const intptr_t ratio = (ic_data_sorted.GetCountAt(0) * 100) / total_count;
     return ratio > FLAG_inline_smi_string_hashcode_ratio;
   }
   return false;
 }
 
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     FlowGraph* flow_graph,
     const ParsedFunction& parsed_function,
     bool is_optimizing,
     const GrowableArray<const Function*>& inline_id_to_function,
     const GrowableArray<TokenPosition>& inline_id_to_token_pos,
     const GrowableArray<intptr_t>& caller_inline_id)
-      : thread_(Thread::Current()),
-        zone_(Thread::Current()->zone()),
-        assembler_(assembler),
-        parsed_function_(parsed_function),
-        flow_graph_(*flow_graph),
-        block_order_(*flow_graph->CodegenBlockOrder(is_optimizing)),
-        current_block_(NULL),
-        exception_handlers_list_(NULL),
-        pc_descriptors_list_(NULL),
-        stackmap_table_builder_(NULL),
-        code_source_map_builder_(NULL),
-        saved_code_size_(0),
-        block_info_(block_order_.length()),
-        deopt_infos_(),
-        static_calls_target_table_(),
-        is_optimizing_(is_optimizing),
-        may_reoptimize_(false),
-        intrinsic_mode_(false),
-        double_class_(Class::ZoneHandle(
-            isolate()->object_store()->double_class())),
-        mint_class_(Class::ZoneHandle(
-            isolate()->object_store()->mint_class())),
-        float32x4_class_(Class::ZoneHandle(
-            isolate()->object_store()->float32x4_class())),
-        float64x2_class_(Class::ZoneHandle(
-            isolate()->object_store()->float64x2_class())),
-        int32x4_class_(Class::ZoneHandle(
-            isolate()->object_store()->int32x4_class())),
-        list_class_(Class::ZoneHandle(
-            Library::Handle(Library::CoreLibrary()).
-                LookupClass(Symbols::List()))),
-        parallel_move_resolver_(this),
-        pending_deoptimization_env_(NULL),
-        deopt_id_to_ic_data_(NULL),
-        edge_counters_array_(Array::ZoneHandle()),
-        inlined_code_intervals_(Array::ZoneHandle(Object::empty_array().raw())),
-        inline_id_to_function_(inline_id_to_function),
-        inline_id_to_token_pos_(inline_id_to_token_pos),
-        caller_inline_id_(caller_inline_id) {
+    : thread_(Thread::Current()),
+      zone_(Thread::Current()->zone()),
+      assembler_(assembler),
+      parsed_function_(parsed_function),
+      flow_graph_(*flow_graph),
+      block_order_(*flow_graph->CodegenBlockOrder(is_optimizing)),
+      current_block_(NULL),
+      exception_handlers_list_(NULL),
+      pc_descriptors_list_(NULL),
+      stackmap_table_builder_(NULL),
+      code_source_map_builder_(NULL),
+      saved_code_size_(0),
+      block_info_(block_order_.length()),
+      deopt_infos_(),
+      static_calls_target_table_(),
+      is_optimizing_(is_optimizing),
+      may_reoptimize_(false),
+      intrinsic_mode_(false),
+      double_class_(
+          Class::ZoneHandle(isolate()->object_store()->double_class())),
+      mint_class_(Class::ZoneHandle(isolate()->object_store()->mint_class())),
+      float32x4_class_(
+          Class::ZoneHandle(isolate()->object_store()->float32x4_class())),
+      float64x2_class_(
+          Class::ZoneHandle(isolate()->object_store()->float64x2_class())),
+      int32x4_class_(
+          Class::ZoneHandle(isolate()->object_store()->int32x4_class())),
+      list_class_(Class::ZoneHandle(Library::Handle(Library::CoreLibrary())
+                                        .LookupClass(Symbols::List()))),
+      parallel_move_resolver_(this),
+      pending_deoptimization_env_(NULL),
+      deopt_id_to_ic_data_(NULL),
+      edge_counters_array_(Array::ZoneHandle()),
+      inlined_code_intervals_(Array::ZoneHandle(Object::empty_array().raw())),
+      inline_id_to_function_(inline_id_to_function),
+      inline_id_to_token_pos_(inline_id_to_token_pos),
+      caller_inline_id_(caller_inline_id) {
   ASSERT(flow_graph->parsed_function().function().raw() ==
          parsed_function.function().raw());
   if (!is_optimizing) {
     const intptr_t len = thread()->deopt_id();
-    deopt_id_to_ic_data_ = new(zone()) ZoneGrowableArray<const ICData*>(len);
+    deopt_id_to_ic_data_ = new (zone()) ZoneGrowableArray<const ICData*>(len);
     deopt_id_to_ic_data_->SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
       (*deopt_id_to_ic_data_)[i] = NULL;
     }
     // TODO(fschneider): Abstract iteration into ICDataArrayIterator.
-    const Array& old_saved_ic_data = Array::Handle(zone(),
-        flow_graph->function().ic_data_array());
+    const Array& old_saved_ic_data =
+        Array::Handle(zone(), flow_graph->function().ic_data_array());
     const intptr_t saved_len =
         old_saved_ic_data.IsNull() ? 0 : old_saved_ic_data.Length();
     for (intptr_t i = 1; i < saved_len; i++) {
       ICData& ic_data = ICData::ZoneHandle(zone());
       ic_data ^= old_saved_ic_data.At(i);
       (*deopt_id_to_ic_data_)[ic_data.deopt_id()] = &ic_data;
     }
   }
   ASSERT(assembler != NULL);
   ASSERT(!list_class_.IsNull());
 }
 
 
 bool FlowGraphCompiler::IsUnboxedField(const Field& field) {
-  bool valid_class = (SupportsUnboxedDoubles() &&
-                      (field.guarded_cid() == kDoubleCid)) ||
-                     (SupportsUnboxedSimd128() &&
-                      (field.guarded_cid() == kFloat32x4Cid)) ||
-                     (SupportsUnboxedSimd128() &&
-                      (field.guarded_cid() == kFloat64x2Cid));
-  return field.is_unboxing_candidate()
-      && !field.is_final()
-      && !field.is_nullable()
-      && valid_class;
+  bool valid_class =
+      (SupportsUnboxedDoubles() && (field.guarded_cid() == kDoubleCid)) ||
+      (SupportsUnboxedSimd128() && (field.guarded_cid() == kFloat32x4Cid)) ||
+      (SupportsUnboxedSimd128() && (field.guarded_cid() == kFloat64x2Cid));
+  return field.is_unboxing_candidate() && !field.is_final() &&
+         !field.is_nullable() && valid_class;
 }
 
 
 bool FlowGraphCompiler::IsPotentialUnboxedField(const Field& field) {
   return field.is_unboxing_candidate() &&
          (FlowGraphCompiler::IsUnboxedField(field) ||
           (!field.is_final() && (field.guarded_cid() == kIllegalCid)));
 }
 
 
 void FlowGraphCompiler::InitCompiler() {
-  pc_descriptors_list_ = new(zone()) DescriptorList(64);
-  exception_handlers_list_ = new(zone()) ExceptionHandlerList();
+  pc_descriptors_list_ = new (zone()) DescriptorList(64);
+  exception_handlers_list_ = new (zone()) ExceptionHandlerList();
   block_info_.Clear();
   // Conservative detection of leaf routines used to remove the stack check
   // on function entry.
   bool is_leaf = is_optimizing() && !flow_graph().IsCompiledForOsr();
   // Initialize block info and search optimized (non-OSR) code for calls
   // indicating a non-leaf routine and calls without IC data indicating
   // possible reoptimization.
   for (int i = 0; i < block_order_.length(); ++i) {
-    block_info_.Add(new(zone()) BlockInfo());
+    block_info_.Add(new (zone()) BlockInfo());
     if (is_optimizing() && !flow_graph().IsCompiledForOsr()) {
       BlockEntryInstr* entry = block_order_[i];
       for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
         Instruction* current = it.Current();
         if (current->IsBranch()) {
           current = current->AsBranch()->comparison();
         }
         // In optimized code, ICData is always set in the instructions.
         const ICData* ic_data = NULL;
         if (current->IsInstanceCall()) {
           ic_data = current->AsInstanceCall()->ic_data();
         }
         if ((ic_data != NULL) && (ic_data->NumberOfUsedChecks() == 0)) {
           may_reoptimize_ = true;
         }
-        if (is_leaf &&
-            !current->IsCheckStackOverflow() &&
+        if (is_leaf && !current->IsCheckStackOverflow() &&
             !current->IsParallelMove()) {
           // Note that we do not care if the code contains instructions that
           // can deoptimize.
           LocationSummary* locs = current->locs();
           if ((locs != NULL) && locs->can_call()) {
             is_leaf = false;
           }
         }
       }
     }
@@ skipping 26 matching lines @@
   return CanOptimize() && !parsed_function().function().HasBreakpoint();
 }
 
 
 bool FlowGraphCompiler::CanOSRFunction() const {
   return FLAG_use_osr & CanOptimizeFunction() && !is_optimizing();
 }
 
 
 bool FlowGraphCompiler::ForceSlowPathForStackOverflow() const {
-  if ((FLAG_stacktrace_every > 0) ||
-      (FLAG_deoptimize_every > 0) ||
+  if ((FLAG_stacktrace_every > 0) || (FLAG_deoptimize_every > 0) ||
       (isolate()->reload_every_n_stack_overflow_checks() > 0)) {
     return true;
   }
   if (FLAG_stacktrace_filter != NULL &&
       strstr(parsed_function().function().ToFullyQualifiedCString(),
              FLAG_stacktrace_filter) != NULL) {
     return true;
   }
-  if (is_optimizing() &&
-      FLAG_deoptimize_filter != NULL &&
+  if (is_optimizing() && FLAG_deoptimize_filter != NULL &&
       strstr(parsed_function().function().ToFullyQualifiedCString(),
              FLAG_deoptimize_filter) != NULL) {
     return true;
   }
   return false;
 }
 
 
 static bool IsEmptyBlock(BlockEntryInstr* block) {
-  return !block->IsCatchBlockEntry() &&
-         !block->HasNonRedundantParallelMove() &&
+  return !block->IsCatchBlockEntry() && !block->HasNonRedundantParallelMove() &&
          block->next()->IsGoto() &&
          !block->next()->AsGoto()->HasNonRedundantParallelMove() &&
          !block->IsIndirectEntry();
 }
 
 
 void FlowGraphCompiler::CompactBlock(BlockEntryInstr* block) {
   BlockInfo* block_info = block_info_[block->postorder_number()];
 
   // Break out of cycles in the control flow graph.
@@ skipping 40 matching lines @@
   block_info->set_next_nonempty_label(nonempty_label);
 }
 
 
 void FlowGraphCompiler::EmitInstructionPrologue(Instruction* instr) {
   if (!is_optimizing()) {
     if (instr->CanBecomeDeoptimizationTarget() && !instr->IsGoto()) {
       // Instructions that can be deoptimization targets need to record kDeopt
       // PcDescriptor corresponding to their deopt id. GotoInstr records its
       // own so that it can control the placement.
-      AddCurrentDescriptor(RawPcDescriptors::kDeopt,
-                           instr->deopt_id(),
+      AddCurrentDescriptor(RawPcDescriptors::kDeopt, instr->deopt_id(),
                            instr->token_pos());
     }
     AllocateRegistersLocally(instr);
-  } else if (instr->MayThrow()  &&
+  } else if (instr->MayThrow() &&
              (CurrentTryIndex() != CatchClauseNode::kInvalidTryIndex)) {
     // Optimized try-block: Sync locals to fixed stack locations.
     EmitTrySync(instr, CurrentTryIndex());
   }
 }
 
 
-
 void FlowGraphCompiler::EmitSourceLine(Instruction* instr) {
   if (!instr->token_pos().IsReal() || (instr->env() == NULL)) {
     return;
   }
   const Script& script =
       Script::Handle(zone(), instr->env()->function().script());
   intptr_t line_nr;
   intptr_t column_nr;
   script.GetTokenLocation(instr->token_pos(), &line_nr, &column_nr);
   const String& line = String::Handle(zone(), script.GetLine(line_nr));
-  assembler()->Comment("Line %" Pd " in '%s':\n           %s",
-      line_nr,
-      instr->env()->function().ToFullyQualifiedCString(),
-      line.ToCString());
+  assembler()->Comment("Line %" Pd " in '%s':\n           %s", line_nr,
+                       instr->env()->function().ToFullyQualifiedCString(),
+                       line.ToCString());
 }
 
 
 static void LoopInfoComment(
     Assembler* assembler,
     const BlockEntryInstr& block,
     const ZoneGrowableArray<BlockEntryInstr*>& loop_headers) {
   if (Assembler::EmittingComments()) {
     for (intptr_t loop_id = 0; loop_id < loop_headers.length(); ++loop_id) {
       for (BitVector::Iterator loop_it(loop_headers[loop_id]->loop_info());
-           !loop_it.Done();
-           loop_it.Advance()) {
+           !loop_it.Done(); loop_it.Advance()) {
         if (loop_it.Current() == block.preorder_number()) {
-           assembler->Comment("  Loop %" Pd "", loop_id);
+          assembler->Comment("  Loop %" Pd "", loop_id);
         }
       }
     }
   }
 }
 
 
 // We collect intervals while generating code.
 struct IntervalStruct {
   // 'start' is the pc-offsets where the inlined code started.
   // 'pos' is the token position where the inlined call occured.
   intptr_t start;
   TokenPosition pos;
   intptr_t inlining_id;
   IntervalStruct(intptr_t s, TokenPosition tp, intptr_t id)
       : start(s), pos(tp), inlining_id(id) {}
   void Dump() {
-    THR_Print("start: 0x%" Px " iid: %" Pd " pos: %s",
-              start, inlining_id, pos.ToCString());
+    THR_Print("start: 0x%" Px " iid: %" Pd " pos: %s", start, inlining_id,
+              pos.ToCString());
   }
 };
 
 
 void FlowGraphCompiler::VisitBlocks() {
   CompactBlocks();
   const ZoneGrowableArray<BlockEntryInstr*>* loop_headers = NULL;
   if (Assembler::EmittingComments()) {
     // 'loop_headers' were cleared, recompute.
     loop_headers = flow_graph().ComputeLoops();
@@ skipping 46 matching lines @@
           } else {
             // We will add this token position later when generating the
             // profile.
             prev_inlining_pos = TokenPosition::kNoSource;
           }
           if (prev_inlining_id > max_inlining_id) {
             max_inlining_id = prev_inlining_id;
           }
         }
       }
-      if (FLAG_code_comments ||
-          FLAG_disassemble || FLAG_disassemble_optimized) {
+      if (FLAG_code_comments || FLAG_disassemble ||
+          FLAG_disassemble_optimized) {
         if (FLAG_source_lines) {
           EmitSourceLine(instr);
         }
         EmitComment(instr);
       }
       if (instr->IsParallelMove()) {
         parallel_move_resolver_.EmitNativeCode(instr->AsParallelMove());
       } else {
         BeginCodeSourceRange();
         EmitInstructionPrologue(instr);
@@ skipping 25 matching lines @@
         Array::New(intervals.length() * Code::kInlIntNumEntries, Heap::kOld);
     Smi& start_h = Smi::Handle();
     Smi& caller_inline_id = Smi::Handle();
     Smi& inline_id = Smi::Handle();
     for (intptr_t i = 0; i < intervals.length(); i++) {
       if (FLAG_trace_inlining_intervals && is_optimizing()) {
         const Function& function =
             *inline_id_to_function_.At(intervals[i].inlining_id);
         intervals[i].Dump();
         THR_Print(" parent iid %" Pd " %s\n",
-            caller_inline_id_[intervals[i].inlining_id],
-            function.ToQualifiedCString());
+                  caller_inline_id_[intervals[i].inlining_id],
+                  function.ToQualifiedCString());
       }
 
       const intptr_t id = intervals[i].inlining_id;
       start_h = Smi::New(intervals[i].start);
       inline_id = Smi::New(id);
       caller_inline_id = Smi::New(caller_inline_id_[intervals[i].inlining_id]);
 
       const intptr_t p = i * Code::kInlIntNumEntries;
       inlined_code_intervals_.SetAt(p + Code::kInlIntStart, start_h);
       inlined_code_intervals_.SetAt(p + Code::kInlIntInliningId, inline_id);
     }
   }
   set_current_block(NULL);
   if (FLAG_trace_inlining_intervals && is_optimizing()) {
     LogBlock lb;
     THR_Print("Intervals:\n");
     for (intptr_t cc = 0; cc < caller_inline_id_.length(); cc++) {
-      THR_Print("  iid: %" Pd " caller iid: %" Pd "\n",
-          cc, caller_inline_id_[cc]);
+      THR_Print("  iid: %" Pd " caller iid: %" Pd "\n", cc,
+                caller_inline_id_[cc]);
     }
     Smi& temp = Smi::Handle();
     for (intptr_t i = 0; i < inlined_code_intervals_.Length();
          i += Code::kInlIntNumEntries) {
       temp ^= inlined_code_intervals_.At(i + Code::kInlIntStart);
       ASSERT(!temp.IsNull());
       THR_Print("% " Pd " start: 0x%" Px " ", i, temp.Value());
       temp ^= inlined_code_intervals_.At(i + Code::kInlIntInliningId);
       THR_Print("iid: %" Pd " ", temp.Value());
     }
@@ skipping 14 matching lines @@
   const GrowableArray<Definition*>* idefs = catch_block->initial_definitions();
 
   // Construct a ParallelMove instruction for parameters and locals. Skip the
   // special locals exception_var and stacktrace_var since they will be filled
   // when an exception is thrown. Constant locations are known to be the same
   // at all instructions that may throw, and do not need to be materialized.
 
   // Parameters first.
   intptr_t i = 0;
   const intptr_t num_non_copied_params = flow_graph().num_non_copied_params();
-  ParallelMoveInstr* move_instr = new(zone()) ParallelMoveInstr();
+  ParallelMoveInstr* move_instr = new (zone()) ParallelMoveInstr();
   for (; i < num_non_copied_params; ++i) {
     // Don't sync captured parameters. They are not in the environment.
     if (flow_graph().captured_parameters()->Contains(i)) continue;
     if ((*idefs)[i]->IsConstant()) continue;  // Common constants
     Location src = env->LocationAt(i);
 #if defined(TARGET_ARCH_DBC)
     intptr_t dest_index = kNumberOfCpuRegisters - 1 - i;
     Location dest = Location::RegisterLocation(dest_index);
     // Update safepoint bitmap to indicate that the target location
     // now contains a pointer. With DBC parameters are copied into
@@ skipping 32 matching lines @@
   }
   parallel_move_resolver()->EmitNativeCode(move_instr);
 }
 
 
 intptr_t FlowGraphCompiler::StackSize() const {
   if (is_optimizing_) {
     return flow_graph_.graph_entry()->spill_slot_count();
   } else {
     return parsed_function_.num_stack_locals() +
-        parsed_function_.num_copied_params();
+           parsed_function_.num_copied_params();
   }
 }
 
 
-Label* FlowGraphCompiler::GetJumpLabel(
-    BlockEntryInstr* block_entry) const {
+Label* FlowGraphCompiler::GetJumpLabel(BlockEntryInstr* block_entry) const {
   const intptr_t block_index = block_entry->postorder_number();
   return block_info_[block_index]->jump_label();
 }
 
 
-bool FlowGraphCompiler::WasCompacted(
-    BlockEntryInstr* block_entry) const {
+bool FlowGraphCompiler::WasCompacted(BlockEntryInstr* block_entry) const {
   const intptr_t block_index = block_entry->postorder_number();
   return block_info_[block_index]->WasCompacted();
 }
 
 
 Label* FlowGraphCompiler::NextNonEmptyLabel() const {
   const intptr_t current_index = current_block()->postorder_number();
   return block_info_[current_index]->next_nonempty_label();
 }
 
 
 bool FlowGraphCompiler::CanFallThroughTo(BlockEntryInstr* block_entry) const {
   return NextNonEmptyLabel() == GetJumpLabel(block_entry);
 }
 
 
 BranchLabels FlowGraphCompiler::CreateBranchLabels(BranchInstr* branch) const {
   Label* true_label = GetJumpLabel(branch->true_successor());
   Label* false_label = GetJumpLabel(branch->false_successor());
   Label* fall_through = NextNonEmptyLabel();
-  BranchLabels result = { true_label, false_label, fall_through };
+  BranchLabels result = {true_label, false_label, fall_through};
   return result;
 }
 
 
 void FlowGraphCompiler::AddSlowPathCode(SlowPathCode* code) {
   slow_path_code_.Add(code);
 }
 
 
 void FlowGraphCompiler::GenerateDeferredCode() {
   for (intptr_t i = 0; i < slow_path_code_.length(); i++) {
     BeginCodeSourceRange();
     slow_path_code_[i]->GenerateCode(this);
     EndCodeSourceRange(TokenPosition::kDeferredSlowPath);
   }
   for (intptr_t i = 0; i < deopt_infos_.length(); i++) {
     BeginCodeSourceRange();
     deopt_infos_[i]->GenerateCode(this, i);
     EndCodeSourceRange(TokenPosition::kDeferredDeoptInfo);
   }
 }
 
 
 void FlowGraphCompiler::AddExceptionHandler(intptr_t try_index,
                                             intptr_t outer_try_index,
                                             intptr_t pc_offset,
                                             const Array& handler_types,
                                             bool needs_stacktrace) {
-  exception_handlers_list_->AddHandler(try_index,
-                                       outer_try_index,
-                                       pc_offset,
-                                       handler_types,
-                                       needs_stacktrace);
+  exception_handlers_list_->AddHandler(try_index, outer_try_index, pc_offset,
+                                       handler_types, needs_stacktrace);
 }
 
 
 void FlowGraphCompiler::SetNeedsStacktrace(intptr_t try_index) {
   exception_handlers_list_->SetNeedsStacktrace(try_index);
 }
 
 
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(RawPcDescriptors::Kind kind,
                                              intptr_t deopt_id,
                                              TokenPosition token_pos) {
   // When running with optimizations disabled, don't emit deopt-descriptors.
   if (!CanOptimize() && (kind == RawPcDescriptors::kDeopt)) return;
-  pc_descriptors_list()->AddDescriptor(kind,
-                                       assembler()->CodeSize(),
-                                       deopt_id,
-                                       token_pos,
-                                       CurrentTryIndex());
+  pc_descriptors_list()->AddDescriptor(kind, assembler()->CodeSize(), deopt_id,
+                                       token_pos, CurrentTryIndex());
 }
 
 
 void FlowGraphCompiler::AddStaticCallTarget(const Function& func) {
   ASSERT(func.IsZoneHandle());
   static_calls_target_table_.Add(
-      new(zone()) StaticCallsStruct(assembler()->CodeSize(), &func, NULL));
+      new (zone()) StaticCallsStruct(assembler()->CodeSize(), &func, NULL));
 }
 
 
 void FlowGraphCompiler::AddStubCallTarget(const Code& code) {
   ASSERT(code.IsZoneHandle());
   static_calls_target_table_.Add(
-      new(zone()) StaticCallsStruct(assembler()->CodeSize(), NULL, &code));
+      new (zone()) StaticCallsStruct(assembler()->CodeSize(), NULL, &code));
 }
 
 
 void FlowGraphCompiler::AddDeoptIndexAtCall(intptr_t deopt_id) {
   ASSERT(is_optimizing());
   ASSERT(!intrinsic_mode());
   CompilerDeoptInfo* info =
-      new(zone()) CompilerDeoptInfo(deopt_id,
-                                    ICData::kDeoptAtCall,
-                                    0,  // No flags.
-                                    pending_deoptimization_env_);
+      new (zone()) CompilerDeoptInfo(deopt_id, ICData::kDeoptAtCall,
+                                     0,  // No flags.
+                                     pending_deoptimization_env_);
   info->set_pc_offset(assembler()->CodeSize());
   deopt_infos_.Add(info);
 }
 
 
 // This function must be in sync with FlowGraphCompiler::SaveLiveRegisters
 // and FlowGraphCompiler::SlowPathEnvironmentFor.
 // See StackFrame::VisitObjectPointers for the details of how stack map is
 // interpreted.
 void FlowGraphCompiler::RecordSafepoint(LocationSummary* locs,
                                         intptr_t slow_path_argument_count) {
   if (is_optimizing() || locs->live_registers()->HasUntaggedValues()) {
-    const intptr_t spill_area_size = is_optimizing() ?
-        flow_graph_.graph_entry()->spill_slot_count() : 0;
+    const intptr_t spill_area_size =
+        is_optimizing() ? flow_graph_.graph_entry()->spill_slot_count() : 0;
 
     RegisterSet* registers = locs->live_registers();
     ASSERT(registers != NULL);
-    const intptr_t kFpuRegisterSpillFactor =
-            kFpuRegisterSize / kWordSize;
-    const intptr_t live_registers_size = registers->CpuRegisterCount() +
+    const intptr_t kFpuRegisterSpillFactor = kFpuRegisterSize / kWordSize;
+    const intptr_t live_registers_size =
+        registers->CpuRegisterCount() +
         (registers->FpuRegisterCount() * kFpuRegisterSpillFactor);
 
     BitmapBuilder* bitmap = locs->stack_bitmap();
 
-    // An instruction may have two safepoints in deferred code. The
-    // call to RecordSafepoint has the side-effect of appending the live
-    // registers to the bitmap. This is why the second call to RecordSafepoint
-    // with the same instruction (and same location summary) sees a bitmap that
-    // is larger that StackSize(). It will never be larger than StackSize() +
-    // live_registers_size.
-    // The first safepoint will grow the bitmap to be the size of
-    // spill_area_size but the second safepoint will truncate the bitmap and
-    // append the live registers to it again. The bitmap produced by both calls
-    // will be the same.
+// An instruction may have two safepoints in deferred code. The
+// call to RecordSafepoint has the side-effect of appending the live
+// registers to the bitmap. This is why the second call to RecordSafepoint
+// with the same instruction (and same location summary) sees a bitmap that
+// is larger that StackSize(). It will never be larger than StackSize() +
+// live_registers_size.
+// The first safepoint will grow the bitmap to be the size of
+// spill_area_size but the second safepoint will truncate the bitmap and
+// append the live registers to it again. The bitmap produced by both calls
+// will be the same.
 #if !defined(TARGET_ARCH_DBC)
     ASSERT(bitmap->Length() <= (spill_area_size + live_registers_size));
     bitmap->SetLength(spill_area_size);
 #else
     if (bitmap->Length() <= (spill_area_size + live_registers_size)) {
       bitmap->SetLength(Utils::Maximum(bitmap->Length(), spill_area_size));
     }
 #endif
 
     // Mark the bits in the stack map in the same order we push registers in
@@ skipping 30 matching lines @@
     }
 
     // Arguments pushed on top of live registers in the slow path are tagged.
     for (intptr_t i = 0; i < slow_path_argument_count; ++i) {
       bitmap->Set(bitmap->Length(), true);
     }
 
     // The slow path area Outside the spill area contains are live registers
     // and pushed arguments for calls inside the slow path.
     intptr_t slow_path_bit_count = bitmap->Length() - spill_area_size;
-    stackmap_table_builder()->AddEntry(assembler()->CodeSize(),
-                                       bitmap,
+    stackmap_table_builder()->AddEntry(assembler()->CodeSize(), bitmap,
                                        slow_path_bit_count);
   }
 }
 
 
 // This function must be kept in sync with:
 //
 //     FlowGraphCompiler::RecordSafepoint
 //     FlowGraphCompiler::SaveLiveRegisters
 //     MaterializeObjectInstr::RemapRegisters
@@ skipping 34 matching lines @@
     } else {
       cpu_reg_slots[i] = -1;
     }
   }
 
   // 2. Iterate the environment and replace register locations with the
   //    corresponding spill slot locations.
   for (Environment::DeepIterator it(env); !it.Done(); it.Advance()) {
     Location loc = it.CurrentLocation();
     Value* value = it.CurrentValue();
-    it.SetCurrentLocation(loc.RemapForSlowPath(
-        value->definition(), cpu_reg_slots, fpu_reg_slots));
+    it.SetCurrentLocation(loc.RemapForSlowPath(value->definition(),
+                                               cpu_reg_slots, fpu_reg_slots));
   }
 
   return env;
 }
 
 
 Label* FlowGraphCompiler::AddDeoptStub(intptr_t deopt_id,
                                        ICData::DeoptReasonId reason,
                                        uint32_t flags) {
   if (intrinsic_mode()) {
     return &intrinsic_slow_path_label_;
   }
 
   // No deoptimization allowed when 'FLAG_precompiled_mode' is set.
   if (FLAG_precompiled_mode) {
     if (FLAG_trace_compiler) {
       THR_Print(
           "Retrying compilation %s, suppressing inlining of deopt_id:%" Pd "\n",
           parsed_function_.function().ToFullyQualifiedCString(), deopt_id);
     }
     ASSERT(deopt_id != 0);  // longjmp must return non-zero value.
     Thread::Current()->long_jump_base()->Jump(
         deopt_id, Object::speculative_inlining_error());
   }
 
   ASSERT(is_optimizing_);
-  CompilerDeoptInfoWithStub* stub =
-      new(zone()) CompilerDeoptInfoWithStub(deopt_id,
-                                            reason,
-                                            flags,
-                                            pending_deoptimization_env_);
+  CompilerDeoptInfoWithStub* stub = new (zone()) CompilerDeoptInfoWithStub(
+      deopt_id, reason, flags, pending_deoptimization_env_);
   deopt_infos_.Add(stub);
   return stub->entry_label();
 }
 
 
 #if defined(TARGET_ARCH_DBC)
 void FlowGraphCompiler::EmitDeopt(intptr_t deopt_id,
                                   ICData::DeoptReasonId reason,
                                   uint32_t flags) {
   ASSERT(is_optimizing());
   ASSERT(!intrinsic_mode());
   // The pending deoptimization environment may be changed after this deopt is
   // emitted, so we need to make a copy.
-  Environment* env_copy =
-      pending_deoptimization_env_->DeepCopy(zone());
+  Environment* env_copy = pending_deoptimization_env_->DeepCopy(zone());
   CompilerDeoptInfo* info =
-      new(zone()) CompilerDeoptInfo(deopt_id,
-                                    reason,
-                                    flags,
-                                    env_copy);
+      new (zone()) CompilerDeoptInfo(deopt_id, reason, flags, env_copy);
   deopt_infos_.Add(info);
-  assembler()->Deopt(0, /*is_eager =*/ 1);
+  assembler()->Deopt(0, /*is_eager =*/1);
   info->set_pc_offset(assembler()->CodeSize());
 }
 #endif  // defined(TARGET_ARCH_DBC)
 
 
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
   ASSERT(exception_handlers_list_ != NULL);
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.PayloadStart()));
   code.set_exception_handlers(handlers);
   if (FLAG_compiler_stats) {
     Thread* thread = Thread::Current();
     INC_STAT(thread, total_code_size,
-        ExceptionHandlers::InstanceSize(handlers.num_entries()));
+             ExceptionHandlers::InstanceSize(handlers.num_entries()));
     INC_STAT(thread, total_code_size, handlers.num_entries() * sizeof(uword));
   }
 }
 
 
 void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
   ASSERT(pc_descriptors_list_ != NULL);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       pc_descriptors_list_->FinalizePcDescriptors(code.PayloadStart()));
   if (!is_optimizing_) descriptors.Verify(parsed_function_.function());
@@ skipping 19 matching lines @@
   } else {
     const Array& array =
         Array::Handle(Array::New(deopt_info_table_size, Heap::kOld));
     Smi& offset = Smi::Handle();
     TypedData& info = TypedData::Handle();
     Smi& reason_and_flags = Smi::Handle();
     for (intptr_t i = 0; i < deopt_infos_.length(); i++) {
       offset = Smi::New(deopt_infos_[i]->pc_offset());
       info = deopt_infos_[i]->CreateDeoptInfo(this, &builder, array);
       reason_and_flags = DeoptTable::EncodeReasonAndFlags(
-          deopt_infos_[i]->reason(),
-          deopt_infos_[i]->flags());
+          deopt_infos_[i]->reason(), deopt_infos_[i]->flags());
       DeoptTable::SetEntry(array, i, offset, info, reason_and_flags);
     }
     return array.raw();
   }
 }
 
 
 void FlowGraphCompiler::FinalizeStackmaps(const Code& code) {
   if (stackmap_table_builder_ == NULL) {
     code.set_stackmaps(Object::null_array());
@@ skipping 27 matching lines @@
     info.end_pos = TokenPosition::kMinSource;
     info.set_index(parsed_function().current_context_var()->index());
     var_descs.SetVar(0, Symbols::CurrentContextVar(), &info);
   }
   code.set_var_descriptors(var_descs);
 }
 
 
 void FlowGraphCompiler::FinalizeStaticCallTargetsTable(const Code& code) {
   ASSERT(code.static_calls_target_table() == Array::null());
-  const Array& targets = Array::Handle(zone(), Array::New(
-      (static_calls_target_table_.length() * Code::kSCallTableEntryLength),
-      Heap::kOld));
+  const Array& targets =
+      Array::Handle(zone(), Array::New((static_calls_target_table_.length() *
+                                        Code::kSCallTableEntryLength),
+                                       Heap::kOld));
   Smi& smi_offset = Smi::Handle(zone());
   for (intptr_t i = 0; i < static_calls_target_table_.length(); i++) {
     const intptr_t target_ix = Code::kSCallTableEntryLength * i;
     smi_offset = Smi::New(static_calls_target_table_[i]->offset);
     targets.SetAt(target_ix + Code::kSCallTableOffsetEntry, smi_offset);
     if (static_calls_target_table_[i]->function != NULL) {
       targets.SetAt(target_ix + Code::kSCallTableFunctionEntry,
-          *static_calls_target_table_[i]->function);
+                    *static_calls_target_table_[i]->function);
     }
     if (static_calls_target_table_[i]->code != NULL) {
       targets.SetAt(target_ix + Code::kSCallTableCodeEntry,
-          *static_calls_target_table_[i]->code);
+                    *static_calls_target_table_[i]->code);
     }
   }
   code.set_static_calls_target_table(targets);
-  INC_STAT(Thread::Current(),
-           total_code_size,
+  INC_STAT(Thread::Current(), total_code_size,
            targets.Length() * sizeof(uword));
 }
 
 
 // Returns 'true' if regular code generation should be skipped.
 bool FlowGraphCompiler::TryIntrinsify() {
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
   if (FLAG_intrinsify && !isolate()->type_checks()) {
     const Class& owner = Class::Handle(parsed_function().function().Owner());
@@ skipping 42 matching lines @@
   // before any deoptimization point.
   ASSERT(!intrinsic_slow_path_label_.IsBound());
   assembler()->Bind(&intrinsic_slow_path_label_);
   return complete;
 }
 
 
 // DBC is very different from other architectures in how it performs instance
 // and static calls because it does not use stubs.
 #if !defined(TARGET_ARCH_DBC)
-void FlowGraphCompiler::GenerateInstanceCall(
-    intptr_t deopt_id,
-    TokenPosition token_pos,
-    intptr_t argument_count,
-    LocationSummary* locs,
-    const ICData& ic_data_in) {
+void FlowGraphCompiler::GenerateInstanceCall(intptr_t deopt_id,
+                                             TokenPosition token_pos,
+                                             intptr_t argument_count,
+                                             LocationSummary* locs,
+                                             const ICData& ic_data_in) {
   ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
   if (FLAG_precompiled_mode) {
     ic_data = ic_data.AsUnaryClassChecks();
-    EmitSwitchableInstanceCall(ic_data, argument_count,
-                               deopt_id, token_pos, locs);
+    EmitSwitchableInstanceCall(ic_data, argument_count, deopt_id, token_pos,
+                               locs);
     return;
   }
   ASSERT(!ic_data.IsNull());
   if (is_optimizing() && (ic_data_in.NumberOfUsedChecks() == 0)) {
     // Emit IC call that will count and thus may need reoptimization at
     // function entry.
     ASSERT(may_reoptimize() || flow_graph().IsCompiledForOsr());
     switch (ic_data.NumArgsTested()) {
       case 1:
         EmitOptimizedInstanceCall(
             *StubCode::OneArgOptimizedCheckInlineCache_entry(), ic_data,
             argument_count, deopt_id, token_pos, locs);
         return;
       case 2:
         EmitOptimizedInstanceCall(
             *StubCode::TwoArgsOptimizedCheckInlineCache_entry(), ic_data,
             argument_count, deopt_id, token_pos, locs);
         return;
       default:
         UNIMPLEMENTED();
     }
     return;
   }
 
   if (is_optimizing()) {
-    EmitMegamorphicInstanceCall(ic_data_in, argument_count,
-                                deopt_id, token_pos, locs,
-                                CatchClauseNode::kInvalidTryIndex);
+    EmitMegamorphicInstanceCall(ic_data_in, argument_count, deopt_id, token_pos,
+                                locs, CatchClauseNode::kInvalidTryIndex);
     return;
   }
 
   switch (ic_data.NumArgsTested()) {
     case 1:
-      EmitInstanceCall(
-          *StubCode::OneArgCheckInlineCache_entry(), ic_data, argument_count,
-          deopt_id, token_pos, locs);
+      EmitInstanceCall(*StubCode::OneArgCheckInlineCache_entry(), ic_data,
+                       argument_count, deopt_id, token_pos, locs);
       break;
     case 2:
-      EmitInstanceCall(
-          *StubCode::TwoArgsCheckInlineCache_entry(), ic_data, argument_count,
-          deopt_id, token_pos, locs);
+      EmitInstanceCall(*StubCode::TwoArgsCheckInlineCache_entry(), ic_data,
+                       argument_count, deopt_id, token_pos, locs);
       break;
     default:
       UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphCompiler::GenerateStaticCall(intptr_t deopt_id,
                                            TokenPosition token_pos,
                                            const Function& function,
                                            intptr_t argument_count,
                                            const Array& argument_names,
                                            LocationSummary* locs,
                                            const ICData& ic_data_in) {
   const ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
-  const Array& arguments_descriptor = Array::ZoneHandle(
-      ic_data.IsNull() ? ArgumentsDescriptor::New(argument_count,
-                                                  argument_names)
-                       : ic_data.arguments_descriptor());
+  const Array& arguments_descriptor =
+      Array::ZoneHandle(ic_data.IsNull() ? ArgumentsDescriptor::New(
+                                               argument_count, argument_names)
+                                         : ic_data.arguments_descriptor());
   if (is_optimizing()) {
-    EmitOptimizedStaticCall(function, arguments_descriptor,
-                            argument_count, deopt_id, token_pos, locs);
+    EmitOptimizedStaticCall(function, arguments_descriptor, argument_count,
+                            deopt_id, token_pos, locs);
   } else {
     ICData& call_ic_data = ICData::ZoneHandle(ic_data.raw());
     if (call_ic_data.IsNull()) {
       const intptr_t kNumArgsChecked = 0;
-      call_ic_data = GetOrAddStaticCallICData(deopt_id,
-                                              function,
-                                              arguments_descriptor,
-                                              kNumArgsChecked)->raw();
+      call_ic_data =
+          GetOrAddStaticCallICData(deopt_id, function, arguments_descriptor,
+                                   kNumArgsChecked)
+              ->raw();
     }
     EmitUnoptimizedStaticCall(argument_count, deopt_id, token_pos, locs,
                               call_ic_data);
   }
 }
 
 
 void FlowGraphCompiler::GenerateNumberTypeCheck(Register kClassIdReg,
                                                 const AbstractType& type,
                                                 Label* is_instance_lbl,
@@ skipping 51 matching lines @@
   assembler()->Comment("%s", buffer);
 #endif
 }
 
 
 #if !defined(TARGET_ARCH_DBC)
 // TODO(vegorov) enable edge-counters on DBC if we consider them beneficial.
 bool FlowGraphCompiler::NeedsEdgeCounter(TargetEntryInstr* block) {
   // Only emit an edge counter if there is not goto at the end of the block,
   // except for the entry block.
-  return (FLAG_reorder_basic_blocks
-      && (!block->last_instruction()->IsGoto()
-          || (block == flow_graph().graph_entry()->normal_entry())));
+  return (FLAG_reorder_basic_blocks &&
+          (!block->last_instruction()->IsGoto() ||
+           (block == flow_graph().graph_entry()->normal_entry())));
 }
 
 
 // Allocate a register that is not explicitly blocked.
 static Register AllocateFreeRegister(bool* blocked_registers) {
   for (intptr_t regno = 0; regno < kNumberOfCpuRegisters; regno++) {
     if (!blocked_registers[regno]) {
       blocked_registers[regno] = true;
       return static_cast<Register>(regno);
     }
   }
   UNREACHABLE();
   return kNoRegister;
 }
 #endif
 
 
 void FlowGraphCompiler::AllocateRegistersLocally(Instruction* instr) {
   ASSERT(!is_optimizing());
-  instr->InitializeLocationSummary(zone(),
-                                   false);  // Not optimizing.
+  instr->InitializeLocationSummary(zone(), false);  // Not optimizing.
 
-  // No need to allocate registers based on LocationSummary on DBC as in
-  // unoptimized mode it's a stack based bytecode just like IR itself.
+// No need to allocate registers based on LocationSummary on DBC as in
+// unoptimized mode it's a stack based bytecode just like IR itself.
 #if !defined(TARGET_ARCH_DBC)
   LocationSummary* locs = instr->locs();
 
   bool blocked_registers[kNumberOfCpuRegisters];
 
   // Block all registers globally reserved by the assembler, etc and mark
   // the rest as free.
   for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
     blocked_registers[i] = (kDartAvailableCpuRegs & (1 << i)) == 0;
   }
@@ skipping 45 matching lines @@
     if (should_pop) {
       assembler()->PopRegister(reg);
     }
   }
 
   // Allocate all unallocated temp locations.
   for (intptr_t i = 0; i < locs->temp_count(); i++) {
     Location loc = locs->temp(i);
     if (loc.IsUnallocated()) {
       ASSERT(loc.policy() == Location::kRequiresRegister);
-      loc = Location::RegisterLocation(
-        AllocateFreeRegister(blocked_registers));
+      loc = Location::RegisterLocation(AllocateFreeRegister(blocked_registers));
       locs->set_temp(i, loc);
     }
   }
 
   Location result_location = locs->out(0);
   if (result_location.IsUnallocated()) {
     switch (result_location.policy()) {
       case Location::kAny:
       case Location::kPrefersRegister:
       case Location::kRequiresRegister:
       case Location::kWritableRegister:
-        result_location = Location::RegisterLocation(
-            AllocateFreeRegister(blocked_registers));
+        result_location =
+            Location::RegisterLocation(AllocateFreeRegister(blocked_registers));
         break;
       case Location::kSameAsFirstInput:
         result_location = locs->in(0);
         break;
       case Location::kRequiresFpuRegister:
         UNREACHABLE();
         break;
     }
     locs->set_out(0, result_location);
   }
@@ skipping 166 matching lines @@
     }
   } else {
     *spilled = false;
   }
 
   return scratch;
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::ScratchFpuRegisterScope(
-    ParallelMoveResolver* resolver, FpuRegister blocked)
-    : resolver_(resolver),
-      reg_(kNoFpuRegister),
-      spilled_(false) {
+    ParallelMoveResolver* resolver,
+    FpuRegister blocked)
+    : resolver_(resolver), reg_(kNoFpuRegister), spilled_(false) {
   COMPILE_ASSERT(FpuTMP != kNoFpuRegister);
-  uword blocked_mask = ((blocked != kNoFpuRegister) ? 1 << blocked : 0)
-                     | 1 << FpuTMP;
-  reg_ = static_cast<FpuRegister>(
-      resolver_->AllocateScratchRegister(Location::kFpuRegister,
-                                         blocked_mask,
-                                         0,
-                                         kNumberOfFpuRegisters - 1,
-                                         &spilled_));
+  uword blocked_mask =
+      ((blocked != kNoFpuRegister) ? 1 << blocked : 0) | 1 << FpuTMP;
+  reg_ = static_cast<FpuRegister>(resolver_->AllocateScratchRegister(
+      Location::kFpuRegister, blocked_mask, 0, kNumberOfFpuRegisters - 1,
+      &spilled_));
 
   if (spilled_) {
     resolver->SpillFpuScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::~ScratchFpuRegisterScope() {
   if (spilled_) {
     resolver_->RestoreFpuScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchRegisterScope::ScratchRegisterScope(
-    ParallelMoveResolver* resolver, Register blocked)
-    : resolver_(resolver),
-      reg_(kNoRegister),
-      spilled_(false) {
+    ParallelMoveResolver* resolver,
+    Register blocked)
+    : resolver_(resolver), reg_(kNoRegister), spilled_(false) {
   uword blocked_mask = RegMaskBit(blocked) | kReservedCpuRegisters;
   if (resolver->compiler_->intrinsic_mode()) {
     // Block additional registers that must be preserved for intrinsics.
     blocked_mask |= RegMaskBit(ARGS_DESC_REG);
 #if !defined(TARGET_ARCH_IA32)
     // Need to preserve CODE_REG to be able to store the PC marker
     // and load the pool pointer.
     blocked_mask |= RegMaskBit(CODE_REG);
 #endif
   }
   reg_ = static_cast<Register>(
-      resolver_->AllocateScratchRegister(Location::kRegister,
-                                         blocked_mask,
-                                         0,
-                                         kNumberOfCpuRegisters - 1,
-                                         &spilled_));
+      resolver_->AllocateScratchRegister(Location::kRegister, blocked_mask, 0,
+                                         kNumberOfCpuRegisters - 1, &spilled_));
 
   if (spilled_) {
     resolver->SpillScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchRegisterScope::~ScratchRegisterScope() {
   if (spilled_) {
     resolver_->RestoreScratch(reg_);
@@ skipping 34 matching lines @@
     intptr_t num_args_tested) {
   if ((deopt_id_to_ic_data_ != NULL) &&
       ((*deopt_id_to_ic_data_)[deopt_id] != NULL)) {
     const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
     ASSERT(res->deopt_id() == deopt_id);
     ASSERT(res->target_name() == target_name.raw());
     ASSERT(res->NumArgsTested() == num_args_tested);
     ASSERT(!res->is_static_call());
     return res;
   }
-  const ICData& ic_data = ICData::ZoneHandle(zone(), ICData::New(
-      parsed_function().function(), target_name,
-      arguments_descriptor, deopt_id, num_args_tested, false));
+  const ICData& ic_data =
+      ICData::ZoneHandle(zone(), ICData::New(parsed_function().function(),
+                                             target_name, arguments_descriptor,
+                                             deopt_id, num_args_tested, false));
 #if defined(TAG_IC_DATA)
   ic_data.set_tag(Instruction::kInstanceCall);
 #endif
   if (deopt_id_to_ic_data_ != NULL) {
     (*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
   }
   ASSERT(!ic_data.is_static_call());
   return &ic_data;
 }
 
 
 const ICData* FlowGraphCompiler::GetOrAddStaticCallICData(
     intptr_t deopt_id,
     const Function& target,
     const Array& arguments_descriptor,
     intptr_t num_args_tested) {
   if ((deopt_id_to_ic_data_ != NULL) &&
       ((*deopt_id_to_ic_data_)[deopt_id] != NULL)) {
     const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
     ASSERT(res->deopt_id() == deopt_id);
     ASSERT(res->target_name() == target.name());
     ASSERT(res->NumArgsTested() == num_args_tested);
     ASSERT(res->is_static_call());
     return res;
   }
-  const ICData& ic_data = ICData::ZoneHandle(zone(), ICData::New(
-      parsed_function().function(), String::Handle(zone(), target.name()),
-      arguments_descriptor, deopt_id, num_args_tested, true));
+  const ICData& ic_data = ICData::ZoneHandle(
+      zone(),
+      ICData::New(parsed_function().function(),
+                  String::Handle(zone(), target.name()), arguments_descriptor,
+                  deopt_id, num_args_tested, true));
   ic_data.AddTarget(target);
 #if defined(TAG_IC_DATA)
   ic_data.set_tag(Instruction::kStaticCall);
 #endif
   if (deopt_id_to_ic_data_ != NULL) {
     (*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
   }
   return &ic_data;
 }
 
 
 intptr_t FlowGraphCompiler::GetOptimizationThreshold() const {
   intptr_t threshold;
   if (is_optimizing()) {
     threshold = FLAG_reoptimization_counter_threshold;
   } else if (parsed_function_.function().IsIrregexpFunction()) {
     threshold = FLAG_regexp_optimization_counter_threshold;
   } else {
     const intptr_t basic_blocks = flow_graph().preorder().length();
     ASSERT(basic_blocks > 0);
     threshold = FLAG_optimization_counter_scale * basic_blocks +
-        FLAG_min_optimization_counter_threshold;
+                FLAG_min_optimization_counter_threshold;
     if (threshold > FLAG_optimization_counter_threshold) {
       threshold = FLAG_optimization_counter_threshold;
     }
   }
   return threshold;
 }
 
 
 const Class& FlowGraphCompiler::BoxClassFor(Representation rep) {
   switch (rep) {
@@ skipping 11 matching lines @@
       UNREACHABLE();
       return Class::ZoneHandle();
   }
 }
 
 
 RawArray* FlowGraphCompiler::InliningIdToFunction() const {
   if (inline_id_to_function_.length() == 0) {
     return Object::empty_array().raw();
   }
-  const Array& res = Array::Handle(
-      Array::New(inline_id_to_function_.length(), Heap::kOld));
+  const Array& res =
+      Array::Handle(Array::New(inline_id_to_function_.length(), Heap::kOld));
   for (intptr_t i = 0; i < inline_id_to_function_.length(); i++) {
     res.SetAt(i, *inline_id_to_function_[i]);
   }
   return res.raw();
 }
 
 
 RawArray* FlowGraphCompiler::InliningIdToTokenPos() const {
   if (inline_id_to_token_pos_.length() == 0) {
     return Object::empty_array().raw();
   }
-  const Array& res = Array::Handle(zone(),
-      Array::New(inline_id_to_token_pos_.length(), Heap::kOld));
+  const Array& res = Array::Handle(
+      zone(), Array::New(inline_id_to_token_pos_.length(), Heap::kOld));
   Smi& smi = Smi::Handle(zone());
   for (intptr_t i = 0; i < inline_id_to_token_pos_.length(); i++) {
     smi = Smi::New(inline_id_to_token_pos_[i].value());
     res.SetAt(i, smi);
   }
   return res.raw();
 }
 
 
 RawArray* FlowGraphCompiler::CallerInliningIdMap() const {
   if (caller_inline_id_.length() == 0) {
     return Object::empty_array().raw();
   }
-  const Array& res = Array::Handle(
-      Array::New(caller_inline_id_.length(), Heap::kOld));
+  const Array& res =
+      Array::Handle(Array::New(caller_inline_id_.length(), Heap::kOld));
   Smi& smi = Smi::Handle();
   for (intptr_t i = 0; i < caller_inline_id_.length(); i++) {
     smi = Smi::New(caller_inline_id_[i]);
     res.SetAt(i, smi);
   }
   return res.raw();
 }
 
 
 void FlowGraphCompiler::BeginCodeSourceRange() {
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   // Remember how many bytes of code we emitted so far. This function
   // is called before we call into an instruction's EmitNativeCode.
   saved_code_size_ = assembler()->CodeSize();
-);
+#endif  // !defined(PRODUCT)
 }
 
 
 bool FlowGraphCompiler::EndCodeSourceRange(TokenPosition token_pos) {
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   // This function is called after each instructions' EmitNativeCode.
   if (saved_code_size_ < assembler()->CodeSize()) {
     // We emitted more code, now associate the emitted code chunk with
     // |token_pos|.
     code_source_map_builder()->AddEntry(saved_code_size_, token_pos);
     BeginCodeSourceRange();
     return true;
   }
-);
+#endif  // !defined(PRODUCT)
   return false;
 }
 
 
 #if !defined(TARGET_ARCH_DBC)
 // DBC emits calls very differently from other architectures due to its
 // interpreted nature.
-void FlowGraphCompiler::EmitPolymorphicInstanceCall(
-    const ICData& ic_data,
-    intptr_t argument_count,
-    const Array& argument_names,
-    intptr_t deopt_id,
-    TokenPosition token_pos,
-    LocationSummary* locs,
-    bool complete) {
+void FlowGraphCompiler::EmitPolymorphicInstanceCall(const ICData& ic_data,
+                                                    intptr_t argument_count,
+                                                    const Array& argument_names,
+                                                    intptr_t deopt_id,
+                                                    TokenPosition token_pos,
+                                                    LocationSummary* locs,
+                                                    bool complete) {
   if (FLAG_polymorphic_with_deopt) {
-    Label* deopt = AddDeoptStub(deopt_id,
-                                ICData::kDeoptPolymorphicInstanceCallTestFail);
+    Label* deopt =
+        AddDeoptStub(deopt_id, ICData::kDeoptPolymorphicInstanceCallTestFail);
     Label ok;
     EmitTestAndCall(ic_data, argument_count, argument_names,
                     deopt,  // No cid match.
                     &ok,    // Found cid.
                     deopt_id, token_pos, locs, complete);
     assembler()->Bind(&ok);
   } else {
     if (complete) {
       Label ok;
       EmitTestAndCall(ic_data, argument_count, argument_names,
-                      NULL,                      // No cid match.
-                      &ok,                       // Found cid.
+                      NULL,  // No cid match.
+                      &ok,   // Found cid.
                       deopt_id, token_pos, locs, true);
       assembler()->Bind(&ok);
     } else {
-      EmitSwitchableInstanceCall(ic_data, argument_count,
-                                 deopt_id, token_pos, locs);
+      EmitSwitchableInstanceCall(ic_data, argument_count, deopt_id, token_pos,
+                                 locs);
     }
   }
 }
 #endif
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 // TODO(vegorov) re-enable frame state tracking on DBC. It is
 // currently disabled because it relies on LocationSummaries and
 // we don't use them during unoptimized compilation on DBC.
 void FlowGraphCompiler::FrameStateUpdateWith(Instruction* instr) {
   ASSERT(!is_optimizing());
 
   switch (instr->tag()) {
     case Instruction::kPushArgument:
       // Do nothing.
       break;
 
     case Instruction::kDropTemps:
       FrameStatePop(instr->locs()->input_count() +
-          instr->AsDropTemps()->num_temps());
+                    instr->AsDropTemps()->num_temps());
       break;
 
     default:
       FrameStatePop(instr->locs()->input_count());
       break;
   }
 
   ASSERT(!instr->locs()->can_call() || FrameStateIsSafeToCall());
 
   FrameStatePop(instr->ArgumentCount());
   Definition* defn = instr->AsDefinition();
   if ((defn != NULL) && defn->HasTemp()) {
     FrameStatePush(defn);
   }
 }
 
 
 void FlowGraphCompiler::FrameStatePush(Definition* defn) {
   Representation rep = defn->representation();
-  if ((rep == kUnboxedDouble) ||
-      (rep == kUnboxedFloat64x2) ||
+  if ((rep == kUnboxedDouble) || (rep == kUnboxedFloat64x2) ||
       (rep == kUnboxedFloat32x4)) {
     // LoadField instruction lies about its representation in the unoptimized
     // code because Definition::representation() can't depend on the type of
     // compilation but MakeLocationSummary and EmitNativeCode can.
     ASSERT(defn->IsLoadField() && defn->AsLoadField()->IsUnboxedLoad());
     ASSERT(defn->locs()->out(0).IsRegister());
     rep = kTagged;
   }
   ASSERT(!is_optimizing());
   ASSERT((rep == kTagged) || (rep == kUntagged));
   ASSERT(rep != kUntagged || flow_graph_.IsIrregexpFunction());
   frame_state_.Add(rep);
 }
 
 
 void FlowGraphCompiler::FrameStatePop(intptr_t count) {
   ASSERT(!is_optimizing());
-  frame_state_.TruncateTo(Utils::Maximum(static_cast<intptr_t>(0),
-      frame_state_.length() - count));
+  frame_state_.TruncateTo(
+      Utils::Maximum(static_cast<intptr_t>(0), frame_state_.length() - count));
 }
 
 
 bool FlowGraphCompiler::FrameStateIsSafeToCall() {
   ASSERT(!is_optimizing());
   for (intptr_t i = 0; i < frame_state_.length(); i++) {
     if (frame_state_[i] != kTagged) {
       return false;
     }
   }
   return true;
 }
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart