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

runtime/vm/flow_graph_inliner.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
-#include "vm/precompiler.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
-#include "vm/kernel.h"
-#include "vm/kernel_to_il.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_type_propagator.h"
 #include "vm/il_printer.h"
 #include "vm/jit_optimizer.h"
+#include "vm/kernel.h"
+#include "vm/kernel_to_il.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/precompiler.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(int,
             deoptimization_counter_inlining_threshold,
             12,
             "How many times we allow deoptimization before we stop inlining.");
 DEFINE_FLAG(bool, trace_inlining, false, "Trace inlining");
 DEFINE_FLAG(charp, inlining_filter, NULL, "Inline only in named function");
@@ skipping 75 matching lines @@
   } while (false)
 
 #define PRINT_INLINING_TREE(comment, caller, target, instance_call)            \
   do {                                                                         \
     if (FLAG_print_inlining_tree) {                                            \
       inlined_info_.Add(InlinedInfo(caller, target, inlining_depth_,           \
                                     instance_call, comment));                  \
     }                                                                          \
   } while (false)
 
-
 // Test if a call is recursive by looking in the deoptimization environment.
 static bool IsCallRecursive(const Function& function, Definition* call) {
   Environment* env = call->env();
   while (env != NULL) {
     if (function.raw() == env->function().raw()) {
       return true;
     }
     env = env->outer();
   }
   return false;
 }
 
-
 // Helper to get the default value of a formal parameter.
 static ConstantInstr* GetDefaultValue(intptr_t i,
                                       const ParsedFunction& parsed_function) {
   return new ConstantInstr(parsed_function.DefaultParameterValueAt(i));
 }
 
-
 // Pair of an argument name and its value.
 struct NamedArgument {
   String* name;
   Value* value;
   NamedArgument(String* name, Value* value) : name(name), value(value) {}
 };
 
-
 // Helper to collect information about a callee graph when considering it for
 // inlining.
 class GraphInfoCollector : public ValueObject {
  public:
   GraphInfoCollector() : call_site_count_(0), instruction_count_(0) {}
 
   void Collect(const FlowGraph& graph) {
     call_site_count_ = 0;
     instruction_count_ = 0;
     for (BlockIterator block_it = graph.postorder_iterator(); !block_it.Done();
@@ skipping 29 matching lines @@
   }
 
   intptr_t call_site_count() const { return call_site_count_; }
   intptr_t instruction_count() const { return instruction_count_; }
 
  private:
   intptr_t call_site_count_;
   intptr_t instruction_count_;
 };
 
-
 // Structure for collecting inline data needed to print inlining tree.
 struct InlinedInfo {
   const Function* caller;
   const Function* inlined;
   intptr_t inlined_depth;
   const Definition* call_instr;
   const char* bailout_reason;
   InlinedInfo(const Function* caller_function,
               const Function* inlined_function,
               const intptr_t depth,
               const Definition* call,
               const char* reason)
       : caller(caller_function),
         inlined(inlined_function),
         inlined_depth(depth),
         call_instr(call),
         bailout_reason(reason) {}
 };
 
-
 // A collection of call sites to consider for inlining.
 class CallSites : public ValueObject {
  public:
   explicit CallSites(FlowGraph* flow_graph, intptr_t threshold)
       : inlining_depth_threshold_(threshold),
         static_calls_(),
         closure_calls_(),
         instance_calls_() {}
 
   struct InstanceCallInfo {
@@ skipping 117 matching lines @@
           // TODO(srdjan): Add data for closure calls.
         }
         if (call != NULL) {
           inlined_info->Add(
               InlinedInfo(caller, &target, depth + 1, call, "Too deep"));
         }
       }
     }
   }
 
