v8::internal::PostorderProcessor Class Reference

Inheritance diagram for v8::internal::PostorderProcessor:

Collaboration diagram for v8::internal::PostorderProcessor:

Public Member Functions
PostorderProcessor *	parent ()
PostorderProcessor *	child ()
HBasicBlock *	block ()
HLoopInformation *	loop ()
HBasicBlock *	loop_header ()
PostorderProcessor *	PerformStep (Zone *zone, ZoneList< HBasicBlock * > *order)
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 PostorderProcessor *	CreateEntryProcessor (Zone *zone, HBasicBlock *block)

Private Types
enum	LoopKind {   NONE , SUCCESSORS , SUCCESSORS_OF_LOOP_HEADER , LOOP_MEMBERS ,   SUCCESSORS_OF_LOOP_MEMBER }

Private Member Functions
	PostorderProcessor (PostorderProcessor *father)
PostorderProcessor *	SetupSuccessors (Zone *zone, HBasicBlock *block, HBasicBlock *loop_header)
PostorderProcessor *	SetupLoopMembers (Zone *zone, HBasicBlock *block, HLoopInformation *loop, HBasicBlock *loop_header)
PostorderProcessor *	SetupSuccessorsOfLoopMember (HBasicBlock *block, HLoopInformation *loop, HBasicBlock *loop_header)
PostorderProcessor *	Push (Zone *zone)
void	ClosePostorder (ZoneList< HBasicBlock * > *order, Zone *zone)
PostorderProcessor *	Pop (Zone *zone, ZoneList< HBasicBlock * > *order)
PostorderProcessor *	Backtrack (Zone *zone, ZoneList< HBasicBlock * > *order)
PostorderProcessor *	PerformNonBacktrackingStep (Zone *zone, ZoneList< HBasicBlock * > *order)
void	InitializeSuccessors ()
HBasicBlock *	AdvanceSuccessors ()
void	InitializeLoopMembers ()
HBasicBlock *	AdvanceLoopMembers ()

Private Attributes
LoopKind	kind_
PostorderProcessor *	father_
PostorderProcessor *	child_
HLoopInformation *	loop_
HBasicBlock *	block_
HBasicBlock *	loop_header_
int	loop_index
int	loop_length
HSuccessorIterator	successor_iterator

Detailed Description

Definition at line 3584 of file hydrogen.cc.

Member Enumeration Documentation

LoopKind

enum v8::internal::PostorderProcessor::LoopKind

private

Enumerator
NONE
SUCCESSORS
SUCCESSORS_OF_LOOP_HEADER
LOOP_MEMBERS
SUCCESSORS_OF_LOOP_MEMBER

Definition at line 3616 of file hydrogen.cc.

                {
    NONE,
    SUCCESSORS,
    SUCCESSORS_OF_LOOP_HEADER,
    LOOP_MEMBERS,
    SUCCESSORS_OF_LOOP_MEMBER
  };

Constructor & Destructor Documentation

PostorderProcessor()

v8::internal::PostorderProcessor::PostorderProcessor ( PostorderProcessor *  father )

inlineexplicitprivate

Definition at line 3612 of file hydrogen.cc.

      : father_(father), child_(NULL), successor_iterator(NULL) { }

Member Function Documentation

AdvanceLoopMembers()

HBasicBlock* v8::internal::PostorderProcessor::AdvanceLoopMembers ( )

inlineprivate

Definition at line 3803 of file hydrogen.cc.

                                    {
    if (loop_index < loop_length) {
      HBasicBlock* result = loop_->blocks()->at(loop_index);
      loop_index++;
      return result;
    } else {
      return NULL;
    }
  }

References NULL.

AdvanceSuccessors()

HBasicBlock* v8::internal::PostorderProcessor::AdvanceSuccessors ( )

inlineprivate

Definition at line 3788 of file hydrogen.cc.

                                   {
    if (!successor_iterator.Done()) {
      HBasicBlock* result = successor_iterator.Current();
      successor_iterator.Advance();
      return result;
    }
    return NULL;
  }

References NULL.

Backtrack()

PostorderProcessor* v8::internal::PostorderProcessor::Backtrack ( Zone *  zone, ZoneList< HBasicBlock * > *  order  )

inlineprivate

Definition at line 3726 of file hydrogen.cc.

                                                               {
    PostorderProcessor* parent = Pop(zone, order);
    while (parent != NULL) {
      PostorderProcessor* next =
          parent->PerformNonBacktrackingStep(zone, order);
      if (next != NULL) {
        return next;
      } else {
        parent = parent->Pop(zone, order);
      }
    }
    return NULL;
  }

References NULL, PerformNonBacktrackingStep(), and Pop().

Here is the call graph for this function:

block()

HBasicBlock* v8::internal::PostorderProcessor::block ( )

inline

Definition at line 3590 of file hydrogen.cc.

{ return block_; }

child()

PostorderProcessor* v8::internal::PostorderProcessor::child ( )

