#include <generic-node.h>

Inheritance diagram for v8::internal::compiler::GenericNode< B, S >:

Collaboration diagram for v8::internal::compiler::GenericNode< B, S >:

Classes
class	Edge

class	Input

class	Inputs

class	Use

class	Uses

Public Types
typedef B	BaseClass

typedef S	DerivedClass

Public Member Functions
NodeId	id () const

int	InputCount () const

S *	InputAt (int index) const

void	ReplaceInput (int index, GenericNode *new_input)

void	AppendInput (Zone zone, GenericNode new_input)

void	InsertInput (Zone zone, int index, GenericNode new_input)

void	RemoveInput (int index)

int	UseCount ()

S *	UseAt (int index)

void	ReplaceUses (GenericNode *replace_to)

template<class UnaryPredicate >
void	ReplaceUsesIf (UnaryPredicate pred, GenericNode *replace_to)

void	RemoveAllInputs ()

void	TrimInputCount (int input_count)

Inputs	inputs ()

Uses	uses ()

bool	OwnedBy (GenericNode *owner) const

Static Public Member Functions
static S *	New (GenericGraphBase graph, int input_count, S *inputs)

Protected Member Functions
void	EnsureAppendableInputs (Zone *zone)

Input *	GetInputRecordPtr (int index) const

void	AppendUse (Use *use)

void	RemoveUse (Use *use)

void *	operator new (size_t, void *location)

	GenericNode (GenericGraphBase *graph, int input_count)

Private Types
typedef ZoneDeque< Input >	InputDeque

Private Member Functions
void	AssignUniqueID (GenericGraphBase *graph)

	DISALLOW_COPY_AND_ASSIGN (GenericNode)

Private Attributes
NodeId	id_

int	input_count_: 31

bool	has_appendable_inputs_: 1

union {
Input * static_

InputDeque * appendable_

}	inputs_

int	use_count_

Use *	first_use_

Use *	last_use_

Friends
class	GenericGraphBase

Detailed Description

template<class B, class S>
class v8::internal::compiler::GenericNode< B, S >

Definition at line 30 of file generic-node.h.

Member Typedef Documentation

◆ BaseClass

template<class B , class S >

typedef B v8::internal::compiler::GenericNode< B, S >::BaseClass

Definition at line 32 of file generic-node.h.

◆ DerivedClass

template<class B , class S >

typedef S v8::internal::compiler::GenericNode< B, S >::DerivedClass

Definition at line 33 of file generic-node.h.

◆ InputDeque

template<class B , class S >

typedef ZoneDeque<Input> v8::internal::compiler::GenericNode< B, S >::InputDeque

private

Definition at line 136 of file generic-node.h.

Constructor & Destructor Documentation

◆ GenericNode()

template<class B , class S >

v8::internal::compiler::GenericNode< B, S >::GenericNode	(	GenericGraphBase *	graph,
		int	input_count
	)

protected

Definition at line 19 of file generic-node-inl.h.

     : BaseClass(graph->zone()),
       input_count_(input_count),
       has_appendable_inputs_(false),
       use_count_(0),
       first_use_(NULL),
       last_use_(NULL) {
   inputs_.static_ = reinterpret_cast<Input*>(this + 1), AssignUniqueID(graph);
 }

References v8::internal::compiler::GenericNode< B, S >::AssignUniqueID(), and v8::internal::compiler::GenericNode< B, S >::inputs_.

Referenced by v8::internal::compiler::GenericNode< B, S >::New().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ AppendInput()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::AppendInput	(	Zone *	zone,
		GenericNode< B, S > *	new_input
	)

inline

Definition at line 155 of file generic-node-inl.h.

                                                                             {
   EnsureAppendableInputs(zone);
   Use* new_use = new (zone) Use;
   Input new_input;
   new_input.to = to_append;
   new_input.use = new_use;
   inputs_.appendable_->push_back(new_input);
   new_use->input_index = input_count_;
   new_use->from = this;
   to_append->AppendUse(new_use);
   input_count_++;
 }

References v8::internal::compiler::GenericNode< B, S >::AppendUse(), v8::internal::compiler::GenericNode< B, S >::EnsureAppendableInputs(), v8::internal::compiler::GenericNode< B, S >::Use::from, v8::internal::compiler::GenericNode< B, S >::input_count_, v8::internal::compiler::GenericNode< B, S >::Use::input_index, v8::internal::compiler::GenericNode< B, S >::inputs_, v8::internal::compiler::GenericNode< B, S >::Input::to, and v8::internal::compiler::GenericNode< B, S >::Input::use.

Referenced by v8::internal::compiler::GenericNode< B, S >::InsertInput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AppendUse()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::AppendUse ( Use * use )