-
   void FindCallSites(FlowGraph* graph,
                      intptr_t depth,
                      GrowableArray<InlinedInfo>* inlined_info) {
     ASSERT(graph != NULL);
     if (depth > inlining_depth_threshold_) {
       if (FLAG_print_inlining_tree) {
         RecordAllNotInlinedFunction(graph, depth, inlined_info);
       }
       return;
     }
@@ skipping 56 matching lines @@
 
  private:
   intptr_t inlining_depth_threshold_;
   GrowableArray<StaticCallInfo> static_calls_;
   GrowableArray<ClosureCallInfo> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
-
 struct InlinedCallData {
   InlinedCallData(Definition* call,
                   intptr_t first_param_index,  // 1 if type args are passed.
                   GrowableArray<Value*>* arguments,
                   const Function& caller,
                   intptr_t caller_inlining_id)
       : call(call),
         first_param_index(first_param_index),
         arguments(arguments),
         callee_graph(NULL),
         parameter_stubs(NULL),
         exit_collector(NULL),
         caller(caller),
         caller_inlining_id(caller_inlining_id) {}
 
   Definition* call;
   const intptr_t first_param_index;
   GrowableArray<Value*>* arguments;
   FlowGraph* callee_graph;
   ZoneGrowableArray<Definition*>* parameter_stubs;
   InlineExitCollector* exit_collector;
   const Function& caller;
   const intptr_t caller_inlining_id;
 };
 
-
 class CallSiteInliner;
 
 class PolymorphicInliner : public ValueObject {
  public:
   PolymorphicInliner(CallSiteInliner* owner,
                      PolymorphicInstanceCallInstr* call,
                      const Function& caller_function,
                      intptr_t caller_inlining_id);
 
   void Inline();
@@ skipping 21 matching lines @@
   // The non_inlined_variants_ can be used in a long-lived instruction object,
   // so they are not embedded into the shorter-lived PolymorphicInliner object.
   CallTargets* non_inlined_variants_;
   GrowableArray<BlockEntryInstr*> inlined_entries_;
   InlineExitCollector* exit_collector_;
 
   const Function& caller_function_;
   const intptr_t caller_inlining_id_;
 };
 
-
 static bool HasAnnotation(const Function& function, const char* annotation) {
   const Class& owner = Class::Handle(function.Owner());
   const Library& library = Library::Handle(owner.library());
   const Array& metadata =
       Array::Cast(Object::Handle(library.GetMetadata(function)));
 
   if (metadata.Length() > 0) {
     Object& val = Object::Handle();
     for (intptr_t i = 0; i < metadata.Length(); i++) {
       val = metadata.At(i);
       if (val.IsString() && String::Cast(val).Equals(annotation)) {
         return true;
       }
     }
   }
   return false;
 }
 
-
 static void ReplaceParameterStubs(Zone* zone,
                                   FlowGraph* caller_graph,
                                   InlinedCallData* call_data,
                                   const TargetInfo* target_info) {
   CSTAT_TIMER_SCOPE(Thread::Current(), graphinliner_subst_timer);
   const bool is_polymorphic = call_data->call->IsPolymorphicInstanceCall();
   ASSERT(is_polymorphic == (target_info != NULL));
   FlowGraph* callee_graph = call_data->callee_graph;
   TargetEntryInstr* callee_entry = callee_graph->graph_entry()->normal_entry();
 
@@ skipping 69 matching lines @@
         }
         param->ReplaceUsesWith(type_args);
       }
     }
   }
 
   // Check that inlining maintains use lists.
   DEBUG_ASSERT(!FLAG_verify_compiler || caller_graph->VerifyUseLists());
 }
 
-
 class CallSiteInliner : public ValueObject {
  public:
   explicit CallSiteInliner(FlowGraphInliner* inliner, intptr_t threshold)
       : inliner_(inliner),
         caller_graph_(inliner->flow_graph()),
         inlined_(false),
         initial_size_(inliner->flow_graph()->InstructionCount()),
         inlined_size_(0),
         inlined_recursive_call_(false),
         inlining_depth_(1),
@@ skipping 256 matching lines @@
           CSTAT_TIMER_SCOPE(thread(), graphinliner_parse_timer);
           parsed_function = GetParsedFunction(function, &in_cache);
           if (!function.CanBeInlined()) {
             // As a side effect of parsing the function, it may be marked
             // as not inlinable. This happens for async and async* functions
             // when causal stack traces are being tracked.
             return false;
           }
         }
 
