#include <il.h>

Inheritance diagram for dart::BlockEntryInstr:

Classes
class	InstructionsIterable

Public Member Functions
virtual intptr_t	PredecessorCount () const =0

virtual BlockEntryInstr *	PredecessorAt (intptr_t index) const =0

intptr_t	preorder_number () const

void	set_preorder_number (intptr_t number)

intptr_t	postorder_number () const

void	set_postorder_number (intptr_t number)

intptr_t	block_id () const

void	set_start_pos (intptr_t pos)

intptr_t	start_pos () const

void	set_end_pos (intptr_t pos)

intptr_t	end_pos () const

BlockEntryInstr *	dominator () const

BlockEntryInstr *	ImmediateDominator () const

const GrowableArray< BlockEntryInstr * > &	dominated_blocks ()

void	AddDominatedBlock (BlockEntryInstr *block)

void	ClearDominatedBlocks ()

bool	Dominates (BlockEntryInstr *other) const

Instruction *	last_instruction () const

void	set_last_instruction (Instruction *instr)

ParallelMoveInstr *	parallel_move () const

bool	HasParallelMove () const

bool	HasNonRedundantParallelMove () const

ParallelMoveInstr *	GetParallelMove ()

bool	DiscoverBlock (BlockEntryInstr predecessor, GrowableArray< BlockEntryInstr > preorder, GrowableArray< intptr_t > parent)

virtual bool	CanBecomeDeoptimizationTarget () const

virtual bool	ComputeCanDeoptimize () const

virtual bool	HasUnknownSideEffects () const

intptr_t	try_index () const

void	set_try_index (intptr_t index)

bool	InsideTryBlock () const

LoopInfo *	loop_info () const

void	set_loop_info (LoopInfo *loop_info)

bool	IsLoopHeader () const

intptr_t	NestingDepth () const

virtual BlockEntryInstr *	GetBlock ()

virtual TokenPosition	token_pos () const

void	ReplaceAsPredecessorWith (BlockEntryInstr *new_block)

void	set_block_id (intptr_t block_id)

intptr_t	stack_depth () const

void	set_stack_depth (intptr_t s)

void	ClearAllInstructions ()

InstructionsIterable	instructions ()

Public Member Functions inherited from dart::TemplateInstruction< 0, NoThrow >
	TemplateInstruction (intptr_t deopt_id=DeoptId::kNone)

	TemplateInstruction (const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)

virtual intptr_t	InputCount () const

virtual Value *	InputAt (intptr_t i) const

virtual bool	MayThrow () const

Protected Member Functions
	BlockEntryInstr (intptr_t block_id, intptr_t try_index, intptr_t deopt_id, intptr_t stack_depth)

bool	FindOsrEntryAndRelink (GraphEntryInstr graph_entry, Instruction parent, BitVector *block_marks)

Private Member Functions
virtual void	ClearPredecessors ()=0

virtual void	AddPredecessor (BlockEntryInstr *predecessor)=0

Additional Inherited Members
Public Types inherited from dart::TemplateInstruction< 0, NoThrow >
using	BaseClass = typename NoCSE< Instruction, PureInstruction >::Base

Protected Attributes inherited from dart::TemplateInstruction< 0, NoThrow >
EmbeddedArray< Value *, N >	inputs_

Detailed Description

Definition at line 1644 of file il.h.

Constructor & Destructor Documentation

◆ BlockEntryInstr()

dart::BlockEntryInstr::BlockEntryInstr	(	intptr_t	block_id,
		intptr_t	try_index,
		intptr_t	deopt_id,
		intptr_t	stack_depth
	)

inlineprotected

Definition at line 1776 of file il.h.

      : TemplateInstruction(deopt_id),
        block_id_(block_id),
        try_index_(try_index),
        stack_depth_(stack_depth),
        dominated_blocks_(1) {}

Member Function Documentation

◆ AddDominatedBlock()