inline

Definition at line 3589 of file hydrogen.cc.

{return child_; }

ClosePostorder()

void v8::internal::PostorderProcessor::ClosePostorder ( ZoneList< HBasicBlock * > *  order, Zone *  zone  )

inlineprivate

Definition at line 3689 of file hydrogen.cc.

                                                                 {
    DCHECK(block_->end()->FirstSuccessor() == NULL ||
           order->Contains(block_->end()->FirstSuccessor()) ||
           block_->end()->FirstSuccessor()->IsLoopHeader());
    DCHECK(block_->end()->SecondSuccessor() == NULL ||
           order->Contains(block_->end()->SecondSuccessor()) ||
           block_->end()->SecondSuccessor()->IsLoopHeader());
    order->Add(block_, zone);
  }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::Contains(), DCHECK, and NULL.

Here is the call graph for this function:

CreateEntryProcessor()

static PostorderProcessor* v8::internal::PostorderProcessor::CreateEntryProcessor ( Zone *  zone, HBasicBlock *  block  )

inlinestatic

Definition at line 3594 of file hydrogen.cc.

                                                                      {
    PostorderProcessor* result = new(zone) PostorderProcessor(NULL);
    return result->SetupSuccessors(zone, block, NULL);
  }

References NULL, and SetupSuccessors().

Here is the call graph for this function:

InitializeLoopMembers()

void v8::internal::PostorderProcessor::InitializeLoopMembers ( )

inlineprivate

Definition at line 3798 of file hydrogen.cc.

                               {
    loop_index = 0;
    loop_length = loop_->blocks()->length();
  }

InitializeSuccessors()

void v8::internal::PostorderProcessor::InitializeSuccessors ( )

inlineprivate

Definition at line 3782 of file hydrogen.cc.

                              {
    loop_index = 0;
    loop_length = 0;
    successor_iterator = HSuccessorIterator(block_->end());
  }

loop()

HLoopInformation* v8::internal::PostorderProcessor::loop ( )

inline

Definition at line 3591 of file hydrogen.cc.

{ return loop_; }

loop_header()

HBasicBlock* v8::internal::PostorderProcessor::loop_header ( )

inline

Definition at line 3592 of file hydrogen.cc.

{ return loop_header_; }

parent()

PostorderProcessor* v8::internal::PostorderProcessor::parent ( )

inline

Definition at line 3587 of file hydrogen.cc.

{return father_; }

PerformNonBacktrackingStep()

PostorderProcessor* v8::internal::PostorderProcessor::PerformNonBacktrackingStep ( Zone *  zone, ZoneList< HBasicBlock * > *  order  )

inlineprivate

Definition at line 3741 of file hydrogen.cc.

                                     {
    HBasicBlock* next_block;
    switch (kind_) {
      case SUCCESSORS:
        next_block = AdvanceSuccessors();
        if (next_block != NULL) {
          PostorderProcessor* result = Push(zone);
          return result->SetupSuccessors(zone, next_block, loop_header_);
        }
        break;
      case SUCCESSORS_OF_LOOP_HEADER:
        next_block = AdvanceSuccessors();
        if (next_block != NULL) {
          PostorderProcessor* result = Push(zone);
          return result->SetupSuccessors(zone, next_block, block());
        }
        break;
      case LOOP_MEMBERS:
        next_block = AdvanceLoopMembers();
        if (next_block != NULL) {
          PostorderProcessor* result = Push(zone);
          return result->SetupSuccessorsOfLoopMember(next_block,
                                                     loop_, loop_header_);
        }
        break;
      case SUCCESSORS_OF_LOOP_MEMBER:
        next_block = AdvanceSuccessors();
        if (next_block != NULL) {
          PostorderProcessor* result = Push(zone);
          return result->SetupSuccessors(zone, next_block, loop_header_);
        }
        break;
      case NONE:
        return NULL;
    }
    return NULL;
  }

References NONE, NULL, v8::internal::compiler::Push(), SetupSuccessors(), and SetupSuccessorsOfLoopMember().

Referenced by Backtrack().

Here is the call graph for this function:

Here is the caller graph for this function:

PerformStep()

PostorderProcessor* v8::internal::PostorderProcessor::PerformStep ( Zone *  zone, ZoneList< HBasicBlock * > *  order  )

inline

Definition at line 3600 of file hydrogen.cc.

                                                                 {
    PostorderProcessor* next =
        PerformNonBacktrackingStep(zone, order);
    if (next != NULL) {
      return next;
    } else {
      return Backtrack(zone, order);
    }
  }

References NULL.

Pop()

PostorderProcessor* v8::internal::PostorderProcessor::Pop ( Zone *  zone, ZoneList< HBasicBlock * > *  order  )

inlineprivate