-
         // Build the callee graph.
         InlineExitCollector* exit_collector =
             new (Z) InlineExitCollector(caller_graph_, call);
         FlowGraph* callee_graph;
         if (UseKernelFrontEndFor(parsed_function)) {
           kernel::FlowGraphBuilder builder(
               parsed_function->function().kernel_offset(), parsed_function,
               *ic_data_array, /* not building var desc */ NULL, exit_collector,
               Compiler::kNoOSRDeoptId, caller_graph_->max_block_id() + 1);
           {
@@ skipping 581 matching lines @@
   intptr_t inlining_recursion_depth_;
   intptr_t inlining_depth_threshold_;
   CallSites* collected_call_sites_;
   CallSites* inlining_call_sites_;
   GrowableArray<ParsedFunction*> function_cache_;
   GrowableArray<InlinedInfo> inlined_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSiteInliner);
 };
 
-
 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner,
                                        PolymorphicInstanceCallInstr* call,
                                        const Function& caller_function,
                                        intptr_t caller_inlining_id)
     : owner_(owner),
       call_(call),
       num_variants_(call->NumberOfChecks()),
       variants_(call->targets_),
       inlined_variants_(zone()),
       non_inlined_variants_(new (zone()) CallTargets(zone())),
       inlined_entries_(num_variants_),
       exit_collector_(new (Z) InlineExitCollector(owner->caller_graph(), call)),
       caller_function_(caller_function),
       caller_inlining_id_(caller_inlining_id) {}
 
-
 Isolate* PolymorphicInliner::isolate() const {
   return owner_->caller_graph()->isolate();
 }
 
-
 Zone* PolymorphicInliner::zone() const {
   return owner_->caller_graph()->zone();
 }
 
-
 intptr_t PolymorphicInliner::AllocateBlockId() const {
   return owner_->caller_graph()->allocate_block_id();
 }
 
-
 // Inlined bodies are shared if two different class ids have the same
 // inlined target.  This sharing is represented by using three different
 // types of entries in the inlined_entries_ array:
 //
 //   * GraphEntry: the inlined body is not shared.
 //
 //   * TargetEntry: the inlined body is shared and this is the first variant.
 //
 //   * JoinEntry: the inlined body is shared and this is a subsequent variant.
 bool PolymorphicInliner::CheckInlinedDuplicate(const Function& target) {
@@ skipping 40 matching lines @@
           inlined_entries_[i]->last_instruction()->SuccessorAt(0);
       ASSERT(join->IsJoinEntry());
       inlined_entries_.Add(join);
       return true;
     }
   }
 
   return false;
 }
 
-
 bool PolymorphicInliner::CheckNonInlinedDuplicate(const Function& target) {
   for (intptr_t i = 0; i < non_inlined_variants_->length(); ++i) {
     if (target.raw() == non_inlined_variants_->TargetAt(i)->target->raw()) {
       return true;
     }
   }
 
   return false;
 }
 
-
 bool PolymorphicInliner::TryInliningPoly(const TargetInfo& target_info) {
   if ((!FLAG_precompiled_mode ||
        owner_->inliner_->use_speculative_inlining()) &&
       target_info.IsSingleCid() &&
       TryInlineRecognizedMethod(target_info.cid_start, *target_info.target)) {
     owner_->inlined_ = true;
     return true;
   }
 
   GrowableArray<Value*> arguments(call_->ArgumentCount());
@@ skipping 11 matching lines @@
   FlowGraph* callee_graph = call_data.callee_graph;
   call_data.exit_collector->PrepareGraphs(callee_graph);
   inlined_entries_.Add(callee_graph->graph_entry());
   exit_collector_->Union(call_data.exit_collector);
 
   ReplaceParameterStubs(zone(), owner_->caller_graph(), &call_data,
                         &target_info);
   return true;
 }
 
-
 static Instruction* AppendInstruction(Instruction* first, Instruction* second) {
   for (intptr_t i = second->InputCount() - 1; i >= 0; --i) {
     Value* input = second->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   first->LinkTo(second);
   return second;
 }
 
-
 bool PolymorphicInliner::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target) {
   TargetEntryInstr* entry;
   Definition* last;
   // Replace the receiver argument with a redefinition to prevent code from
   // the inlined body from being hoisted above the inlined entry.
   GrowableArray<Definition*> arguments(call_->ArgumentCount());
   Definition* receiver = call_->ArgumentAt(0);
   RedefinitionInstr* redefinition =
       new (Z) RedefinitionInstr(new (Z) Value(receiver));
@@ skipping 22 matching lines @@
     GraphEntryInstr* graph_entry = new (Z)
         GraphEntryInstr(*temp_parsed_function, entry, Compiler::kNoOSRDeoptId);
     // Update polymorphic inliner state.
     inlined_entries_.Add(graph_entry);
     exit_collector_->Union(exit_collector);
     return true;
   }
   return false;
 }
 
