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

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 94 matching lines @@
 COMPILE_ASSERT(!FLAG_deoptimize_alot);  // Used in some tests.
 COMPILE_ASSERT(!FLAG_enable_mirrors);
 COMPILE_ASSERT(FLAG_precompiled_runtime);
 COMPILE_ASSERT(!FLAG_print_stop_message);
 COMPILE_ASSERT(!FLAG_use_osr);
 COMPILE_ASSERT(FLAG_deoptimize_every == 0);  // Used in some tests.
 COMPILE_ASSERT(FLAG_load_deferred_eagerly);
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
-
 // Assign locations to incoming arguments, i.e., values pushed above spill slots
 // with PushArgument.  Recursively allocates from outermost to innermost
 // environment.
 void CompilerDeoptInfo::AllocateIncomingParametersRecursive(
     Environment* env,
     intptr_t* stack_height) {
   if (env == NULL) return;
   AllocateIncomingParametersRecursive(env->outer(), stack_height);
   for (Environment::ShallowIterator it(env); !it.Done(); it.Advance()) {
     if (it.CurrentLocation().IsInvalid() &&
         it.CurrentValue()->definition()->IsPushArgument()) {
       it.SetCurrentLocation(Location::StackSlot((*stack_height)++));
     }
   }
 }
 
-
 void CompilerDeoptInfo::EmitMaterializations(Environment* env,
                                              DeoptInfoBuilder* builder) {
   for (Environment::DeepIterator it(env); !it.Done(); it.Advance()) {
     if (it.CurrentLocation().IsInvalid()) {
       MaterializeObjectInstr* mat =
           it.CurrentValue()->definition()->AsMaterializeObject();
       ASSERT(mat != NULL);
       builder->AddMaterialization(mat);
     }
   }
 }
 
-
 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()),
@@ skipping 50 matching lines @@
   }
   ASSERT(assembler != NULL);
   ASSERT(!list_class_.IsNull());
 
   bool stack_traces_only = !FLAG_profiler;
   code_source_map_builder_ = new (zone_)
       CodeSourceMapBuilder(stack_traces_only, caller_inline_id,
                            inline_id_to_token_pos, inline_id_to_function);
 }
 
-
 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 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();
   catch_entry_state_maps_builder_ = new (zone()) CatchEntryStateMapBuilder();
   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
@@ skipping 38 matching lines @@
     const Array& edge_counters =
         Array::Handle(Array::New(num_counters, Heap::kOld));
     const Smi& zero_smi = Smi::Handle(Smi::New(0));
     for (intptr_t i = 0; i < num_counters; ++i) {
       edge_counters.SetAt(i, zero_smi);
     }
     edge_counters_array_ = edge_counters.raw();
   }
 }
 
-
 bool FlowGraphCompiler::CanOptimize() {
   return FLAG_optimization_counter_threshold >= 0;
 }
 
-
 bool FlowGraphCompiler::CanOptimizeFunction() const {
   return CanOptimize() && !parsed_function().function().HasBreakpoint();
 }
 
-
 bool FlowGraphCompiler::CanOSRFunction() const {
   return isolate()->use_osr() && CanOptimizeFunction() && !is_optimizing();
 }
 
-
 bool FlowGraphCompiler::ForceSlowPathForStackOverflow() const {
   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 &&
       strstr(parsed_function().function().ToFullyQualifiedCString(),
              FLAG_deoptimize_filter) != NULL) {
     return true;
   }
   return false;
 }
 
-
 static bool IsEmptyBlock(BlockEntryInstr* block) {
   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.
   if (block_info->is_marked()) {
     return;
   }
   block_info->mark();
 
   if (IsEmptyBlock(block)) {
     // For empty blocks, record a corresponding nonempty target as their
     // jump label.
     BlockEntryInstr* target = block->next()->AsGoto()->successor();
     CompactBlock(target);
     block_info->set_jump_label(GetJumpLabel(target));
   }
 }
 