void dart::BlockEntryInstr::AddDominatedBlock ( BlockEntryInstr * block )

inline

Definition at line 1671 of file il.h.

                                                 {
    ASSERT(!block->IsFunctionEntry() || this->IsGraphEntry());
    block->set_dominator(this);
    dominated_blocks_.Add(block);
  }

◆ AddPredecessor()

virtual void dart::BlockEntryInstr::AddPredecessor ( BlockEntryInstr * predecessor )

privatepure virtual

Implemented in dart::GraphEntryInstr, dart::JoinEntryInstr, dart::TargetEntryInstr, dart::FunctionEntryInstr, dart::OsrEntryInstr, and dart::CatchBlockEntryInstr.

◆ block_id()

intptr_t dart::BlockEntryInstr::block_id ( ) const

inline

Definition at line 1655 of file il.h.

1655{ return block_id_; }

◆ CanBecomeDeoptimizationTarget()

virtual bool dart::BlockEntryInstr::CanBecomeDeoptimizationTarget ( ) const

inlinevirtual

Definition at line 1714 of file il.h.

                                                     {
    // BlockEntry environment is copied to Goto and Branch instructions
    // when we insert new blocks targeting this block.
    return true;
  }

◆ ClearAllInstructions()

void dart::BlockEntryInstr::ClearAllInstructions ( )

Definition at line 1896 of file il.cc.

                                           {
  JoinEntryInstr* join = this->AsJoinEntry();
  if (join != nullptr) {
    for (PhiIterator it(join); !it.Done(); it.Advance()) {
      it.Current()->UnuseAllInputs();
    }
  }
  UnuseAllInputs();
  for (ForwardInstructionIterator it(this); !it.Done(); it.Advance()) {
    it.Current()->UnuseAllInputs();
  }
}

◆ ClearDominatedBlocks()

void dart::BlockEntryInstr::ClearDominatedBlocks ( )

inline

Definition at line 1676 of file il.h.

1676{ dominated_blocks_.Clear(); }

◆ ClearPredecessors()

virtual void dart::BlockEntryInstr::ClearPredecessors ( )

privatepure virtual

Implemented in dart::GraphEntryInstr, dart::JoinEntryInstr, dart::TargetEntryInstr, dart::FunctionEntryInstr, dart::OsrEntryInstr, and dart::CatchBlockEntryInstr.

◆ ComputeCanDeoptimize()

virtual bool dart::BlockEntryInstr::ComputeCanDeoptimize ( ) const

inlinevirtual

Definition at line 1720 of file il.h.

1720{ return false; }

◆ DiscoverBlock()

bool dart::BlockEntryInstr::DiscoverBlock	(	BlockEntryInstr *	predecessor,
		GrowableArray< BlockEntryInstr * > *	preorder,
		GrowableArray< intptr_t > *	parent
	)

Definition at line 1690 of file il.cc.

                                                                     {
  // If this block has a predecessor (i.e., is not the graph entry) we can
  // assume the preorder array is non-empty.
  ASSERT((predecessor == nullptr) || !preorder->is_empty());
  // Blocks with a single predecessor cannot have been reached before.
  ASSERT(IsJoinEntry() || !IsMarked(this, preorder));
 
  // 1. If the block has already been reached, add current_block as a
  // basic-block predecessor and we are done.
  if (IsMarked(this, preorder)) {
    ASSERT(predecessor != nullptr);
    AddPredecessor(predecessor);
    return false;
  }
 
  // 2. Otherwise, clear the predecessors which might have been computed on
  // some earlier call to DiscoverBlocks and record this predecessor.
  ClearPredecessors();
  if (predecessor != nullptr) AddPredecessor(predecessor);
 
  // 3. The predecessor is the spanning-tree parent.  The graph entry has no
  // parent, indicated by -1.
  intptr_t parent_number =
      (predecessor == nullptr) ? -1 : predecessor->preorder_number();
  parent->Add(parent_number);
 
  // 4. Assign the preorder number and add the block entry to the list.
  set_preorder_number(preorder->length());
  preorder->Add(this);
 
  // The preorder and parent arrays are indexed by
  // preorder block number, so they should stay in lockstep.
  ASSERT(preorder->length() == parent->length());
 
  // 5. Iterate straight-line successors to record assigned variables and
  // find the last instruction in the block.  The graph entry block consists
  // of only the entry instruction, so that is the last instruction in the
  // block.
  Instruction* last = this;
  for (ForwardInstructionIterator it(this); !it.Done(); it.Advance()) {
    last = it.Current();
  }
  set_last_instruction(last);
  if (last->IsGoto()) last->AsGoto()->set_block(this);
 
  return true;
}

