v8::internal::State Class Reference

Inheritance diagram for v8::internal::State:

Collaboration diagram for v8::internal::State:

Public Member Functions
	State (Zone *zone)
State *	Process (HInstruction *instr, Zone *zone)
Public Member Functions inherited from v8::internal::ZoneObject
	INLINE (void *operator new(size_t size, Zone *zone))
void	operator delete (void *, size_t)
void	operator delete (void *pointer, Zone *zone)

Static Public Member Functions
static State *	Merge (State *succ_state, HBasicBlock *succ_block, State *pred_state, HBasicBlock *pred_block, Zone *zone)
static State *	Finish (State *state, HBasicBlock *block, Zone *zone)

Private Types
enum	Mode { NORMAL , COLLECT_CONSECUTIVE_SIMULATES }

Private Member Functions
	State (const State &other)
bool	HasRememberedSimulates () const
void	Remember (HSimulate *sim)
void	FlushSimulates ()
void	RemoveSimulates ()
State *	Copy (HBasicBlock *succ_block, HBasicBlock *pred_block, Zone *zone)
State *	Merge (HBasicBlock *succ_block, State *pred_state, HBasicBlock *pred_block, Zone *zone)

Private Attributes
Zone *	zone_
ZoneList< HSimulate * >	mergelist_
bool	first_
Mode	mode_

Detailed Description

Definition at line 12 of file hydrogen-removable-simulates.cc.

Member Enumeration Documentation

Mode

enum v8::internal::State::Mode

private

Enumerator
NORMAL
COLLECT_CONSECUTIVE_SIMULATES

Definition at line 117 of file hydrogen-removable-simulates.cc.

{ NORMAL, COLLECT_CONSECUTIVE_SIMULATES };

Constructor & Destructor Documentation

State() [1/2]

v8::internal::State::State ( Zone *  zone )

inlineexplicit

Definition at line 14 of file hydrogen-removable-simulates.cc.

      : zone_(zone), mergelist_(2, zone), first_(true), mode_(NORMAL) { }

Referenced by Copy().

Here is the caller graph for this function:

State() [2/2]

v8::internal::State::State ( const State &  other )

inlineexplicitprivate

Definition at line 111 of file hydrogen-removable-simulates.cc.

      : zone_(other.zone_),
        mergelist_(other.mergelist_, other.zone_),
        first_(other.first_),
        mode_(other.mode_) { }

Member Function Documentation

Copy()

State* v8::internal::State::Copy ( HBasicBlock *  succ_block, HBasicBlock *  pred_block, Zone *  zone  )

inlineprivate

Definition at line 137 of file hydrogen-removable-simulates.cc.

                                                                            {
    State* copy = new(zone) State(*this);
    if (FLAG_trace_removable_simulates) {
      PrintF("[copy state %p from B%d to new state %p for B%d]\n",
             reinterpret_cast<void*>(this), pred_block->block_id(),
             reinterpret_cast<void*>(copy), succ_block->block_id());
    }
    return copy;
  }

References v8::internal::PrintF(), and State().

Referenced by Merge().

Here is the call graph for this function:

Here is the caller graph for this function:

Finish()

static State* v8::internal::State::Finish ( State *  state, HBasicBlock *  block, Zone *  zone  )

inlinestatic

Definition at line 96 of file hydrogen-removable-simulates.cc.

                                                                     {
    if (FLAG_trace_removable_simulates) {
      PrintF("[preparing state %p for B%d]\n", reinterpret_cast<void*>(state),
             block->block_id());
    }
    // For our current local analysis, we should not remember simulates across
    // block boundaries.
    DCHECK(!state->HasRememberedSimulates());
    // Nasty heuristic: Never remove the first simulate in a block. This
    // just so happens to have a beneficial effect on register allocation.
    state->first_ = true;
    return state;
  }

References DCHECK, first_, HasRememberedSimulates(), and v8::internal::PrintF().

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

Here is the call graph for this function:

Here is the caller graph for this function:

FlushSimulates()

void v8::internal::State::FlushSimulates ( )

inlineprivate

Definition at line 125 of file hydrogen-removable-simulates.cc.

                        {
    if (HasRememberedSimulates()) {
      mergelist_.RemoveLast()->MergeWith(&mergelist_);
    }
  }

References HasRememberedSimulates(), and mergelist_.

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

HasRememberedSimulates()

bool v8::internal::State::HasRememberedSimulates ( ) const

inlineprivate

Definition at line 119 of file hydrogen-removable-simulates.cc.

{ return !mergelist_.is_empty(); }

References mergelist_.

Referenced by Finish(), FlushSimulates(), Merge(), and RemoveSimulates().

Here is the caller graph for this function:

Merge() [1/2]

State* v8::internal::State::Merge ( HBasicBlock *  succ_block, State *  pred_state, HBasicBlock *  pred_block, Zone *  zone  )

inlineprivate

Definition at line 147 of file hydrogen-removable-simulates.cc.

                           {
    // For our current local analysis, we should not remember simulates across
    // block boundaries.
    DCHECK(!pred_state->HasRememberedSimulates());
    DCHECK(!HasRememberedSimulates());
    if (FLAG_trace_removable_simulates) {
      PrintF("[merge state %p from B%d into %p for B%d]\n",
             reinterpret_cast<void*>(pred_state), pred_block->block_id(),
             reinterpret_cast<void*>(this), succ_block->block_id());
    }
    return this;
  }