-
 // Build a DAG to dispatch to the inlined function bodies.  Load the class
 // id of the receiver and make explicit comparisons for each inlined body,
 // in frequency order.  If all variants are inlined, the entry to the last
 // inlined body is guarded by a CheckClassId instruction which can deopt.
 // If not all variants are inlined, we add a PolymorphicInstanceCall
 // instruction to handle the non-inlined variants.
 TargetEntryInstr* PolymorphicInliner::BuildDecisionGraph() {
   const intptr_t try_idx = call_->GetBlock()->try_index();
 
   // Start with a fresh target entry.
@@ skipping 225 matching lines @@
     // Remove push arguments of the call.
     for (intptr_t i = 0; i < call_->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call_->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
   }
   return entry;
 }
 
-
 static void TracePolyInlining(const CallTargets& targets,
                               intptr_t idx,
                               intptr_t total,
                               const char* message) {
   String& name =
       String::Handle(targets.TargetAt(idx)->target->QualifiedUserVisibleName());
   int percent = total == 0 ? 0 : (100 * targets.TargetAt(idx)->count) / total;
   THR_Print("%s cid %" Pd "-%" Pd ": %" Pd "/%" Pd " %d%% %s\n",
             name.ToCString(), targets[idx].cid_start, targets[idx].cid_end,
             targets.TargetAt(idx)->count, total, percent, message);
 }
 
-
 bool PolymorphicInliner::trace_inlining() const {
   return owner_->trace_inlining();
 }
 
-
 void PolymorphicInliner::Inline() {
   ASSERT(&variants_ == &call_->targets_);
 
   intptr_t total = call_->total_call_count();
   for (intptr_t var_idx = 0; var_idx < variants_.length(); ++var_idx) {
     TargetInfo* info = variants_.TargetAt(var_idx);
     if (variants_.length() > FLAG_max_polymorphic_checks) {
       non_inlined_variants_->Add(info);
       continue;
     }
@@ skipping 61 matching lines @@
 
   // If there are no inlined variants, leave the call in place.
   if (inlined_variants_.is_empty()) return;
 
   // Now build a decision tree (a DAG because of shared inline variants) and
   // inline it at the call site.
   TargetEntryInstr* entry = BuildDecisionGraph();
   exit_collector_->ReplaceCall(entry);
 }
 
-
 static uint16_t ClampUint16(intptr_t v) {
   return (v > 0xFFFF) ? 0xFFFF : static_cast<uint16_t>(v);
 }
 
-
 static bool ShouldTraceInlining(FlowGraph* flow_graph) {
   const Function& top = flow_graph->parsed_function().function();
   return FLAG_trace_inlining && FlowGraphPrinter::ShouldPrint(top);
 }
 
-
 FlowGraphInliner::FlowGraphInliner(
     FlowGraph* flow_graph,
     GrowableArray<const Function*>* inline_id_to_function,
     GrowableArray<TokenPosition>* inline_id_to_token_pos,
     GrowableArray<intptr_t>* caller_inline_id,
     bool use_speculative_inlining,
     GrowableArray<intptr_t>* inlining_black_list,
     Precompiler* precompiler)
     : flow_graph_(flow_graph),
       inline_id_to_function_(inline_id_to_function),
       inline_id_to_token_pos_(inline_id_to_token_pos),
       caller_inline_id_(caller_inline_id),
       trace_inlining_(ShouldTraceInlining(flow_graph)),
       use_speculative_inlining_(use_speculative_inlining),
       inlining_black_list_(inlining_black_list),
       precompiler_(precompiler) {
   ASSERT(!use_speculative_inlining || (inlining_black_list != NULL));
 }
 
-
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph, bool force) {
   const Function& function = flow_graph->function();
   if (force || (function.optimized_instruction_count() == 0)) {
     GraphInfoCollector info;
     info.Collect(*flow_graph);
 
     function.set_optimized_instruction_count(
         ClampUint16(info.instruction_count()));
     function.set_optimized_call_site_count(ClampUint16(info.call_site_count()));
   }
 }
 
