dart::GraphInfoCollector Class Reference

Inheritance diagram for dart::GraphInfoCollector:

Public Member Functions
	GraphInfoCollector ()
void	Collect (const FlowGraph &graph)
intptr_t	call_site_count () const
intptr_t	instruction_count () const
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Detailed Description

Definition at line 151 of file inliner.cc.

Constructor & Destructor Documentation

GraphInfoCollector()

dart::GraphInfoCollector::GraphInfoCollector ( )

inline

Definition at line 153 of file inliner.cc.

: call_site_count_(0), instruction_count_(0) {}

Member Function Documentation

call_site_count()

intptr_t dart::GraphInfoCollector::call_site_count ( ) const

inline

Definition at line 214 of file inliner.cc.

{ return call_site_count_; }

Collect()

void dart::GraphInfoCollector::Collect ( const FlowGraph &  graph )

inline

Definition at line 155 of file inliner.cc.

                                       {
    call_site_count_ = 0;
    instruction_count_ = 0;
    for (BlockIterator block_it = graph.postorder_iterator(); !block_it.Done();
         block_it.Advance()) {
      // Skip any blocks from the prologue to make them not count towards the
      // inlining instruction budget.
      const intptr_t block_id = block_it.Current()->block_id();
      if (graph.prologue_info().Contains(block_id)) {
        continue;
      }
 
      for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
           it.Advance()) {
        Instruction* current = it.Current();
        // Don't count instructions that won't generate any code.
        if (current->IsRedefinition()) {
          continue;
        }
        // UnboxedConstant is often folded into the indexing
        // instructions (similar to Constant instructions which
        // belong to initial definitions and not counted here).
        if (current->IsUnboxedConstant()) {
          continue;
        }
        ++instruction_count_;
        // Count inputs of certain instructions as if separate MoveArgument
        // instructions are used for inputs. This is done in order to
        // preserve inlining behavior and avoid code size growth after
        // MoveArgument insertion was moved to the end of the
        // compilation pipeline.
        if (current->IsAllocateObject()) {
          instruction_count_ += current->InputCount();
        } else if (current->ArgumentCount() > 0) {
          ASSERT(!current->HasMoveArguments());
          instruction_count_ += current->ArgumentCount();
        }
        if (current->IsInstanceCall() || current->IsStaticCall() ||
            current->IsClosureCall()) {
          ++call_site_count_;
          continue;
        }
        if (current->IsPolymorphicInstanceCall()) {
          PolymorphicInstanceCallInstr* call =
              current->AsPolymorphicInstanceCall();
          // These checks make sure that the number of call-sites counted does
          // not change relative to the time when the current set of inlining
          // parameters was fixed.
          // TODO(fschneider): Determine new heuristic parameters that avoid
          // these checks entirely.
          if (!call->IsSureToCallSingleRecognizedTarget() &&
              (call->token_kind() != Token::kEQ)) {
            ++call_site_count_;
          }
        }
      }
    }
  }

instruction_count()

intptr_t dart::GraphInfoCollector::instruction_count ( ) const

inline

Definition at line 215 of file inliner.cc.

{ return instruction_count_; }

---

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

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