◆ dominated_blocks()

const GrowableArray< BlockEntryInstr * > & dart::BlockEntryInstr::dominated_blocks ( )

inline

Definition at line 1667 of file il.h.

                                                            {
    return dominated_blocks_;
  }

◆ Dominates()

bool dart::BlockEntryInstr::Dominates ( BlockEntryInstr * other ) const

Definition at line 1806 of file il.cc.

                                                            {
  // TODO(fschneider): Make this faster by e.g. storing dominators for each
  // block while computing the dominator tree.
  ASSERT(other != nullptr);
  BlockEntryInstr* current = other;
  while (current != nullptr && current != this) {
    current = current->dominator();
  }
  return current == this;
}

◆ dominator()

BlockEntryInstr * dart::BlockEntryInstr::dominator ( ) const

inline

Definition at line 1664 of file il.h.

1664{ return dominator_; }

◆ end_pos()

intptr_t dart::BlockEntryInstr::end_pos ( ) const

inline

Definition at line 1662 of file il.h.

1662{ return end_pos_; }

◆ FindOsrEntryAndRelink()

bool dart::BlockEntryInstr::FindOsrEntryAndRelink	(	GraphEntryInstr *	graph_entry,
		Instruction *	parent,
		BitVector *	block_marks
	)

protected

Definition at line 1747 of file il.cc.

                                                                    {
  const intptr_t osr_id = graph_entry->osr_id();
 
  // Search for the instruction with the OSR id.  Use a depth first search
  // because basic blocks have not been discovered yet.  Prune unreachable
  // blocks by replacing the normal entry with a jump to the block
  // containing the OSR entry point.
 
  // Do not visit blocks more than once.
  if (block_marks->Contains(block_id())) return false;
  block_marks->Add(block_id());
 
  // Search this block for the OSR id.
  Instruction* instr = this;
  for (ForwardInstructionIterator it(this); !it.Done(); it.Advance()) {
    instr = it.Current();
    if (instr->GetDeoptId() == osr_id) {
      // Sanity check that we found a stack check instruction.
      ASSERT(instr->IsCheckStackOverflow());
      // Loop stack check checks are always in join blocks so that they can
      // be the target of a goto.
      ASSERT(IsJoinEntry());
      // The instruction should be the first instruction in the block so
      // we can simply jump to the beginning of the block.
      ASSERT(instr->previous() == this);
 
      ASSERT(stack_depth() == instr->AsCheckStackOverflow()->stack_depth());
      auto normal_entry = graph_entry->normal_entry();
      auto osr_entry = new OsrEntryInstr(
          graph_entry, normal_entry->block_id(), normal_entry->try_index(),
          normal_entry->deopt_id(), stack_depth());
 
      auto goto_join = new GotoInstr(AsJoinEntry(),
                                     CompilerState::Current().GetNextDeoptId());
      ASSERT(parent != nullptr);
      goto_join->CopyDeoptIdFrom(*parent);
      osr_entry->LinkTo(goto_join);
 
      // Remove normal function entries & add osr entry.
      graph_entry->set_normal_entry(nullptr);
      graph_entry->set_unchecked_entry(nullptr);
      graph_entry->set_osr_entry(osr_entry);
 
      return true;
    }
  }
 
  // Recursively search the successors.
  for (intptr_t i = instr->SuccessorCount() - 1; i >= 0; --i) {
    if (instr->SuccessorAt(i)->FindOsrEntryAndRelink(graph_entry, instr,
                                                     block_marks)) {
      return true;
    }
  }
  return false;
}

