dart::FlowGraphInliner Class Reference

#include <inliner.h>

Inheritance diagram for dart::FlowGraphInliner:

Public Member Functions
	FlowGraphInliner (FlowGraph *flow_graph, GrowableArray< const Function * > *inline_id_to_function, GrowableArray< TokenPosition > *inline_id_to_token_pos, GrowableArray< intptr_t > *caller_inline_id, SpeculativeInliningPolicy *speculative_policy, Precompiler *precompiler)
int	Inline ()
bool	AlwaysInline (const Function &function)
FlowGraph *	flow_graph () const
intptr_t	NextInlineId (const Function &function, const InstructionSource &source)
bool	trace_inlining () const
SpeculativeInliningPolicy *	speculative_policy ()

Static Public Member Functions
static void	CollectGraphInfo (FlowGraph *flow_graph, intptr_t num_constant_args, bool force, intptr_t *instruction_count, intptr_t *call_site_count)
static void	SetInliningId (FlowGraph *flow_graph, intptr_t inlining_id)
static bool	FunctionHasPreferInlinePragma (const Function &function)
static bool	FunctionHasNeverInlinePragma (const Function &function)
static bool	FunctionHasAlwaysConsiderInliningPragma (const Function &function)

Friends
class	CallSiteInliner

Detailed Description

Definition at line 92 of file inliner.h.

Constructor & Destructor Documentation

FlowGraphInliner()

dart::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,
		SpeculativeInliningPolicy *	speculative_policy,
		Precompiler *	precompiler
	)

Definition at line 2400 of file inliner.cc.

    : 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_(FLAG_trace_inlining && flow_graph->should_print()),
      speculative_policy_(speculative_policy),
      precompiler_(precompiler) {}

Member Function Documentation

AlwaysInline()

bool dart::FlowGraphInliner::AlwaysInline

(

const Function &

function

)

Definition at line 2512 of file inliner.cc.

                                                            {
  if (FunctionHasPreferInlinePragma(function)) {
    TRACE_INLINING(
        THR_Print("vm:prefer-inline pragma for %s\n", function.ToCString()));
    return true;
  }
 
  COMPILER_TIMINGS_TIMER_SCOPE(dart::Thread::Current(), MakeInliningDecision);
  // We don't want to inline DIFs for recognized methods because we would rather
  // replace them with inline FG before inlining introduces any superfluous
  // AssertAssignable instructions.
  if (function.IsDispatcherOrImplicitAccessor() &&
      !(function.kind() == UntaggedFunction::kDynamicInvocationForwarder &&
        function.IsRecognized())) {
    // Smaller or same size as the call.
    return true;
  }
 
  if (function.is_const()) {
    // Inlined const fields are smaller than a call.
    return true;
  }
 
  if (function.IsMethodExtractor()) {
    // Tear-off closure allocation has about the same size as the call.
    return true;
  }
 
  if (function.IsGetterFunction() || function.IsSetterFunction() ||
      IsInlineableOperator(function) ||
      (function.kind() == UntaggedFunction::kConstructor)) {
    const intptr_t count = function.optimized_instruction_count();
    if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) {
      return true;
    }
  }
  return false;
}

CollectGraphInfo()

void dart::FlowGraphInliner::CollectGraphInfo ( FlowGraph *  flow_graph, intptr_t  num_constant_args, bool  force, intptr_t *  instruction_count, intptr_t *  call_site_count  )

static

Definition at line 2415 of file inliner.cc.

                                                                   {
  COMPILER_TIMINGS_TIMER_SCOPE(flow_graph->thread(), CollectGraphInfo);
  const Function& function = flow_graph->function();
  // For OSR, don't even bother.
  if (flow_graph->IsCompiledForOsr()) {
    *instruction_count = 0;
    *call_site_count = 0;
    return;
  }
  // Specialized case: always recompute, never cache.
  if (constants_count > 0) {
    ASSERT(!force);
    GraphInfoCollector info;
    info.Collect(*flow_graph);
    *instruction_count = info.instruction_count();
    *call_site_count = info.call_site_count();
    return;
  }
  // Non-specialized case: unless forced, only recompute on a cache miss.
  ASSERT(constants_count == 0);
  if (force || (function.optimized_instruction_count() == 0)) {
    GraphInfoCollector info;
    info.Collect(*flow_graph);
    function.SetOptimizedInstructionCountClamped(info.instruction_count());
    function.SetOptimizedCallSiteCountClamped(info.call_site_count());
  }
  *instruction_count = function.optimized_instruction_count();
  *call_site_count = function.optimized_call_site_count();
}

flow_graph()

FlowGraph * dart::FlowGraphInliner::flow_graph ( ) const

inline

Definition at line 128 of file inliner.h.

{ return flow_graph_; }

FunctionHasAlwaysConsiderInliningPragma()

bool dart::FlowGraphInliner::FunctionHasAlwaysConsiderInliningPragma ( const Function &  function )

static

Definition at line 2499 of file inliner.cc.

                              {
  if (!function.has_pragma()) {
    return false;
  }
  Thread* thread = dart::Thread::Current();
  COMPILER_TIMINGS_TIMER_SCOPE(thread, CheckForPragma);
  Object& options = Object::Handle();
  return Library::FindPragma(thread, /*only_core=*/false, function,
                             Symbols::vm_always_consider_inlining(),
                             /*multiple=*/false, &options);
}

