blob: fe115c976bd5d1f77c18b55150a61177106abbd9 [file] [log] [blame]
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#error "AOT runtime should not use compiler sources (including header files)"
#include "vm/allocation.h"
#include "vm/growable_array.h"
#include "vm/token_position.h"
namespace dart {
class Definition;
class Field;
class FlowGraph;
class ForwardInstructionIterator;
class Function;
class FunctionEntryInstr;
class GraphEntryInstr;
class ICData;
class InstanceCallInstr;
class Instruction;
struct InstructionSource;
class Precompiler;
class StaticCallInstr;
class TargetEntryInstr;
class SpeculativeInliningPolicy {
explicit SpeculativeInliningPolicy(bool enable_suppression,
intptr_t limit = -1)
: enable_suppression_(enable_suppression), remaining_(limit) {}
bool AllowsSpeculativeInlining() const {
return !enable_suppression_ || remaining_ > 0;
bool IsAllowedForInlining(intptr_t call_deopt_id) const {
// If we are not supressing, we always enable optimistic inlining.
if (!enable_suppression_) {
return true;
// If we have already suppressed the deopt-id we don't allow inlining it.
if (IsSuppressed(call_deopt_id)) {
return false;
// Allow it if we can bailout at least one more time.
return remaining_ > 0;
bool AddBlockedDeoptId(intptr_t id) {
#if defined(DEBUG)
// If we exhausted the number of suppression entries there is no point
// in adding entries to the list.
if (remaining_ <= 0) return false;
remaining_ -= 1;
return true;
intptr_t length() const { return inlining_suppressions_.length(); }
bool IsSuppressed(intptr_t id) const {
for (intptr_t i = 0; i < inlining_suppressions_.length(); ++i) {
if (inlining_suppressions_[i] == id) return true;
return false;
// Whether we enable supressing inlining at specific deopt-ids.
const bool enable_suppression_;
// After we reach [remaining_] number of deopt-ids in [inlining_suppressions_]
// list, we'll disable speculative inlining entirely.
intptr_t remaining_;
GrowableArray<intptr_t> inlining_suppressions_;
class FlowGraphInliner : ValueObject {
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);
// The flow graph is destructively updated upon inlining. Returns the max
// depth that we inlined.
int Inline();
// Computes graph information (instruction and call site count).
// For the non-specialized cases (num_constants_args == 0), the
// method uses a cache to avoid recomputing the counts (the cached
// value may still be approximate but close). The 'force' flag is
// used to update the cached value at the end of running the full pipeline
// on non-specialized cases. Specialized cases (num_constants_args > 0)
// always recompute the counts without caching.
// TODO(ajcbik): cache for specific constant argument combinations too?
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);
bool AlwaysInline(const Function& function);
static bool FunctionHasPreferInlinePragma(const Function& function);
static bool FunctionHasNeverInlinePragma(const Function& function);
static bool FunctionHasAlwaysConsiderInliningPragma(const Function& function);
FlowGraph* flow_graph() const { return flow_graph_; }
intptr_t NextInlineId(const Function& function,
const InstructionSource& source);
bool trace_inlining() const { return trace_inlining_; }
SpeculativeInliningPolicy* speculative_policy() {
return speculative_policy_;
struct ExactnessInfo {
const bool is_exact;
bool emit_exactness_guard;
static bool TryReplaceInstanceCallWithInline(
FlowGraph* flow_graph,
ForwardInstructionIterator* iterator,
InstanceCallInstr* call,
SpeculativeInliningPolicy* policy);
static bool TryReplaceStaticCallWithInline(
FlowGraph* flow_graph,
ForwardInstructionIterator* iterator,
StaticCallInstr* call,
SpeculativeInliningPolicy* policy);
static bool TryInlineRecognizedMethod(FlowGraph* flow_graph,
intptr_t receiver_cid,
const Function& target,
Definition* call,
Definition* receiver,
const InstructionSource& source,
const ICData* ic_data,
GraphEntryInstr* graph_entry,
FunctionEntryInstr** entry,
Instruction** last,
Definition** result,
SpeculativeInliningPolicy* policy,
ExactnessInfo* exactness = nullptr);
friend class CallSiteInliner;
FlowGraph* flow_graph_;
GrowableArray<const Function*>* inline_id_to_function_;
GrowableArray<TokenPosition>* inline_id_to_token_pos_;
GrowableArray<intptr_t>* caller_inline_id_;
const bool trace_inlining_;
SpeculativeInliningPolicy* speculative_policy_;
Precompiler* precompiler_;
} // namespace dart