◆ GetBlock()

virtual BlockEntryInstr * dart::BlockEntryInstr::GetBlock ( )

inlinevirtual

Definition at line 1736 of file il.h.

1736{ return this; }

◆ GetParallelMove()

ParallelMoveInstr * dart::BlockEntryInstr::GetParallelMove ( )

inline

Definition at line 1691 of file il.h.

                                       {
    if (parallel_move_ == nullptr) {
      parallel_move_ = new ParallelMoveInstr();
    }
    return parallel_move_;
  }

◆ HasNonRedundantParallelMove()

bool dart::BlockEntryInstr::HasNonRedundantParallelMove ( ) const

inline

Definition at line 1687 of file il.h.

                                           {
    return HasParallelMove() && !parallel_move()->IsRedundant();
  }

◆ HasParallelMove()

bool dart::BlockEntryInstr::HasParallelMove ( ) const

inline

Definition at line 1685 of file il.h.

1685{ return parallel_move_ != nullptr; }

◆ HasUnknownSideEffects()

virtual bool dart::BlockEntryInstr::HasUnknownSideEffects ( ) const

inlinevirtual

Reimplemented in dart::JoinEntryInstr.

Definition at line 1722 of file il.h.

1722{ return false; }

◆ ImmediateDominator()

BlockEntryInstr * dart::BlockEntryInstr::ImmediateDominator ( ) const

Definition at line 1817 of file il.cc.

                                                           {
  Instruction* last = dominator()->last_instruction();
  if ((last->SuccessorCount() == 1) && (last->SuccessorAt(0) == this)) {
    return dominator();
  }
  return nullptr;
}

◆ InsideTryBlock()

bool dart::BlockEntryInstr::InsideTryBlock ( ) const

inline

Definition at line 1728 of file il.h.

1728{ return try_index_ != kInvalidTryIndex; }

dart::kInvalidTryIndex

static constexpr intptr_t kInvalidTryIndex

Definition code_descriptors.h:17

◆ instructions()

InstructionsIterable dart::BlockEntryInstr::instructions ( )

inline

Definition at line 1768 of file il.h.

1768{ return InstructionsIterable(this); }

◆ IsLoopHeader()

bool dart::BlockEntryInstr::IsLoopHeader ( ) const

Definition at line 1825 of file il.cc.

                                         {
  return loop_info_ != nullptr && loop_info_->header() == this;
}

◆ last_instruction()

Instruction * dart::BlockEntryInstr::last_instruction ( ) const

inline

Definition at line 1680 of file il.h.

1680{ return last_instruction_; }

◆ loop_info()

LoopInfo * dart::BlockEntryInstr::loop_info ( ) const

inline

Definition at line 1731 of file il.h.

1731{ return loop_info_; }

◆ NestingDepth()

intptr_t dart::BlockEntryInstr::NestingDepth ( ) const

Definition at line 1829 of file il.cc.

                                             {
  return loop_info_ == nullptr ? 0 : loop_info_->NestingDepth();
}

◆ parallel_move()

ParallelMoveInstr * dart::BlockEntryInstr::parallel_move ( ) const

inline

Definition at line 1683 of file il.h.

1683{ return parallel_move_; }

◆ postorder_number()

intptr_t dart::BlockEntryInstr::postorder_number ( ) const

inline

Definition at line 1652 of file il.h.

1652{ return postorder_number_; }

◆ PredecessorAt()

virtual BlockEntryInstr * dart::BlockEntryInstr::PredecessorAt ( intptr_t index ) const

pure virtual

Implemented in dart::GraphEntryInstr, dart::JoinEntryInstr, dart::TargetEntryInstr, dart::FunctionEntryInstr, dart::OsrEntryInstr, and dart::CatchBlockEntryInstr.