References DCHECK, HasRememberedSimulates(), and v8::internal::PrintF().

Here is the call graph for this function:

Merge() [2/2]

static State* v8::internal::State::Merge ( State *  succ_state, HBasicBlock *  succ_block, State *  pred_state, HBasicBlock *  pred_block, Zone *  zone  )

inlinestatic

Definition at line 86 of file hydrogen-removable-simulates.cc.

                                  {
    return (succ_state == NULL)
        ? pred_state->Copy(succ_block, pred_block, zone)
        : succ_state->Merge(succ_block, pred_state, pred_block, zone);
  }

References Copy(), Merge(), and NULL.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Process()

State* v8::internal::State::Process ( HInstruction *  instr, Zone *  zone  )

inline

Definition at line 17 of file hydrogen-removable-simulates.cc.

                                                  {
    if (FLAG_trace_removable_simulates) {
      PrintF("[%s with state %p in B%d: #%d %s]\n",
             mode_ == NORMAL ? "processing" : "collecting",
             reinterpret_cast<void*>(this), instr->block()->block_id(),
             instr->id(), instr->Mnemonic());
    }
    // Forward-merge "trains" of simulates after an instruction with observable
    // side effects to keep live ranges short.
    if (mode_ == COLLECT_CONSECUTIVE_SIMULATES) {
      if (instr->IsSimulate()) {
        HSimulate* current_simulate = HSimulate::cast(instr);
        if (current_simulate->is_candidate_for_removal() &&
            !current_simulate->ast_id().IsNone()) {
          Remember(current_simulate);
          return this;
        }
      }
      FlushSimulates();
      mode_ = NORMAL;
    }
    // Ensure there's a non-foldable HSimulate before an HEnterInlined to avoid
    // folding across HEnterInlined.
    DCHECK(!(instr->IsEnterInlined() &&
             HSimulate::cast(instr->previous())->is_candidate_for_removal()));
    if (instr->IsLeaveInlined() || instr->IsReturn()) {
      // Never fold simulates from inlined environments into simulates in the
      // outer environment. Simply remove all accumulated simulates without
      // merging. This is safe because simulates after instructions with side
      // effects are never added to the merge list. The same reasoning holds for
      // return instructions.
      RemoveSimulates();
      return this;
    }
    if (instr->IsControlInstruction()) {
      // Merge the accumulated simulates at the end of the block.
      FlushSimulates();
      return this;
    }
    if (instr->IsCapturedObject()) {
      // Do not merge simulates across captured objects - captured objects
      // change environments during environment replay, and such changes
      // would not be reflected in the simulate.
      FlushSimulates();
      return this;
    }
    // Skip the non-simulates and the first simulate.
    if (!instr->IsSimulate()) return this;
    if (first_) {
      first_ = false;
      return this;
    }
    HSimulate* current_simulate = HSimulate::cast(instr);
    if (!current_simulate->is_candidate_for_removal()) {
      Remember(current_simulate);
      FlushSimulates();
    } else if (current_simulate->ast_id().IsNone()) {
      DCHECK(current_simulate->next()->IsEnterInlined());
      FlushSimulates();
    } else if (current_simulate->previous()->HasObservableSideEffects()) {
      Remember(current_simulate);
      mode_ = COLLECT_CONSECUTIVE_SIMULATES;
    } else {
      Remember(current_simulate);
    }
 
    return this;
  }

References v8::internal::HValue::block(), COLLECT_CONSECUTIVE_SIMULATES, DCHECK, first_, FlushSimulates(), v8::internal::HValue::id(), v8::internal::HValue::Mnemonic(), mode_, NORMAL, v8::internal::HInstruction::previous(), v8::internal::PrintF(), Remember(), and RemoveSimulates().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Remember()

void v8::internal::State::Remember ( HSimulate *  sim )

inlineprivate

Definition at line 121 of file hydrogen-removable-simulates.cc.

                                {
    mergelist_.Add(sim, zone_);
  }

References v8::internal::List< T, AllocationPolicy >::Add(), mergelist_, and zone_.

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveSimulates()

void v8::internal::State::RemoveSimulates ( )

inlineprivate

Definition at line 131 of file hydrogen-removable-simulates.cc.

                         {
    while (HasRememberedSimulates()) {
      mergelist_.RemoveLast()->DeleteAndReplaceWith(NULL);
    }
  }

References HasRememberedSimulates(), mergelist_, and NULL.

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

first_

bool v8::internal::State::first_

private

Definition at line 165 of file hydrogen-removable-simulates.cc.

Referenced by Finish(), and Process().

mergelist_

ZoneList<HSimulate*> v8::internal::State::mergelist_

private

Definition at line 164 of file hydrogen-removable-simulates.cc.

Referenced by FlushSimulates(), HasRememberedSimulates(), Remember(), and RemoveSimulates().

mode_

Mode v8::internal::State::mode_

private

Definition at line 166 of file hydrogen-removable-simulates.cc.

Referenced by Process().

zone_

Zone* v8::internal::State::zone_

private

Definition at line 163 of file hydrogen-removable-simulates.cc.

Referenced by Remember().

---

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

• /mnt/V8SourceCode/src/hydrogen-removable-simulates.cc