-
 // TODO(srdjan): This is only needed when disassembling and/or profiling.
 // Sets inlining id for all instructions of this flow-graph, as well for the
 // FlowGraph itself.
 void FlowGraphInliner::SetInliningId(FlowGraph* flow_graph,
                                      intptr_t inlining_id) {
   ASSERT(flow_graph->inlining_id() < 0);
   flow_graph->set_inlining_id(inlining_id);
   for (BlockIterator block_it = flow_graph->postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
          it.Advance()) {
       Instruction* current = it.Current();
       // Do not overwrite owner function.
       ASSERT(!current->has_inlining_id());
       current->set_inlining_id(inlining_id);
     }
   }
 }
 
-
 // Use function name to determine if inlineable operator.
 // Add names as necessary.
 static bool IsInlineableOperator(const Function& function) {
   return (function.name() == Symbols::IndexToken().raw()) ||
          (function.name() == Symbols::AssignIndexToken().raw()) ||
          (function.name() == Symbols::Plus().raw()) ||
          (function.name() == Symbols::Minus().raw());
 }
 
-
 bool FlowGraphInliner::AlwaysInline(const Function& function) {
   const char* kAlwaysInlineAnnotation = "AlwaysInline";
   if (FLAG_enable_inlining_annotations &&
       HasAnnotation(function, kAlwaysInlineAnnotation)) {
     TRACE_INLINING(
         THR_Print("AlwaysInline annotation for %s\n", function.ToCString()));
     return true;
   }
 
   if (function.IsDispatcherOrImplicitAccessor()) {
@@ skipping 10 matching lines @@
       IsInlineableOperator(function) ||
       (function.kind() == RawFunction::kConstructor)) {
     const intptr_t count = function.optimized_instruction_count();
     if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) {
       return true;
     }
   }
   return MethodRecognizer::AlwaysInline(function);
 }
 