◆ PredecessorCount()

virtual intptr_t dart::BlockEntryInstr::PredecessorCount ( ) const

pure virtual

Implemented in dart::GraphEntryInstr, dart::JoinEntryInstr, dart::TargetEntryInstr, dart::FunctionEntryInstr, dart::OsrEntryInstr, and dart::CatchBlockEntryInstr.

◆ preorder_number()

intptr_t dart::BlockEntryInstr::preorder_number ( ) const

inline

Definition at line 1649 of file il.h.

1649{ return preorder_number_; }

◆ ReplaceAsPredecessorWith()

void dart::BlockEntryInstr::ReplaceAsPredecessorWith ( BlockEntryInstr * new_block )

Definition at line 1838 of file il.cc.

                                                                         {
  // Set the last instruction of the new block to that of the old block.
  Instruction* last = last_instruction();
  new_block->set_last_instruction(last);
  // For each successor, update the predecessors.
  for (intptr_t sidx = 0; sidx < last->SuccessorCount(); ++sidx) {
    // If the successor is a target, update its predecessor.
    TargetEntryInstr* target = last->SuccessorAt(sidx)->AsTargetEntry();
    if (target != nullptr) {
      target->predecessor_ = new_block;
      continue;
    }
    // If the successor is a join, update each predecessor and the phis.
    JoinEntryInstr* join = last->SuccessorAt(sidx)->AsJoinEntry();
    ASSERT(join != nullptr);
    // Find the old predecessor index.
    intptr_t old_index = join->IndexOfPredecessor(this);
    intptr_t pred_count = join->PredecessorCount();
    ASSERT(old_index >= 0);
    ASSERT(old_index < pred_count);
    // Find the new predecessor index while reordering the predecessors.
    intptr_t new_id = new_block->block_id();
    intptr_t new_index = old_index;
    if (block_id() < new_id) {
      // Search upwards, bubbling down intermediate predecessors.
      for (; new_index < pred_count - 1; ++new_index) {
        if (join->predecessors_[new_index + 1]->block_id() > new_id) break;
        join->predecessors_[new_index] = join->predecessors_[new_index + 1];
      }
    } else {
      // Search downwards, bubbling up intermediate predecessors.
      for (; new_index > 0; --new_index) {
        if (join->predecessors_[new_index - 1]->block_id() < new_id) break;
        join->predecessors_[new_index] = join->predecessors_[new_index - 1];
      }
    }
    join->predecessors_[new_index] = new_block;
    // If the new and old predecessor index match there is nothing to update.
    if ((join->phis() == nullptr) || (old_index == new_index)) return;
    // Otherwise, reorder the predecessor uses in each phi.
    for (PhiIterator it(join); !it.Done(); it.Advance()) {
      PhiInstr* phi = it.Current();
      ASSERT(phi != nullptr);
      ASSERT(pred_count == phi->InputCount());
      // Save the predecessor use.
      Value* pred_use = phi->InputAt(old_index);
      // Move uses between old and new.
      intptr_t step = (old_index < new_index) ? 1 : -1;
      for (intptr_t use_idx = old_index; use_idx != new_index;
           use_idx += step) {
        phi->SetInputAt(use_idx, phi->InputAt(use_idx + step));
      }
      // Write the predecessor use.
      phi->SetInputAt(new_index, pred_use);
    }
  }
}

◆ set_block_id()

void dart::BlockEntryInstr::set_block_id ( intptr_t block_id )

inline

Definition at line 1747 of file il.h.

1747{ block_id_ = block_id; }

◆ set_end_pos()

void dart::BlockEntryInstr::set_end_pos ( intptr_t pos )

inline

Definition at line 1661 of file il.h.

1661{ end_pos_ = pos; }

pos

SkPoint pos

Definition ImageShaderTest.cpp:27

◆ set_last_instruction()