-
 void FlowGraphCompiler::CompactBlocks() {
   // This algorithm does not garbage collect blocks in place, but merely
   // records forwarding label information.  In this way it avoids having to
   // change join and target entries.
   Label* nonempty_label = NULL;
   for (intptr_t i = block_order().length() - 1; i >= 1; --i) {
     BlockEntryInstr* block = block_order()[i];
 
     // Unoptimized code must emit all possible deoptimization points.
     if (is_optimizing()) {
       CompactBlock(block);
     }
 
     // For nonempty blocks, record the next nonempty block in the block
     // order.  Since no code is emitted for empty blocks, control flow is
     // eligible to fall through to the next nonempty one.
     if (!WasCompacted(block)) {
       BlockInfo* block_info = block_info_[block->postorder_number()];
       block_info->set_next_nonempty_label(nonempty_label);
       nonempty_label = GetJumpLabel(block);
     }
   }
 
   ASSERT(block_order()[0]->IsGraphEntry());
   BlockInfo* block_info = block_info_[block_order()[0]->postorder_number()];
   block_info->set_next_nonempty_label(nonempty_label);
 }
 
-
 void FlowGraphCompiler::EmitCatchEntryState(Environment* env,
                                             intptr_t try_index) {
 #if defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
   env = env ? env : pending_deoptimization_env_;
   try_index = try_index != CatchClauseNode::kInvalidTryIndex
                   ? try_index
                   : CurrentTryIndex();
   if (is_optimizing() && env != NULL &&
       (try_index != CatchClauseNode::kInvalidTryIndex)) {
     env = env->Outermost();
@@ skipping 54 matching lines @@
       if (src.stack_index() != dest_index) {
         catch_entry_state_maps_builder_->AppendMove(src.stack_index(),
                                                     dest_index);
       }
     }
     catch_entry_state_maps_builder_->EndMapping();
   }
 #endif  // defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
 }
 
-
 void FlowGraphCompiler::EmitCallsiteMetaData(TokenPosition token_pos,
                                              intptr_t deopt_id,
                                              RawPcDescriptors::Kind kind,
                                              LocationSummary* locs) {
   AddCurrentDescriptor(kind, deopt_id, token_pos);
   RecordSafepoint(locs);
   EmitCatchEntryState();
 }
 
-
 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(),
                            instr->token_pos());
     }
     AllocateRegistersLocally(instr);
   }
 }
 
-
 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());
 }
 
-
 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()) {
         if (loop_it.Current() == block.preorder_number()) {
           assembler->Comment("  Loop %" Pd "", loop_id);
         }
       }
     }
   }
 }
 
-
 void FlowGraphCompiler::VisitBlocks() {
   CompactBlocks();
   const ZoneGrowableArray<BlockEntryInstr*>* loop_headers = NULL;
   if (Assembler::EmittingComments()) {
     // 'loop_headers' were cleared, recompute.
     loop_headers = flow_graph().ComputeLoops();
     ASSERT(loop_headers != NULL);
   }
 
   for (intptr_t i = 0; i < block_order().length(); ++i) {
@@ skipping 55 matching lines @@
     }
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
     ASSERT(is_optimizing() || FrameStateIsSafeToCall());
 #endif
   }
 
   set_current_block(NULL);
 }
 
-
 void FlowGraphCompiler::Bailout(const char* reason) {
   parsed_function_.Bailout("FlowGraphCompiler", reason);
 }
 
-
 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();
   }
 }
 
-
 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 {
   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};
   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,
                                             TokenPosition token_pos,
                                             bool is_generated,
                                             const Array& handler_types,
                                             bool needs_stacktrace) {
   exception_handlers_list_->AddHandler(try_index, outer_try_index, pc_offset,
                                        token_pos, is_generated, handler_types,
                                        needs_stacktrace);
 }
 
-
 void FlowGraphCompiler::SetNeedsStackTrace(intptr_t try_index) {
   exception_handlers_list_->SetNeedsStackTrace(try_index);
 }
 
-
 void FlowGraphCompiler::AddDescriptor(RawPcDescriptors::Kind kind,
                                       intptr_t pc_offset,
                                       intptr_t deopt_id,
                                       TokenPosition token_pos,
                                       intptr_t try_index) {
   code_source_map_builder_->NoteDescriptor(kind, pc_offset, token_pos);
   // When running with optimizations disabled, don't emit deopt-descriptors.
   if (!CanOptimize() && (kind == RawPcDescriptors::kDeopt)) return;
   pc_descriptors_list_->AddDescriptor(kind, pc_offset, deopt_id, token_pos,
                                       try_index);
 }
 