FunctionHasNeverInlinePragma()

bool dart::FlowGraphInliner::FunctionHasNeverInlinePragma ( const Function &  function )

static

Definition at line 2487 of file inliner.cc.

                                                                            {
  if (!function.has_pragma()) {
    return false;
  }
  Thread* thread = dart::Thread::Current();
  COMPILER_TIMINGS_TIMER_SCOPE(thread, CheckForPragma);
  Object& options = Object::Handle();
  return Library::FindPragma(thread, /*only_core=*/false, function,
                             Symbols::vm_never_inline(),
                             /*multiple=*/false, &options);
}

FunctionHasPreferInlinePragma()

bool dart::FlowGraphInliner::FunctionHasPreferInlinePragma ( const Function &  function )

static

Definition at line 2475 of file inliner.cc.

                                                                             {
  if (!function.has_pragma()) {
    return false;
  }
  Thread* thread = dart::Thread::Current();
  COMPILER_TIMINGS_TIMER_SCOPE(thread, CheckForPragma);
  Object& options = Object::Handle();
  return Library::FindPragma(thread, /*only_core=*/false, function,
                             Symbols::vm_prefer_inline(),
                             /*multiple=*/false, &options);
}

Inline()

int dart::FlowGraphInliner::Inline

(

)

Definition at line 2551 of file inliner.cc.

                             {
  // Collect some early graph information assuming it is non-specialized
  // so that the cached approximation may be used later for an early
  // bailout from inlining.
  intptr_t instruction_count = 0;
  intptr_t call_site_count = 0;
  FlowGraphInliner::CollectGraphInfo(flow_graph_,
                                     /*constants_count*/ 0,
                                     /*force*/ false, &instruction_count,
                                     &call_site_count);
 
  const Function& top = flow_graph_->function();
  if ((FLAG_inlining_filter != nullptr) &&
      (strstr(top.ToFullyQualifiedCString(), FLAG_inlining_filter) ==
       nullptr)) {
    return 0;
  }
 
  if (trace_inlining()) {
    String& name = String::Handle(top.QualifiedUserVisibleName());
    THR_Print("Inlining calls in %s\n", name.ToCString());
  }
 
  if (FLAG_support_il_printer && trace_inlining() &&
      (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
    THR_Print("Before Inlining of %s\n",
              flow_graph_->function().ToFullyQualifiedCString());
    FlowGraphPrinter printer(*flow_graph_);
    printer.PrintBlocks();
  }
 
  intptr_t inlining_depth_threshold = FLAG_inlining_depth_threshold;
 
  CallSiteInliner inliner(this, inlining_depth_threshold);
  inliner.InlineCalls();
  if (FLAG_print_inlining_tree) {
    inliner.PrintInlinedInfo(top);
  }
 
  if (inliner.inlined()) {
    flow_graph_->DiscoverBlocks();
    if (trace_inlining()) {
      THR_Print("Inlining growth factor: %f\n", inliner.GrowthFactor());
      if (FLAG_support_il_printer &&
          (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();
      }
    }
  }
  return inliner.inlining_depth();
}

NextInlineId()

intptr_t dart::FlowGraphInliner::NextInlineId	(	const Function &	function,
		const InstructionSource &	source
	)

Definition at line 2606 of file inliner.cc.

                                                                         {
  const intptr_t id = inline_id_to_function_->length();
  // TODO(johnmccutchan): Do not allow IsNoSource once all nodes have proper
  // source positions.
  ASSERT(source.token_pos.IsReal() || source.token_pos.IsSynthetic() ||
         source.token_pos.IsNoSource());
  RELEASE_ASSERT(!function.IsNull());
  ASSERT(FunctionType::Handle(function.signature()).IsFinalized());
  inline_id_to_function_->Add(&function);
  inline_id_to_token_pos_->Add(source.token_pos);
  caller_inline_id_->Add(source.inlining_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;
}

SetInliningId()

void dart::FlowGraphInliner::SetInliningId ( FlowGraph *  flow_graph, intptr_t  inlining_id  )

static

Definition at line 2449 of file inliner.cc.

                                                           {
  ASSERT(flow_graph->inlining_id() < 0);
  flow_graph->set_inlining_id(inlining_id);
  // We only need to set the inlining ID on instructions that may possibly
  // have token positions, so no need to set it on blocks or internal
  // definitions.
  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();
      current->set_inlining_id(inlining_id);
    }
  }
}

speculative_policy()

SpeculativeInliningPolicy * dart::FlowGraphInliner::speculative_policy ( )

inline

Definition at line 134 of file inliner.h.

                                                  {
    return speculative_policy_;
  }

trace_inlining()

bool dart::FlowGraphInliner::trace_inlining ( ) const

inline

Definition at line 132 of file inliner.h.

{ return trace_inlining_; }

Friends And Related Symbol Documentation

CallSiteInliner

friend class CallSiteInliner

friend

Definition at line 139 of file inliner.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/compiler/backend/inliner.h
• third_party/dart-lang/sdk/runtime/vm/compiler/backend/inliner.cc