v8::internal::HFlowEngine< State, Effects > Class Template Reference

#include <hydrogen-flow-engine.h>

Collaboration diagram for v8::internal::HFlowEngine< State, Effects >:

Public Member Functions
	HFlowEngine (HGraph *graph, Zone *zone)
State *	AnalyzeOneBlock (HBasicBlock *block, State *state)
void	AnalyzeDominatedBlocks (HBasicBlock *root, State *initial)

Private Member Functions
Effects *	ComputeLoopEffects (HBasicBlock *block)
bool	SkipNonDominatedBlock (HBasicBlock *root, HBasicBlock *other)
State *	StateAt (HBasicBlock *block)
void	SetStateAt (HBasicBlock *block, State *state)
void	InitializeStates ()
void	CheckPredecessorCount (HBasicBlock *block)
void	IncrementPredecessorCount (HBasicBlock *block)

Private Attributes
HGraph *	graph_
Zone *	zone_
ZoneList< State * >	block_states_
ZoneList< Effects * >	loop_effects_

Detailed Description

template<class State, class Effects>
class v8::internal::HFlowEngine< State, Effects >

Definition at line 68 of file hydrogen-flow-engine.h.

Constructor & Destructor Documentation

HFlowEngine()

template<class State , class Effects >

v8::internal::HFlowEngine< State, Effects >::HFlowEngine ( HGraph *  graph, Zone *  zone  )

inline

Definition at line 70 of file hydrogen-flow-engine.h.

    : graph_(graph),
      zone_(zone),
#if DEBUG
      pred_counts_(graph->blocks()->length(), zone),
#endif
      block_states_(graph->blocks()->length(), zone),
      loop_effects_(graph->blocks()->length(), zone) {
    loop_effects_.AddBlock(NULL, graph_->blocks()->length(), zone);
  }

References v8::internal::HFlowEngine< State, Effects >::graph_, v8::internal::HFlowEngine< State, Effects >::loop_effects_, and NULL.

Member Function Documentation

AnalyzeDominatedBlocks()

template<class State , class Effects >

void v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks ( HBasicBlock *  root, State *  initial  )

inline

Definition at line 92 of file hydrogen-flow-engine.h.

                                                                 {
    InitializeStates();
    SetStateAt(root, initial);
 
    // Iterate all dominated blocks starting from the given start block.
    for (int i = root->block_id(); i < graph_->blocks()->length(); i++) {
      HBasicBlock* block = graph_->blocks()->at(i);
 
      // Skip blocks not dominated by the root node.
      if (SkipNonDominatedBlock(root, block)) continue;
      State* state = State::Finish(StateAt(block), block, zone_);
 
      if (block->IsReachable()) {
        DCHECK(state != NULL);
        if (block->IsLoopHeader()) {
          // Apply loop effects before analyzing loop body.
          ComputeLoopEffects(block)->Apply(state);
        } else {
          // Must have visited all predecessors before this block.
          CheckPredecessorCount(block);
        }
 
        // Go through all instructions of the current block, updating the state.
        for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
          state = state->Process(it.Current(), zone_);
        }
      }
 
      // Propagate the block state forward to all successor blocks.
      int max = block->end()->SuccessorCount();
      for (int i = 0; i < max; i++) {
        HBasicBlock* succ = block->end()->SuccessorAt(i);
        IncrementPredecessorCount(succ);
 
        if (max == 1 && succ->predecessors()->length() == 1) {
          // Optimization: successor can inherit this state.
          SetStateAt(succ, state);
        } else {
          // Merge the current state with the state already at the successor.
          SetStateAt(succ,
                     State::Merge(StateAt(succ), succ, state, block, zone_));
        }
      }
    }
  }