-
 void FlowGraphInliner::Inline() {
   // Collect graph info and store it on the function.
   // We might later use it for an early bailout from the inlining.
   CollectGraphInfo(flow_graph_);
 
   const Function& top = flow_graph_->function();
   if ((FLAG_inlining_filter != NULL) &&
       (strstr(top.ToFullyQualifiedCString(), FLAG_inlining_filter) == NULL)) {
     return;
   }
@@ skipping 31 matching lines @@
           (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
         THR_Print("After Inlining of %s\n",
                   flow_graph_->function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
-
 intptr_t FlowGraphInliner::NextInlineId(const Function& function,
                                         TokenPosition tp,
                                         intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   // TODO(johnmccutchan): Do not allow IsNoSource once all nodes have proper
   // source positions.
   ASSERT(tp.IsReal() || tp.IsSynthetic() || tp.IsNoSource());
   inline_id_to_function_->Add(&function);
   inline_id_to_token_pos_->Add(tp);
   caller_inline_id_->Add(parent_id);
   // We always have one less token position than functions.
   ASSERT(inline_id_to_token_pos_->length() ==
          (inline_id_to_function_->length() - 1));
   return id;
 }
 
-
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
-
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
-
 static bool ShouldInlineInt64ArrayOps() {
 #if defined(TARGET_ARCH_X64)
   return true;
 #else
   return false;
 #endif
 }
 
-
 static bool CanUnboxInt32() {
   // Int32/Uint32 can be unboxed if it fits into a smi or the platform
   // supports unboxed mints.
   return (kSmiBits >= 32) || FlowGraphCompiler::SupportsUnboxedMints();
 }
 
-
 // Quick access to the current one.
 #undef Z
 #define Z (flow_graph->zone())
 
 static intptr_t PrepareInlineIndexedOp(FlowGraph* flow_graph,
                                        Instruction* call,
                                        intptr_t array_cid,
                                        Definition** array,
                                        Definition* index,
                                        Instruction** cursor) {
@@ skipping 26 matching lines @@
     array_cid = kArrayCid;
   } else if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements = new (Z) LoadUntaggedInstr(
         new (Z) Value(*array), ExternalTypedData::data_offset());
     *cursor = flow_graph->AppendTo(*cursor, elements, NULL, FlowGraph::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
-
 static bool InlineGetIndexed(FlowGraph* flow_graph,
                              MethodRecognizer::Kind kind,
                              Instruction* call,
                              Definition* receiver,
                              TargetEntryInstr** entry,
                              Definition** last) {
   intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
@@ skipping 24 matching lines @@
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     *last = new (Z) FloatToDoubleInstr(new (Z) Value(*last), deopt_id);
     flow_graph->AppendTo(cursor, *last,
                          deopt_id != Thread::kNoDeoptId ? call->env() : NULL,
                          FlowGraph::kValue);
   }
   return true;
 }
 
-
 static bool InlineSetIndexed(FlowGraph* flow_graph,
                              MethodRecognizer::Kind kind,
                              const Function& target,
                              Instruction* call,
                              Definition* receiver,
                              TokenPosition token_pos,
                              const Cids* value_check,
                              TargetEntryInstr** entry,
                              Definition** last) {
   intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
@@ skipping 120 matching lines @@
 
   const intptr_t index_scale = Instance::ElementSizeFor(array_cid);
   *last = new (Z) StoreIndexedInstr(
       new (Z) Value(array), new (Z) Value(index), new (Z) Value(stored_value),
       needs_store_barrier, index_scale, array_cid, kAlignedAccess,
       call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(cursor, *last, call->env(), FlowGraph::kEffect);
   return true;
 }
 
-
 static bool InlineDoubleOp(FlowGraph* flow_graph,
                            Token::Kind op_kind,
                            Instruction* call,
                            Definition* receiver,
                            TargetEntryInstr** entry,
                            Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
   Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
   BinaryDoubleOpInstr* double_bin_op = new (Z)
       BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
                           call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_bin_op, call->env(), FlowGraph::kValue);
   *last = double_bin_op;
 
   return true;
 }
 
-
 static bool InlineDoubleTestOp(FlowGraph* flow_graph,
                                Instruction* call,
                                Definition* receiver,
                                MethodRecognizer::Kind kind,
                                TargetEntryInstr** entry,
                                Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
 
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
 
   DoubleTestOpInstr* double_test_op = new (Z) DoubleTestOpInstr(
       kind, new (Z) Value(receiver), call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_test_op, call->env(), FlowGraph::kValue);
   *last = double_test_op;
 
   return true;
 }
 
-
 static bool InlineSmiBitAndFromSmi(FlowGraph* flow_graph,
                                    Instruction* call,
                                    Definition* receiver,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   // Right arguments is known to be smi: other._bitAndFromSmi(this);
   BinarySmiOpInstr* smi_op =
       new (Z) BinarySmiOpInstr(Token::kBIT_AND, new (Z) Value(left),
                                new (Z) Value(right), call->deopt_id());
   flow_graph->AppendTo(*entry, smi_op, call->env(), FlowGraph::kValue);
   *last = smi_op;
 
   return true;
 }
 
-
 static bool InlineGrowableArraySetter(FlowGraph* flow_graph,
                                       intptr_t offset,
                                       StoreBarrierType store_barrier_type,
                                       Instruction* call,
                                       Definition* receiver,
                                       TargetEntryInstr** entry,
                                       Definition** last) {
   Definition* array = receiver;
   Definition* value = call->ArgumentAt(1);
 
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
 
   // This is an internal method, no need to check argument types.
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, new (Z) Value(array), new (Z) Value(value), store_barrier_type,
       call->token_pos());
   flow_graph->AppendTo(*entry, store, call->env(), FlowGraph::kEffect);
   *last = store;
 
   return true;
 }
 
-
 static void PrepareInlineByteArrayBaseOp(FlowGraph* flow_graph,
                                          Instruction* call,
                                          intptr_t array_cid,
                                          intptr_t view_cid,
                                          Definition** array,
                                          Definition* byte_index,
                                          Instruction** cursor) {
   LoadFieldInstr* length = new (Z) LoadFieldInstr(
       new (Z) Value(*array), CheckArrayBoundInstr::LengthOffsetFor(array_cid),
       Type::ZoneHandle(Z, Type::SmiType()), call->token_pos());
@@ skipping 40 matching lines @@
       call->env(), FlowGraph::kEffect);
 
   if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements = new (Z) LoadUntaggedInstr(
         new (Z) Value(*array), ExternalTypedData::data_offset());
     *cursor = flow_graph->AppendTo(*cursor, elements, NULL, FlowGraph::kValue);
     *array = elements;
   }
 }
 