-
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(RawPcDescriptors::Kind kind,
                                              intptr_t deopt_id,
                                              TokenPosition token_pos) {
   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));
 }
 
-
 void FlowGraphCompiler::AddStubCallTarget(const Code& code) {
   ASSERT(code.IsZoneHandle());
   static_calls_target_table_.Add(
       new (zone()) StaticCallsStruct(assembler()->CodeSize(), NULL, &code));
 }
 
-
 CompilerDeoptInfo* 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_);
   info->set_pc_offset(assembler()->CodeSize());
   deopt_infos_.Add(info);
   return 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;
 
@@ skipping 64 matching lines @@
     }
 
     // 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,
                                        slow_path_bit_count);
   }
 }
 
-
 // This function must be kept in sync with:
 //
 //     FlowGraphCompiler::RecordSafepoint
 //     FlowGraphCompiler::SaveLiveRegisters
 //     MaterializeObjectInstr::RemapRegisters
 //
 Environment* FlowGraphCompiler::SlowPathEnvironmentFor(
     Instruction* instruction) {
   if (instruction->env() == NULL) {
     ASSERT(!is_optimizing());
@@ skipping 36 matching lines @@
   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));
   }
 
   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_);
   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());
   CompilerDeoptInfo* info =
       new (zone()) CompilerDeoptInfo(deopt_id, reason, flags, env_copy);
   deopt_infos_.Add(info);
   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()));
     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());
   code.set_pc_descriptors(descriptors);
 }
 
-
 RawArray* FlowGraphCompiler::CreateDeoptInfo(Assembler* assembler) {
   // No deopt information if we precompile (no deoptimization allowed).
   if (FLAG_precompiled_mode) {
     return Array::empty_array().raw();
   }
   // For functions with optional arguments, all incoming arguments are copied
   // to spill slots. The deoptimization environment does not track them.
   const Function& function = parsed_function().function();
   const intptr_t incoming_arg_count =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
@@ skipping 12 matching lines @@
       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());
       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());
   } else {
     // Finalize the stack map array and add it to the code object.
     code.set_stackmaps(
         Array::Handle(stackmap_table_builder_->FinalizeStackMaps(code)));
   }
 }
 
-
 void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
   if (code.is_optimized()) {
     // Optimized code does not need variable descriptors. They are
     // only stored in the unoptimized version.
     code.set_var_descriptors(Object::empty_var_descriptors());
     return;
   }
   LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle();
   if (parsed_function().node_sequence() == NULL) {
     // Eager local var descriptors computation for Irregexp function as it is
@@ skipping 41 matching lines @@
     if (static_calls_target_table_[i]->code != NULL) {
       targets.SetAt(target_ix + Code::kSCallTableCodeEntry,
                     *static_calls_target_table_[i]->code);
     }
   }
   code.set_static_calls_target_table(targets);
   INC_STAT(Thread::Current(), total_code_size,
            targets.Length() * sizeof(uword));
 }
 
-
 void FlowGraphCompiler::FinalizeCodeSourceMap(const Code& code) {
   const Array& inlined_id_array =
       Array::Handle(zone(), code_source_map_builder_->InliningIdToFunction());
   INC_STAT(Thread::Current(), total_code_size,
            inlined_id_array.Length() * sizeof(uword));
   code.set_inlined_id_to_function(inlined_id_array);
 
   const CodeSourceMap& map =
       CodeSourceMap::Handle(code_source_map_builder_->Finalize());
   INC_STAT(Thread::Current(), total_code_size, map.Length() * sizeof(uint8_t));
   code.set_code_source_map(map);
 
 #if defined(DEBUG)
   // Force simulation through the last pc offset. This checks we can decode
   // the whole CodeSourceMap without hitting an unknown opcode, stack underflow,
   // etc.
   GrowableArray<const Function*> fs;
   GrowableArray<TokenPosition> tokens;
   code.GetInlinedFunctionsAtInstruction(code.Size() - 1, &fs, &tokens);
 #endif
 }
 