inlineprotected

Definition at line 191 of file generic-node-inl.h.

                                           {
   use->next = NULL;
   use->prev = last_use_;
   if (last_use_ == NULL) {
     first_use_ = use;
   } else {
     last_use_->next = use;
   }
   last_use_ = use;
   ++use_count_;
 }

References v8::internal::compiler::GenericNode< B, S >::first_use_, v8::internal::compiler::GenericNode< B, S >::last_use_, v8::internal::compiler::GenericNode< B, S >::Use::next, NULL, use(), and v8::internal::compiler::GenericNode< B, S >::use_count_.

Referenced by v8::internal::compiler::GenericNode< B, S >::AppendInput(), and v8::internal::compiler::GenericNode< B, S >::ReplaceUsesIf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AssignUniqueID()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::AssignUniqueID ( GenericGraphBase * graph )

inlineprivate

Definition at line 30 of file generic-node-inl.h.

                                                                      {
   id_ = graph->NextNodeID();
 }

References v8::internal::compiler::GenericGraphBase::NextNodeID().

Referenced by v8::internal::compiler::GenericNode< B, S >::GenericNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DISALLOW_COPY_AND_ASSIGN()

template<class B , class S >

v8::internal::compiler::GenericNode< B, S >::DISALLOW_COPY_AND_ASSIGN ( GenericNode< B, S > )

private

◆ EnsureAppendableInputs()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::EnsureAppendableInputs ( Zone * zone )

protected

Definition at line 142 of file generic-node-inl.h.

                                                          {
   if (!has_appendable_inputs_) {
     void* deque_buffer = zone->New(sizeof(InputDeque));
     InputDeque* deque = new (deque_buffer) InputDeque(zone);
     for (int i = 0; i < input_count_; ++i) {
       deque->push_back(inputs_.static_[i]);
     }
     inputs_.appendable_ = deque;
     has_appendable_inputs_ = true;
   }
 }

References v8::internal::compiler::GenericNode< B, S >::has_appendable_inputs_, v8::internal::compiler::GenericNode< B, S >::input_count_, v8::internal::compiler::GenericNode< B, S >::inputs_, and v8::internal::Zone::New().

Referenced by v8::internal::compiler::GenericNode< B, S >::AppendInput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInputRecordPtr()

template<class B , class S >

Input* v8::internal::compiler::GenericNode< B, S >::GetInputRecordPtr ( int index ) const

inlineprotected

Definition at line 118 of file generic-node.h.

                                             {
     if (has_appendable_inputs_) {
       return &((*inputs_.appendable_)[index]);
     } else {
       return inputs_.static_ + index;
     }
   }

References v8::internal::compiler::GenericNode< B, S >::has_appendable_inputs_, and v8::internal::compiler::GenericNode< B, S >::inputs_.

Referenced by v8::internal::compiler::GenericNode< B, S >::InputAt(), v8::internal::compiler::GenericNode< B, S >::ReplaceInput(), and v8::internal::compiler::GenericNode< B, S >::TrimInputCount().

Here is the caller graph for this function:

◆ id()

template<class B , class S >

NodeId v8::internal::compiler::GenericNode< B, S >::id ( ) const

inline

Definition at line 35 of file generic-node.h.

35 { return id_; }

References v8::internal::compiler::GenericNode< B, S >::id_.

◆ InputAt()

template<class B , class S >

S* v8::internal::compiler::GenericNode< B, S >::InputAt ( int index ) const

inline

Definition at line 38 of file generic-node.h.

                               {
     return static_cast<S*>(GetInputRecordPtr(index)->to);
   }

References v8::internal::compiler::GenericNode< B, S >::GetInputRecordPtr(), v8::internal::S, and v8::internal::compiler::GenericNode< B, S >::Input::to.

Referenced by v8::internal::compiler::GenericNode< B, S >::InsertInput(), and v8::internal::compiler::GenericNode< B, S >::RemoveInput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InputCount()

template<class B , class S >

int v8::internal::compiler::GenericNode< B, S >::InputCount ( ) const

inline

Definition at line 37 of file generic-node.h.

37 { return input_count_; }

References v8::internal::compiler::GenericNode< B, S >::input_count_.

Referenced by v8::internal::compiler::GenericNode< B, S >::InsertInput(), and v8::internal::compiler::GenericNode< B, S >::RemoveInput().

Here is the caller graph for this function:

◆ inputs()

template<class B , class S >

Inputs v8::internal::compiler::GenericNode< B, S >::inputs ( )

inline

Definition at line 74 of file generic-node.h.

74 { return Inputs(this); }