-
 static bool InlineByteArrayBaseLoad(FlowGraph* flow_graph,
                                     Instruction* call,
                                     Definition* receiver,
                                     intptr_t array_cid,
                                     intptr_t view_cid,
                                     TargetEntryInstr** entry,
                                     Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
@@ skipping 22 matching lines @@
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     *last = new (Z) FloatToDoubleInstr(new (Z) Value(*last), deopt_id);
     flow_graph->AppendTo(cursor, *last,
                          deopt_id != Thread::kNoDeoptId ? call->env() : NULL,
                          FlowGraph::kValue);
   }
   return true;
 }
 
-
 static bool InlineByteArrayBaseStore(FlowGraph* flow_graph,
                                      const Function& target,
                                      Instruction* call,
                                      Definition* receiver,
                                      intptr_t array_cid,
                                      intptr_t view_cid,
                                      TargetEntryInstr** entry,
                                      Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
@@ skipping 92 matching lines @@
       1,  // Index scale
       view_cid, kUnalignedAccess, call->deopt_id(), call->token_pos());
 
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kEffect);
   return true;
 }
 
-
 // Returns the LoadIndexedInstr.
 static Definition* PrepareInlineStringIndexOp(FlowGraph* flow_graph,
                                               Instruction* call,
                                               intptr_t cid,
                                               Definition* str,
                                               Definition* index,
                                               Instruction* cursor) {
   // Load the length of the string.
   // Treat length loads as mutable (i.e. affected by side effects) to avoid
   // hoisting them since we can't hoist the preceding class-check. This
@@ skipping 32 matching lines @@
 
   LoadIndexedInstr* load_indexed = new (Z) LoadIndexedInstr(
       new (Z) Value(str), new (Z) Value(index), Instance::ElementSizeFor(cid),
       cid, kAlignedAccess, Thread::kNoDeoptId, call->token_pos());
 
   cursor = flow_graph->AppendTo(cursor, load_indexed, NULL, FlowGraph::kValue);
   ASSERT(cursor == load_indexed);
   return load_indexed;
 }
 
-
 static bool InlineStringBaseCharAt(FlowGraph* flow_graph,
                                    Instruction* call,
                                    Definition* receiver,
                                    intptr_t cid,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   if ((cid != kOneByteStringCid) && (cid != kExternalOneByteStringCid)) {
     return false;
   }
   Definition* str = receiver;
   Definition* index = call->ArgumentAt(1);
 
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
   OneByteStringFromCharCodeInstr* char_at =
       new (Z) OneByteStringFromCharCodeInstr(new (Z) Value(*last));
 
   flow_graph->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
-
 static bool InlineStringCodeUnitAt(FlowGraph* flow_graph,
                                    Instruction* call,
                                    Definition* receiver,
                                    intptr_t cid,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
          (cid == kExternalOneByteStringCid) ||
          (cid == kExternalTwoByteStringCid));
   Definition* str = receiver;
   Definition* index = call->ArgumentAt(1);
 
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
   return true;
 }
 
-
 // Only used for monomorphic calls.
 bool FlowGraphInliner::TryReplaceInstanceCallWithInline(
     FlowGraph* flow_graph,
     ForwardInstructionIterator* iterator,
     InstanceCallInstr* call) {
   Function& target = Function::Handle(Z);
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
@@ skipping 33 matching lines @@
     // Remove through the iterator.
     ASSERT(iterator->Current() == call);
     iterator->RemoveCurrentFromGraph();
     call->set_previous(NULL);
     call->set_next(NULL);
     return true;
   }
   return false;
 }
 