-
 // 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());
     String& name = String::Handle(parsed_function().function().name());
 
     if (parsed_function().function().kind() == RawFunction::kImplicitGetter) {
       // TODO(27590) Store Field object inside RawFunction::data_ if possible.
@@ skipping 34 matching lines @@
   // "Deoptimization" from intrinsic continues here. All deoptimization
   // branches from intrinsic code redirect to here where the slow-path
   // (normal function body) starts.
   // This means that there must not be any side-effects in intrinsic code
   // 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::GenerateCallWithDeopt(TokenPosition token_pos,
                                               intptr_t deopt_id,
                                               const StubEntry& stub_entry,
                                               RawPcDescriptors::Kind kind,
                                               LocationSummary* locs) {
   GenerateCall(token_pos, stub_entry, kind, locs);
   const intptr_t deopt_id_after = Thread::ToDeoptAfter(deopt_id);
   if (is_optimizing()) {
     AddDeoptIndexAtCall(deopt_id_after);
   } else {
     // Add deoptimization continuation point after the call and before the
     // arguments are removed.
     AddCurrentDescriptor(RawPcDescriptors::kDeopt, deopt_id_after, token_pos);
   }
 }
 
-
 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);
@@ skipping 38 matching lines @@
       break;
     case 2:
       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,
                                            ArgumentsInfo args_info,
                                            LocationSummary* locs,
                                            const ICData& ic_data_in) {
   const ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
   const Array& arguments_descriptor = Array::ZoneHandle(
       zone(), ic_data.IsNull() ? args_info.ToArgumentsDescriptor()
                                : ic_data.arguments_descriptor());
@@ skipping 10 matching lines @@
           GetOrAddStaticCallICData(deopt_id, function, arguments_descriptor,
                                    kNumArgsChecked)
               ->raw();
     }
     AddCurrentDescriptor(RawPcDescriptors::kRewind, deopt_id, token_pos);
     EmitUnoptimizedStaticCall(args_info.pushed_argc, deopt_id, token_pos, locs,
                               call_ic_data);
   }
 }
 
-
 void FlowGraphCompiler::GenerateNumberTypeCheck(Register kClassIdReg,
                                                 const AbstractType& type,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl) {
   assembler()->Comment("NumberTypeCheck");
   GrowableArray<intptr_t> args;
   if (type.IsNumberType()) {
     args.Add(kDoubleCid);
     args.Add(kMintCid);
     args.Add(kBigintCid);
   } else if (type.IsIntType()) {
     args.Add(kMintCid);
     args.Add(kBigintCid);
   } else if (type.IsDoubleType()) {
     args.Add(kDoubleCid);
   }
   CheckClassIds(kClassIdReg, args, is_instance_lbl, is_not_instance_lbl);
 }
 
-
 void FlowGraphCompiler::GenerateStringTypeCheck(Register kClassIdReg,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl) {
   assembler()->Comment("StringTypeCheck");
   GrowableArray<intptr_t> args;
   args.Add(kOneByteStringCid);
   args.Add(kTwoByteStringCid);
   args.Add(kExternalOneByteStringCid);
   args.Add(kExternalTwoByteStringCid);
   CheckClassIds(kClassIdReg, args, is_instance_lbl, is_not_instance_lbl);
 }
 
-
 void FlowGraphCompiler::GenerateListTypeCheck(Register kClassIdReg,
                                               Label* is_instance_lbl) {
   assembler()->Comment("ListTypeCheck");
   Label unknown;
   GrowableArray<intptr_t> args;
   args.Add(kArrayCid);
   args.Add(kGrowableObjectArrayCid);
   args.Add(kImmutableArrayCid);
   CheckClassIds(kClassIdReg, args, is_instance_lbl, &unknown);
   assembler()->Bind(&unknown);
 }
 #endif  // !defined(TARGET_ARCH_DBC)
 
 void FlowGraphCompiler::EmitComment(Instruction* instr) {
   if (!FLAG_support_il_printer || !FLAG_support_disassembler) {
     return;
   }
 #ifndef PRODUCT
   char buffer[256];
   BufferFormatter f(buffer, sizeof(buffer));
   instr->PrintTo(&f);
   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())));
 }
 