void dart::BlockEntryInstr::set_last_instruction ( Instruction * instr )

inline

Definition at line 1681 of file il.h.

1681{ last_instruction_ = instr; }

◆ set_loop_info()

void dart::BlockEntryInstr::set_loop_info ( LoopInfo * loop_info )

inline

Definition at line 1732 of file il.h.

1732{ loop_info_ = loop_info; }

dart::BlockEntryInstr::loop_info

LoopInfo * loop_info() const

Definition il.h:1731

◆ set_postorder_number()

void dart::BlockEntryInstr::set_postorder_number ( intptr_t number )

inline

Definition at line 1653 of file il.h.

1653{ postorder_number_ = number; }

◆ set_preorder_number()

void dart::BlockEntryInstr::set_preorder_number ( intptr_t number )

inline

Definition at line 1650 of file il.h.

1650{ preorder_number_ = number; }

◆ set_stack_depth()

void dart::BlockEntryInstr::set_stack_depth ( intptr_t s )

inline

Definition at line 1751 of file il.h.

1751{ stack_depth_ = s; }

s

struct MyStruct s

◆ set_start_pos()

void dart::BlockEntryInstr::set_start_pos ( intptr_t pos )

inline

Definition at line 1659 of file il.h.

1659{ start_pos_ = pos; }

◆ set_try_index()

void dart::BlockEntryInstr::set_try_index ( intptr_t index )

inline

Definition at line 1725 of file il.h.

1725{ try_index_ = index; }

◆ stack_depth()

intptr_t dart::BlockEntryInstr::stack_depth ( ) const

inline

Definition at line 1750 of file il.h.

1750{ return stack_depth_; }

◆ start_pos()

intptr_t dart::BlockEntryInstr::start_pos ( ) const

inline

Definition at line 1660 of file il.h.

1660{ return start_pos_; }

◆ token_pos()

virtual TokenPosition dart::BlockEntryInstr::token_pos ( ) const

inlinevirtual

Definition at line 1738 of file il.h.

                                          {
    return TokenPosition::kControlFlow;
  }

◆ try_index()

intptr_t dart::BlockEntryInstr::try_index ( ) const

inline

Definition at line 1724 of file il.h.

1724{ return try_index_; }

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

third_party/dart-lang/sdk/runtime/vm/compiler/backend/il.h
third_party/dart-lang/sdk/runtime/vm/compiler/backend/il.cc
third_party/dart-lang/sdk/runtime/vm/compiler/backend/il_serializer.cc

Classes

Public Member Functions

Protected Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BlockEntryInstr()

Member Function Documentation

◆ AddDominatedBlock()

◆ AddPredecessor()

◆ block_id()

◆ CanBecomeDeoptimizationTarget()

◆ ClearAllInstructions()

◆ ClearDominatedBlocks()

◆ ClearPredecessors()

◆ ComputeCanDeoptimize()

◆ DiscoverBlock()

◆ dominated_blocks()

◆ Dominates()

◆ dominator()

◆ end_pos()

◆ FindOsrEntryAndRelink()

◆ GetBlock()

◆ GetParallelMove()

◆ HasNonRedundantParallelMove()

◆ HasParallelMove()

◆ HasUnknownSideEffects()

◆ ImmediateDominator()

◆ InsideTryBlock()

◆ instructions()

◆ IsLoopHeader()

◆ last_instruction()

◆ loop_info()

◆ NestingDepth()

◆ parallel_move()

◆ postorder_number()

◆ PredecessorAt()

◆ PredecessorCount()

◆ preorder_number()

◆ ReplaceAsPredecessorWith()

◆ set_block_id()

◆ set_end_pos()

◆ set_last_instruction()

◆ set_loop_info()

◆ set_postorder_number()

◆ set_preorder_number()

◆ set_stack_depth()

◆ set_start_pos()

◆ set_try_index()

◆ stack_depth()

◆ start_pos()

◆ token_pos()

◆ try_index()