Referenced by v8::internal::compiler::GenericNode< B, S >::New(), and v8::internal::compiler::GenericNode< B, S >::RemoveAllInputs().

Here is the caller graph for this function:

◆ InsertInput()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::InsertInput	(	Zone *	zone,
		int	index,
		GenericNode< B, S > *	new_input
	)

inline

Definition at line 169 of file generic-node-inl.h.

                                                                   {
   DCHECK(index >= 0 && index < InputCount());
   // TODO(turbofan): Optimize this implementation!
   AppendInput(zone, InputAt(InputCount() - 1));
   for (int i = InputCount() - 1; i > index; --i) {
     ReplaceInput(i, InputAt(i - 1));
   }
   ReplaceInput(index, to_insert);
 }

References v8::internal::compiler::GenericNode< B, S >::AppendInput(), DCHECK, v8::internal::compiler::GenericNode< B, S >::InputAt(), v8::internal::compiler::GenericNode< B, S >::InputCount(), and v8::internal::compiler::GenericNode< B, S >::ReplaceInput().

Here is the call graph for this function:

◆ New()

template<class B , class S >

S * v8::internal::compiler::GenericNode< B, S >::New	(	GenericGraphBase *	graph,
		int	input_count,
		S **	inputs
	)

static

Definition at line 226 of file generic-node-inl.h.

                                       {
   size_t node_size = sizeof(GenericNode);
   size_t inputs_size = input_count * sizeof(Input);
   size_t uses_size = input_count * sizeof(Use);
   int size = static_cast<int>(node_size + inputs_size + uses_size);
   Zone* zone = graph->zone();
   void* buffer = zone->New(size);
   S* result = new (buffer) S(graph, input_count);
   Input* input =
       reinterpret_cast<Input*>(reinterpret_cast<char*>(buffer) + node_size);
   Use* use =
       reinterpret_cast<Use*>(reinterpret_cast<char*>(input) + inputs_size);
  
   for (int current = 0; current < input_count; ++current) {
     GenericNode* to = *inputs++;
     input->to = to;
     input->use = use;
     use->input_index = current;
     use->from = result;
     to->AppendUse(use);
     ++use;
     ++input;
   }
   return result;
 }

References v8::internal::compiler::GenericNode< B, S >::GenericNode(), v8::internal::compiler::GenericNode< B, S >::inputs(), v8::internal::Zone::New(), v8::internal::S, size, v8::internal::compiler::GenericNode< B, S >::Input::to, to(), v8::internal::compiler::GenericNode< B, S >::Input::use, use(), and v8::internal::compiler::GenericGraphBase::zone().

Here is the call graph for this function:

◆ operator new()

template<class B , class S >

void* v8::internal::compiler::GenericNode< B, S >::operator new	(	size_t	,
		void *	location
	)

inlineprotected

Definition at line 129 of file generic-node.h.

129 { return location; }

◆ OwnedBy()

template<class B , class S >

bool v8::internal::compiler::GenericNode< B, S >::OwnedBy ( GenericNode< B, S > * owner ) const

inline

Definition at line 220 of file generic-node-inl.h.

                                                                {
   return first_use_ != NULL && first_use_->from == owner &&
          first_use_->next == NULL;
 }

References v8::internal::compiler::GenericNode< B, S >::first_use_, v8::internal::compiler::GenericNode< B, S >::Use::from, v8::internal::compiler::GenericNode< B, S >::Use::next, and NULL.

◆ RemoveAllInputs()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::RemoveAllInputs

inline

Definition at line 96 of file generic-node-inl.h.

                                         {
   for (typename Inputs::iterator iter(inputs().begin()); iter != inputs().end();
        ++iter) {
     iter.GetInput()->Update(NULL);
   }
 }

References v8::internal::compiler::GenericNode< B, S >::Inputs::end(), v8::internal::compiler::GenericNode< B, S >::inputs(), and NULL.

Here is the call graph for this function:

◆ RemoveInput()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::RemoveInput ( int index )

inline

Definition at line 181 of file generic-node-inl.h.

                                              {
   DCHECK(index >= 0 && index < InputCount());
   // TODO(turbofan): Optimize this implementation!
   for (; index < InputCount() - 1; ++index) {
     ReplaceInput(index, InputAt(index + 1));
   }
   TrimInputCount(InputCount() - 1);
 }

References DCHECK, v8::internal::compiler::GenericNode< B, S >::InputAt(), v8::internal::compiler::GenericNode< B, S >::InputCount(), v8::internal::compiler::GenericNode< B, S >::ReplaceInput(), and v8::internal::compiler::GenericNode< B, S >::TrimInputCount().

Here is the call graph for this function:

◆ RemoveUse()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::RemoveUse ( Use * use )

inlineprotected