-
 bool FlowGraphInliner::TryReplaceStaticCallWithInline(
     FlowGraph* flow_graph,
     ForwardInstructionIterator* iterator,
     StaticCallInstr* call) {
   TargetEntryInstr* entry;
   Definition* last;
   if (FlowGraphInliner::TryInlineRecognizedMethod(
           flow_graph, kIllegalCid, call->function(), call, NULL,
           call->token_pos(), *call->ic_data(), &entry, &last)) {
     // Remove the original push arguments.
@@ skipping 18 matching lines @@
     // Remove through the iterator.
     ASSERT(iterator->Current() == call);
     iterator->RemoveCurrentFromGraph();
     call->set_previous(NULL);
     call->set_next(NULL);
     return true;
   }
   return false;
 }
 
-
 static bool InlineFloat32x4Method(FlowGraph* flow_graph,
                                   Instruction* call,
                                   Definition* receiver,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
 
@@ skipping 85 matching lines @@
       UNREACHABLE();
       return false;
   }
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 static bool CheckMask(Definition* definition, intptr_t* mask_ptr) {
   if (!definition->IsConstant()) return false;
   ConstantInstr* constant_instruction = definition->AsConstant();
   const Object& constant_mask = constant_instruction->value();
   if (!constant_mask.IsSmi()) return false;
   const intptr_t mask = Smi::Cast(constant_mask).Value();
   if ((mask < 0) || (mask > 255)) {
     return false;  // Not a valid mask.
   }
   *mask_ptr = mask;
   return true;
 }
 
-
 static bool InlineSimdShuffleMethod(FlowGraph* flow_graph,
                                     Instruction* call,
                                     Definition* receiver,
                                     MethodRecognizer::Kind kind,
                                     TargetEntryInstr** entry,
                                     Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   Definition* mask_definition = call->ArgumentAt(1);
   intptr_t mask = 0;
   if (!CheckMask(mask_definition, &mask)) {
     return false;
   }
   *last = new (Z) Simd32x4ShuffleInstr(kind, new (Z) Value(call->ArgumentAt(0)),
                                        mask, call->deopt_id());
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 static bool InlineSimdShuffleMixMethod(FlowGraph* flow_graph,
                                        Instruction* call,
                                        Definition* receiver,
                                        MethodRecognizer::Kind kind,
                                        TargetEntryInstr** entry,
                                        Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
                        call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   Definition* mask_definition = call->ArgumentAt(2);
   intptr_t mask = 0;
   if (!CheckMask(mask_definition, &mask)) {
     return false;
   }
   *last = new (Z) Simd32x4ShuffleMixInstr(kind, new (Z) Value(receiver),
                                           new (Z) Value(call->ArgumentAt(1)),
                                           mask, call->deopt_id());
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 static bool InlineInt32x4Method(FlowGraph* flow_graph,
                                 Instruction* call,
                                 Definition* receiver,
                                 MethodRecognizer::Kind kind,
                                 TargetEntryInstr** entry,
                                 Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z)
@@ skipping 36 matching lines @@
     default:
       return false;
   }
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 static bool InlineFloat64x2Method(FlowGraph* flow_graph,
                                   Instruction* call,
                                   Definition* receiver,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z)
@@ skipping 32 matching lines @@
       UNREACHABLE();
       return false;
   }
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 static bool InlineSimdConstructor(FlowGraph* flow_graph,
                                   Instruction* call,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
@@ skipping 61 matching lines @@
       UNREACHABLE();
       return false;
   }
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 static bool InlineMathCFunction(FlowGraph* flow_graph,
                                 Instruction* call,
                                 MethodRecognizer::Kind kind,
                                 TargetEntryInstr** entry,
                                 Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
   *entry = new (Z)
       TargetEntryInstr(flow_graph->allocate_block_id(),
@@ skipping 19 matching lines @@
       break;
     }
   }
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
-
 bool FlowGraphInliner::TryInlineRecognizedMethod(FlowGraph* flow_graph,
                                                  intptr_t receiver_cid,
                                                  const Function& target,
                                                  Definition* call,
                                                  Definition* receiver,
                                                  TokenPosition token_pos,
                                                  const ICData& ic_data,
                                                  TargetEntryInstr** entry,
                                                  Definition** last) {
   MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(target);
@@ skipping 402 matching lines @@
           call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
           FlowGraph::kEffect);
       return true;
     }
 
     default:
       return false;
   }
 }
 
-
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)