References v8::internal::Effects< Var, kNoVar >::Apply(), v8::internal::HFlowEngine< State, Effects >::CheckPredecessorCount(), v8::internal::HFlowEngine< State, Effects >::ComputeLoopEffects(), DCHECK, v8::internal::State::Finish(), v8::internal::HFlowEngine< State, Effects >::graph_, v8::internal::HFlowEngine< State, Effects >::IncrementPredecessorCount(), v8::internal::HFlowEngine< State, Effects >::InitializeStates(), v8::internal::State::Merge(), NULL, v8::internal::State::Process(), v8::internal::HFlowEngine< State, Effects >::SetStateAt(), v8::internal::HFlowEngine< State, Effects >::SkipNonDominatedBlock(), v8::internal::HFlowEngine< State, Effects >::StateAt(), and v8::internal::HFlowEngine< State, Effects >::zone_.

Referenced by v8::internal::HCheckEliminationPhase::Run(), v8::internal::HLoadEliminationPhase::Run(), and v8::internal::HMergeRemovableSimulatesPhase::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

AnalyzeOneBlock()

template<class State , class Effects >

State* v8::internal::HFlowEngine< State, Effects >::AnalyzeOneBlock ( HBasicBlock *  block, State *  state  )

inline

Definition at line 82 of file hydrogen-flow-engine.h.

                                                           {
    // Go through all instructions of the current block, updating the state.
    for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
      state = state->Process(it.Current(), zone_);
    }
    return state;
  }

References v8::internal::State::Process(), and v8::internal::HFlowEngine< State, Effects >::zone_.

Referenced by v8::internal::HCheckEliminationPhase::Run(), and v8::internal::HLoadEliminationPhase::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckPredecessorCount()

template<class State , class Effects >

void v8::internal::HFlowEngine< State, Effects >::CheckPredecessorCount ( HBasicBlock *  block )

inlineprivate

Definition at line 197 of file hydrogen-flow-engine.h.

                                                        {
    DCHECK(block->predecessors()->length() == pred_counts_[block->block_id()]);
  }

References DCHECK.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the caller graph for this function:

ComputeLoopEffects()

template<class State , class Effects >

Effects* v8::internal::HFlowEngine< State, Effects >::ComputeLoopEffects ( HBasicBlock *  block )

inlineprivate

Definition at line 141 of file hydrogen-flow-engine.h.

                                                  {
    DCHECK(block->IsLoopHeader());
    Effects* effects = loop_effects_[block->block_id()];
    if (effects != NULL) return effects;  // Already analyzed this loop.
 
    effects = new(zone_) Effects(zone_);
    loop_effects_[block->block_id()] = effects;
    if (effects->Disabled()) return effects;  // No effects for this analysis.
 
    HLoopInformation* loop = block->loop_information();
    int end = loop->GetLastBackEdge()->block_id();
    // Process the blocks between the header and the end.
    for (int i = block->block_id(); i <= end; i++) {
      HBasicBlock* member = graph_->blocks()->at(i);
      if (i != block->block_id() && member->IsLoopHeader()) {
        // Recursively compute and cache the effects of the nested loop.
        DCHECK(member->loop_information()->parent_loop() == loop);
        Effects* nested = ComputeLoopEffects(member);
        effects->Union(nested, zone_);
        // Skip the nested loop's blocks.
        i = member->loop_information()->GetLastBackEdge()->block_id();
      } else {
        // Process all the effects of the block.
        if (member->IsUnreachable()) continue;
        DCHECK(member->current_loop() == loop);
        for (HInstructionIterator it(member); !it.Done(); it.Advance()) {
          effects->Process(it.Current(), zone_);
        }
      }
    }
    return effects;
  }

References DCHECK, v8::internal::Effects< Var, kNoVar >::Disabled(), v8::internal::HFlowEngine< State, Effects >::graph_, v8::internal::HFlowEngine< State, Effects >::loop_effects_, NULL, v8::internal::Effects< Var, kNoVar >::Process(), v8::internal::Effects< Var, kNoVar >::Union(), and v8::internal::HFlowEngine< State, Effects >::zone_.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

IncrementPredecessorCount()

template<class State , class Effects >

void v8::internal::HFlowEngine< State, Effects >::IncrementPredecessorCount ( HBasicBlock *  block )

inlineprivate

Definition at line 201 of file hydrogen-flow-engine.h.

                                                            {
#if DEBUG
    pred_counts_[block->block_id()]++;
#endif
  }

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the caller graph for this function:

InitializeStates()

template<class State , class Effects >

void v8::internal::HFlowEngine< State, Effects >::InitializeStates ( )

inlineprivate

Definition at line 188 of file hydrogen-flow-engine.h.

                                 {
#if DEBUG
    pred_counts_.Rewind(0);
    pred_counts_.AddBlock(0, graph_->blocks()->length(), zone_);
#endif
    block_states_.Rewind(0);
    block_states_.AddBlock(NULL, graph_->blocks()->length(), zone_);
  }

References v8::internal::HFlowEngine< State, Effects >::block_states_, v8::internal::HFlowEngine< State, Effects >::graph_, NULL, and v8::internal::HFlowEngine< State, Effects >::zone_.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the caller graph for this function:

SetStateAt()

template<class State , class Effects >

void v8::internal::HFlowEngine< State, Effects >::SetStateAt ( HBasicBlock *  block, State *  state  )

inlineprivate

Definition at line 184 of file hydrogen-flow-engine.h.

                                                           {
    block_states_.Set(block->block_id(), state);
  }

References v8::internal::HFlowEngine< State, Effects >::block_states_.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the caller graph for this function:

SkipNonDominatedBlock()

template<class State , class Effects >

bool v8::internal::HFlowEngine< State, Effects >::SkipNonDominatedBlock ( HBasicBlock *  root, HBasicBlock *  other  )

inlineprivate

Definition at line 174 of file hydrogen-flow-engine.h.

                                                                           {
    if (root->block_id() == 0) return false;  // Visit the whole graph.
    if (root == other) return false;          // Always visit the root.
    return !root->Dominates(other);           // Only visit dominated blocks.
  }

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the caller graph for this function:

StateAt()

template<class State , class Effects >

State* v8::internal::HFlowEngine< State, Effects >::StateAt ( HBasicBlock *  block )

inlineprivate

Definition at line 180 of file hydrogen-flow-engine.h.

                                            {
    return block_states_.at(block->block_id());
  }

References v8::internal::HFlowEngine< State, Effects >::block_states_.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks().

Here is the caller graph for this function:

Member Data Documentation

block_states_

template<class State , class Effects >

ZoneList<State*> v8::internal::HFlowEngine< State, Effects >::block_states_

private

Definition at line 212 of file hydrogen-flow-engine.h.

Referenced by v8::internal::HFlowEngine< State, Effects >::InitializeStates(), v8::internal::HFlowEngine< State, Effects >::SetStateAt(), and v8::internal::HFlowEngine< State, Effects >::StateAt().

graph_

template<class State , class Effects >

HGraph* v8::internal::HFlowEngine< State, Effects >::graph_

private

Definition at line 207 of file hydrogen-flow-engine.h.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks(), v8::internal::HFlowEngine< State, Effects >::ComputeLoopEffects(), v8::internal::HFlowEngine< State, Effects >::HFlowEngine(), and v8::internal::HFlowEngine< State, Effects >::InitializeStates().

loop_effects_

template<class State , class Effects >

ZoneList<Effects*> v8::internal::HFlowEngine< State, Effects >::loop_effects_

private

Definition at line 213 of file hydrogen-flow-engine.h.

Referenced by v8::internal::HFlowEngine< State, Effects >::ComputeLoopEffects(), and v8::internal::HFlowEngine< State, Effects >::HFlowEngine().

zone_

template<class State , class Effects >

Zone* v8::internal::HFlowEngine< State, Effects >::zone_

private

Definition at line 208 of file hydrogen-flow-engine.h.

Referenced by v8::internal::HFlowEngine< State, Effects >::AnalyzeDominatedBlocks(), v8::internal::HFlowEngine< State, Effects >::AnalyzeOneBlock(), v8::internal::HFlowEngine< State, Effects >::ComputeLoopEffects(), and v8::internal::HFlowEngine< State, Effects >::InitializeStates().

---

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

• /mnt/V8SourceCode/src/hydrogen-flow-engine.h