-
 // 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.
 
 // 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];
@@ skipping 78 matching lines @@
         break;
       case Location::kRequiresFpuRegister:
         UNREACHABLE();
         break;
     }
     locs->set_out(0, result_location);
   }
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
-
 static uword RegMaskBit(Register reg) {
   return ((reg) != kNoRegister) ? (1 << (reg)) : 0;
 }
 
-
 ParallelMoveResolver::ParallelMoveResolver(FlowGraphCompiler* compiler)
     : compiler_(compiler), moves_(32) {}
 
-
 void ParallelMoveResolver::EmitNativeCode(ParallelMoveInstr* parallel_move) {
   ASSERT(moves_.is_empty());
   // Build up a worklist of moves.
   BuildInitialMoveList(parallel_move);
 
   for (int i = 0; i < moves_.length(); ++i) {
     const MoveOperands& move = *moves_[i];
     // Skip constants to perform them last.  They don't block other moves
     // and skipping such moves with register destinations keeps those
     // registers free for the whole algorithm.
     if (!move.IsEliminated() && !move.src().IsConstant()) PerformMove(i);
   }
 
   // Perform the moves with constant sources.
   for (int i = 0; i < moves_.length(); ++i) {
     const MoveOperands& move = *moves_[i];
     if (!move.IsEliminated()) {
       ASSERT(move.src().IsConstant());
       compiler_->BeginCodeSourceRange();
       EmitMove(i);
       compiler_->EndCodeSourceRange(TokenPosition::kParallelMove);
     }
   }
 
   moves_.Clear();
 }
 
-
 void ParallelMoveResolver::BuildInitialMoveList(
     ParallelMoveInstr* parallel_move) {
   // Perform a linear sweep of the moves to add them to the initial list of
   // moves to perform, ignoring any move that is redundant (the source is
   // the same as the destination, the destination is ignored and
   // unallocated, or the move was already eliminated).
   for (int i = 0; i < parallel_move->NumMoves(); i++) {
     MoveOperands* move = parallel_move->MoveOperandsAt(i);
     if (!move->IsRedundant()) moves_.Add(move);
   }
 }
 
-
 void ParallelMoveResolver::PerformMove(int index) {
   // Each call to this function performs a move and deletes it from the move
   // graph.  We first recursively perform any move blocking this one.  We
   // mark a move as "pending" on entry to PerformMove in order to detect
   // cycles in the move graph.  We use operand swaps to resolve cycles,
   // which means that a call to PerformMove could change any source operand
   // in the move graph.
 
   ASSERT(!moves_[index]->IsPending());
   ASSERT(!moves_[index]->IsRedundant());
@@ skipping 48 matching lines @@
       return;
     }
   }
 
   // This move is not blocked.
   compiler_->BeginCodeSourceRange();
   EmitMove(index);
   compiler_->EndCodeSourceRange(TokenPosition::kParallelMove);
 }
 
-
 bool ParallelMoveResolver::IsScratchLocation(Location loc) {
   for (int i = 0; i < moves_.length(); ++i) {
     if (moves_[i]->Blocks(loc)) {
       return false;
     }
   }
 
   for (int i = 0; i < moves_.length(); ++i) {
     if (moves_[i]->dest().Equals(loc)) {
       return true;
     }
   }
 
   return false;
 }
 
-
 intptr_t ParallelMoveResolver::AllocateScratchRegister(
     Location::Kind kind,
     uword blocked_mask,
     intptr_t first_free_register,
     intptr_t last_free_register,
     bool* spilled) {
   COMPILE_ASSERT(static_cast<intptr_t>(sizeof(blocked_mask)) * kBitsPerByte >=
                  kNumberOfFpuRegisters);
   COMPILE_ASSERT(static_cast<intptr_t>(sizeof(blocked_mask)) * kBitsPerByte >=
                  kNumberOfCpuRegisters);
@@ skipping 14 matching lines @@
         break;
       }
     }
   } else {
     *spilled = false;
   }
 
   return scratch;
 }
 