Definition at line 204 of file generic-node-inl.h.

                                           {
   if (last_use_ == use) {
     last_use_ = use->prev;
   }
   if (use->prev != NULL) {
     use->prev->next = use->next;
   } else {
     first_use_ = use->next;
   }
   if (use->next != NULL) {
     use->next->prev = use->prev;
   }
   --use_count_;
 }

References v8::internal::compiler::GenericNode< B, S >::first_use_, v8::internal::compiler::GenericNode< B, S >::last_use_, NULL, use(), and v8::internal::compiler::GenericNode< B, S >::use_count_.

Referenced by v8::internal::compiler::GenericNode< NodeData, Node >::RemoveUse(), and v8::internal::compiler::GenericNode< B, S >::ReplaceUsesIf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReplaceInput()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::ReplaceInput	(	int	index,
		GenericNode< B, S > *	new_input
	)

inline

Definition at line 118 of file generic-node-inl.h.

                                                                          {
   Input* input = GetInputRecordPtr(index);
   input->Update(new_to);
 }

References v8::internal::compiler::GenericNode< B, S >::GetInputRecordPtr(), and v8::internal::compiler::GenericNode< B, S >::Input::Update().

Referenced by v8::internal::compiler::GenericNode< B, S >::InsertInput(), and v8::internal::compiler::GenericNode< B, S >::RemoveInput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReplaceUses()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::ReplaceUses ( GenericNode< B, S > * replace_to )

inline

Definition at line 60 of file generic-node-inl.h.

                                                            {
   for (Use* use = first_use_; use != NULL; use = use->next) {
     use->from->GetInputRecordPtr(use->input_index)->to = replace_to;
   }
   if (replace_to->last_use_ == NULL) {
     DCHECK_EQ(NULL, replace_to->first_use_);
     replace_to->first_use_ = first_use_;
     replace_to->last_use_ = last_use_;
   } else if (first_use_ != NULL) {
     DCHECK_NE(NULL, replace_to->first_use_);
     replace_to->last_use_->next = first_use_;
     first_use_->prev = replace_to->last_use_;
     replace_to->last_use_ = last_use_;
   }
   replace_to->use_count_ += use_count_;
   use_count_ = 0;
   first_use_ = NULL;
   last_use_ = NULL;
 }

References v8::internal::compiler::GenericNode< B, S >::first_use_, v8::internal::compiler::GenericNode< B, S >::last_use_, NULL, and use().

Here is the call graph for this function:

◆ ReplaceUsesIf()

template<class B , class S >

template<class UnaryPredicate >

void v8::internal::compiler::GenericNode< B, S >::ReplaceUsesIf	(	UnaryPredicate	pred,
		GenericNode< B, S > *	replace_to
	)

inline

Definition at line 82 of file generic-node-inl.h.

                                                                {
   for (Use* use = first_use_; use != NULL;) {
     Use* next = use->next;
     if (pred(static_cast<S*>(use->from))) {
       RemoveUse(use);
       replace_to->AppendUse(use);
       use->from->GetInputRecordPtr(use->input_index)->to = replace_to;
     }
     use = next;
   }
 }

References v8::internal::compiler::GenericNode< B, S >::AppendUse(), v8::internal::compiler::GenericNode< B, S >::first_use_, NULL, v8::internal::compiler::GenericNode< B, S >::RemoveUse(), v8::internal::S, and use().

Here is the call graph for this function:

◆ TrimInputCount()

template<class B , class S >

void v8::internal::compiler::GenericNode< B, S >::TrimInputCount ( int input_count )

inline

Definition at line 104 of file generic-node-inl.h.

                                                           {
   if (new_input_count == input_count_) return;  // Nothing to do.
  
   DCHECK(new_input_count < input_count_);
  
   // Update inline inputs.
   for (int i = new_input_count; i < input_count_; i++) {
     typename GenericNode<B, S>::Input* input = GetInputRecordPtr(i);
     input->Update(NULL);
   }
   input_count_ = new_input_count;
 }

References DCHECK, v8::internal::compiler::GenericNode< B, S >::GetInputRecordPtr(), v8::internal::compiler::GenericNode< B, S >::input_count_, NULL, and v8::internal::compiler::GenericNode< B, S >::Input::Update().

Referenced by v8::internal::compiler::GenericNode< B, S >::RemoveInput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UseAt()

template<class B , class S >

S* v8::internal::compiler::GenericNode< B, S >::UseAt ( int index )

inline

Definition at line 47 of file generic-node.h.

                       {
     DCHECK(index < use_count_);
     Use* current = first_use_;
     while (index-- != 0) {
       current = current->next;
     }
     return static_cast<S*>(current->from);
   }