Definition at line 3700 of file hydrogen.cc.

                                                         {
    switch (kind_) {
      case SUCCESSORS:
      case SUCCESSORS_OF_LOOP_HEADER:
        ClosePostorder(order, zone);
        return father_;
      case LOOP_MEMBERS:
        return father_;
      case SUCCESSORS_OF_LOOP_MEMBER:
        if (block()->IsLoopHeader() && block() != loop_->loop_header()) {
          // In this case we need to perform a LOOP_MEMBERS cycle so we
          // initialize it and return this instead of father.
          return SetupLoopMembers(zone, block(),
                                  block()->loop_information(), loop_header_);
        } else {
          return father_;
        }
      case NONE:
        return father_;
    }
    UNREACHABLE();
    return NULL;
  }

References NONE, NULL, and UNREACHABLE.

Referenced by Backtrack().

Here is the caller graph for this function:

Push()

PostorderProcessor* v8::internal::PostorderProcessor::Push ( Zone *  zone )

inlineprivate

Definition at line 3682 of file hydrogen.cc.

                                       {
    if (child_ == NULL) {
      child_ = new(zone) PostorderProcessor(this);
    }
    return child_;
  }

References NULL.

SetupLoopMembers()

PostorderProcessor* v8::internal::PostorderProcessor::SetupLoopMembers ( Zone *  zone, HBasicBlock *  block, HLoopInformation *  loop, HBasicBlock *  loop_header  )

inlineprivate

Definition at line 3657 of file hydrogen.cc.

                                                                 {
    kind_ = LOOP_MEMBERS;
    block_ = block;
    loop_ = loop;
    loop_header_ = loop_header;
    InitializeLoopMembers();
    return this;
  }

Referenced by SetupSuccessors().

Here is the caller graph for this function:

SetupSuccessors()

PostorderProcessor* v8::internal::PostorderProcessor::SetupSuccessors ( Zone *  zone, HBasicBlock *  block, HBasicBlock *  loop_header  )

inlineprivate

Definition at line 3625 of file hydrogen.cc.

                                                                {
    if (block == NULL || block->IsOrdered() ||
        block->parent_loop_header() != loop_header) {
      kind_ = NONE;
      block_ = NULL;
      loop_ = NULL;
      loop_header_ = NULL;
      return this;
    } else {
      block_ = block;
      loop_ = NULL;
      block->MarkAsOrdered();
 
      if (block->IsLoopHeader()) {
        kind_ = SUCCESSORS_OF_LOOP_HEADER;
        loop_header_ = block;
        InitializeSuccessors();
        PostorderProcessor* result = Push(zone);
        return result->SetupLoopMembers(zone, block, block->loop_information(),
                                        loop_header);
      } else {
        DCHECK(block->IsFinished());
        kind_ = SUCCESSORS;
        loop_header_ = loop_header;
        InitializeSuccessors();
        return this;
      }
    }
  }

References DCHECK, NONE, NULL, v8::internal::compiler::Push(), and SetupLoopMembers().

Referenced by CreateEntryProcessor(), and PerformNonBacktrackingStep().

Here is the call graph for this function:

Here is the caller graph for this function:

SetupSuccessorsOfLoopMember()

PostorderProcessor* v8::internal::PostorderProcessor::SetupSuccessorsOfLoopMember ( HBasicBlock *  block, HLoopInformation *  loop, HBasicBlock *  loop_header  )

inlineprivate

Definition at line 3669 of file hydrogen.cc.

                                {
    kind_ = SUCCESSORS_OF_LOOP_MEMBER;
    block_ = block;
    loop_ = loop;
    loop_header_ = loop_header;
    InitializeSuccessors();
    return this;
  }

Referenced by PerformNonBacktrackingStep().

Here is the caller graph for this function:

Member Data Documentation

block_

HBasicBlock* v8::internal::PostorderProcessor::block_

private

Definition at line 3817 of file hydrogen.cc.

child_

PostorderProcessor* v8::internal::PostorderProcessor::child_

private

Definition at line 3815 of file hydrogen.cc.

father_

PostorderProcessor* v8::internal::PostorderProcessor::father_

private

Definition at line 3814 of file hydrogen.cc.

kind_

LoopKind v8::internal::PostorderProcessor::kind_

private

Definition at line 3813 of file hydrogen.cc.

loop_

HLoopInformation* v8::internal::PostorderProcessor::loop_

private

Definition at line 3816 of file hydrogen.cc.

loop_header_

HBasicBlock* v8::internal::PostorderProcessor::loop_header_

private

Definition at line 3818 of file hydrogen.cc.

loop_index

int v8::internal::PostorderProcessor::loop_index

private

Definition at line 3819 of file hydrogen.cc.

loop_length

int v8::internal::PostorderProcessor::loop_length

private

Definition at line 3820 of file hydrogen.cc.

successor_iterator

HSuccessorIterator v8::internal::PostorderProcessor::successor_iterator

private

Definition at line 3821 of file hydrogen.cc.

---

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

• /mnt/V8SourceCode/src/hydrogen.cc