-
 ParallelMoveResolver::ScratchFpuRegisterScope::ScratchFpuRegisterScope(
     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_));
 
   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) {
   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_));
 
   if (spilled_) {
     resolver->SpillScratch(reg_);
   }
 }
 
-
 ParallelMoveResolver::ScratchRegisterScope::~ScratchRegisterScope() {
   if (spilled_) {
     resolver_->RestoreScratch(reg_);
   }
 }
 
-
 const ICData* FlowGraphCompiler::GetOrAddInstanceCallICData(
     intptr_t deopt_id,
     const String& target_name,
     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.raw());
@@ skipping 10 matching lines @@
 #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());
@@ skipping 11 matching lines @@
   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;
     if (threshold > FLAG_optimization_counter_threshold) {
       threshold = FLAG_optimization_counter_threshold;
     }
   }
   return threshold;
 }
 
-
 const Class& FlowGraphCompiler::BoxClassFor(Representation rep) {
   switch (rep) {
     case kUnboxedDouble:
       return double_class();
     case kUnboxedFloat32x4:
       return float32x4_class();
     case kUnboxedFloat64x2:
       return float64x2_class();
     case kUnboxedInt32x4:
       return int32x4_class();
     case kUnboxedMint:
       return mint_class();
     default:
       UNREACHABLE();
       return Class::ZoneHandle();
   }
 }
 
-
 void FlowGraphCompiler::BeginCodeSourceRange() {
   code_source_map_builder_->BeginCodeSourceRange(assembler()->CodeSize());
 }
 
-
 void FlowGraphCompiler::EndCodeSourceRange(TokenPosition token_pos) {
   code_source_map_builder_->EndCodeSourceRange(assembler()->CodeSize(),
                                                token_pos);
 }
 
-
 const CallTargets* FlowGraphCompiler::ResolveCallTargetsForReceiverCid(
     intptr_t cid,
     const String& selector,
     const Array& args_desc_array) {
   Zone* zone = Thread::Current()->zone();
 
   ArgumentsDescriptor args_desc(args_desc_array);
 
   Function& fn = Function::ZoneHandle(zone);
   if (!LookupMethodFor(cid, selector, args_desc, &fn)) return NULL;
 
   CallTargets* targets = new (zone) CallTargets(zone);
   targets->Add(new (zone) TargetInfo(cid, cid, &fn, /* count = */ 1));
 
   return targets;
 }
 
-
 bool FlowGraphCompiler::LookupMethodFor(int class_id,
                                         const String& name,
                                         const ArgumentsDescriptor& args_desc,
                                         Function* fn_return,
                                         bool* class_is_abstract_return) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   if (class_id < 0) return false;
   if (class_id >= isolate->class_table()->NumCids()) return false;
@@ skipping 10 matching lines @@
   }
   const bool allow_add = false;
   Function& target_function =
       Function::Handle(zone, Resolver::ResolveDynamicForReceiverClass(
                                  cls, name, args_desc, allow_add));
   if (target_function.IsNull()) return false;
   *fn_return ^= target_function.raw();
   return true;
 }
 
-
 #if !defined(TARGET_ARCH_DBC)
 // DBC emits calls very differently from other architectures due to its
 // interpreted nature.
 void FlowGraphCompiler::EmitPolymorphicInstanceCall(
     const CallTargets& targets,
     const InstanceCallInstr& original_call,
     ArgumentsInfo args_info,
     intptr_t deopt_id,
     TokenPosition token_pos,
     LocationSummary* locs,
@@ skipping 18 matching lines @@
       assembler()->Bind(&ok);
     } else {
       const ICData& unary_checks = ICData::ZoneHandle(
           zone(), original_call.ic_data()->AsUnaryClassChecks());
       EmitSwitchableInstanceCall(unary_checks, args_info.pushed_argc, deopt_id,
                                  token_pos, locs);
     }
   }
 }
 
-
 #define __ assembler()->
 void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
                                         const String& function_name,
                                         ArgumentsInfo args_info,
                                         Label* failed,
                                         Label* match_found,
                                         intptr_t deopt_id,
                                         TokenPosition token_index,
                                         LocationSummary* locs,
                                         bool complete,
@@ skipping 130 matching lines @@
 
   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) ||
       (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));
 }
 
-
 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