v8::internal::compiler::LiveRange Class Reference

#include <register-allocator.h>

Inheritance diagram for v8::internal::compiler::LiveRange:

Collaboration diagram for v8::internal::compiler::LiveRange:

Public Member Functions
	LiveRange (int id, Zone *zone)
UseInterval *	first_interval () const
UsePosition *	first_pos () const
LiveRange *	parent () const
LiveRange *	TopLevel ()
LiveRange *	next () const
bool	IsChild () const
int	id () const
bool	IsFixed () const
bool	IsEmpty () const
InstructionOperand *	CreateAssignedOperand (Zone *zone)
int	assigned_register () const
int	spill_start_index () const
void	set_assigned_register (int reg, Zone *zone)
void	MakeSpilled (Zone *zone)
bool	is_phi () const
void	set_is_phi (bool is_phi)
bool	is_non_loop_phi () const
void	set_is_non_loop_phi (bool is_non_loop_phi)
UsePosition *	NextUsePosition (LifetimePosition start)
UsePosition *	NextRegisterPosition (LifetimePosition start)
UsePosition *	NextUsePositionRegisterIsBeneficial (LifetimePosition start)
UsePosition *	PreviousUsePositionRegisterIsBeneficial (LifetimePosition start)
bool	CanBeSpilled (LifetimePosition pos)
void	SplitAt (LifetimePosition position, LiveRange *result, Zone *zone)
RegisterKind	Kind () const
bool	HasRegisterAssigned () const
bool	IsSpilled () const
InstructionOperand *	current_hint_operand () const
InstructionOperand *	FirstHint () const
LifetimePosition	Start () const
LifetimePosition	End () const
bool	HasAllocatedSpillOperand () const
InstructionOperand *	GetSpillOperand () const
void	SetSpillOperand (InstructionOperand *operand)
void	SetSpillStartIndex (int start)
bool	ShouldBeAllocatedBefore (const LiveRange *other) const
bool	CanCover (LifetimePosition position) const
bool	Covers (LifetimePosition position)
LifetimePosition	FirstIntersection (LiveRange *other)
void	EnsureInterval (LifetimePosition start, LifetimePosition end, Zone *zone)
void	AddUseInterval (LifetimePosition start, LifetimePosition end, Zone *zone)
void	AddUsePosition (LifetimePosition pos, InstructionOperand *operand, InstructionOperand *hint, Zone *zone)
void	ShortenTo (LifetimePosition start)
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 Attributes
static const int	kInvalidAssignment = 0x7fffffff

Private Member Functions
void	ConvertOperands (Zone *zone)
UseInterval *	FirstSearchIntervalForPosition (LifetimePosition position) const
void	AdvanceLastProcessedMarker (UseInterval *to_start_of, LifetimePosition but_not_past) const

Private Attributes
int	id_
bool	spilled_
bool	is_phi_
bool	is_non_loop_phi_
RegisterKind	kind_
int	assigned_register_
UseInterval *	last_interval_
UseInterval *	first_interval_
UsePosition *	first_pos_
LiveRange *	parent_
LiveRange *	next_
UseInterval *	current_interval_
UsePosition *	last_processed_use_
InstructionOperand *	current_hint_operand_
InstructionOperand *	spill_operand_
int	spill_start_index_

Friends
class	RegisterAllocator

Detailed Description

Definition at line 181 of file register-allocator.h.

Constructor & Destructor Documentation

LiveRange()

v8::internal::compiler::LiveRange::LiveRange	(	int	id,
		Zone *	zone
	)

Definition at line 92 of file register-allocator.cc.

    : id_(id),
      spilled_(false),
      is_phi_(false),
      is_non_loop_phi_(false),
      kind_(UNALLOCATED_REGISTERS),
      assigned_register_(kInvalidAssignment),
      last_interval_(NULL),
      first_interval_(NULL),
      first_pos_(NULL),
      parent_(NULL),
      next_(NULL),
      current_interval_(NULL),
      last_processed_use_(NULL),
      current_hint_operand_(NULL),
      spill_operand_(new (zone) InstructionOperand()),
      spill_start_index_(kMaxInt) {}

Member Function Documentation

AddUseInterval()

void v8::internal::compiler::LiveRange::AddUseInterval	(	LifetimePosition	start,
		LifetimePosition	end,
		Zone *	zone
	)

Definition at line 383 of file register-allocator.cc.

                                           {
  RegisterAllocator::TraceAlloc("Add to live range %d interval [%d %d[\n", id_,
                                start.Value(), end.Value());
  if (first_interval_ == NULL) {
    UseInterval* interval = new (zone) UseInterval(start, end);
    first_interval_ = interval;
    last_interval_ = interval;
  } else {
    if (end.Value() == first_interval_->start().Value()) {
      first_interval_->set_start(start);
    } else if (end.Value() < first_interval_->start().Value()) {
      UseInterval* interval = new (zone) UseInterval(start, end);
      interval->set_next(first_interval_);
      first_interval_ = interval;
    } else {
      // Order of instruction's processing (see ProcessInstructions) guarantees
      // that each new use interval either precedes or intersects with
      // last added interval.
      DCHECK(start.Value() < first_interval_->end().Value());
      first_interval_->start_ = Min(start, first_interval_->start_);
      first_interval_->end_ = Max(end, first_interval_->end_);
    }
  }
}

References DCHECK, v8::internal::compiler::UseInterval::end(), v8::internal::compiler::UseInterval::end_, first_interval_, id_, last_interval_, v8::internal::compiler::Max(), v8::internal::compiler::Min(), NULL, v8::internal::compiler::UseInterval::set_next(), v8::internal::compiler::UseInterval::set_start(), v8::internal::compiler::UseInterval::start(), v8::internal::compiler::UseInterval::start_, and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

AddUsePosition()

void v8::internal::compiler::LiveRange::AddUsePosition	(	LifetimePosition	pos,
		InstructionOperand *	operand,
		InstructionOperand *	hint,
		Zone *	zone
	)

Definition at line 410 of file register-allocator.cc.

                                                                     {
  RegisterAllocator::TraceAlloc("Add to live range %d use position %d\n", id_,
                                pos.Value());
  UsePosition* use_pos = new (zone) UsePosition(pos, operand, hint);
  UsePosition* prev_hint = NULL;
  UsePosition* prev = NULL;
  UsePosition* current = first_pos_;
  while (current != NULL && current->pos().Value() < pos.Value()) {
    prev_hint = current->HasHint() ? current : prev_hint;
    prev = current;
    current = current->next();
  }
 
  if (prev == NULL) {
    use_pos->set_next(first_pos_);
    first_pos_ = use_pos;
  } else {
    use_pos->next_ = prev->next_;
    prev->next_ = use_pos;
  }
 
  if (prev_hint == NULL && use_pos->HasHint()) {
    current_hint_operand_ = hint;
  }
}

References current_hint_operand_, first_pos_, v8::internal::compiler::UsePosition::HasHint(), id_, v8::internal::compiler::UsePosition::next(), v8::internal::compiler::UsePosition::next_, NULL, v8::internal::compiler::UsePosition::pos(), v8::internal::compiler::UsePosition::set_next(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

AdvanceLastProcessedMarker()

void v8::internal::compiler::LiveRange::AdvanceLastProcessedMarker ( UseInterval *  to_start_of, LifetimePosition  but_not_past  ) const

private

Definition at line 232 of file register-allocator.cc.

                                                                   {
  if (to_start_of == NULL) return;
  if (to_start_of->start().Value() > but_not_past.Value()) return;
  LifetimePosition start = current_interval_ == NULL
                               ? LifetimePosition::Invalid()
                               : current_interval_->start();
  if (to_start_of->start().Value() > start.Value()) {
    current_interval_ = to_start_of;
  }
}

References current_interval_, v8::internal::compiler::LifetimePosition::Invalid(), NULL, v8::internal::compiler::UseInterval::start(), and v8::internal::compiler::LifetimePosition::Value().

Referenced by Covers(), and FirstIntersection().

Here is the call graph for this function:

Here is the caller graph for this function:

assigned_register()

int v8::internal::compiler::LiveRange::assigned_register ( ) const

inline

Definition at line 197 of file register-allocator.h.

{ return assigned_register_; }

References assigned_register_.

Referenced by CreateAssignedOperand().

Here is the caller graph for this function:

CanBeSpilled()

bool v8::internal::compiler::LiveRange::CanBeSpilled

(

LifetimePosition

pos

)

Definition at line 183 of file register-allocator.cc.

                                                 {
  // We cannot spill a live range that has a use requiring a register
  // at the current or the immediate next position.
  UsePosition* use_pos = NextRegisterPosition(pos);
  if (use_pos == NULL) return true;
  return use_pos->pos().Value() >
         pos.NextInstruction().InstructionEnd().Value();
}

References v8::internal::compiler::LifetimePosition::InstructionEnd(), v8::internal::compiler::LifetimePosition::NextInstruction(), NextRegisterPosition(), NULL, v8::internal::compiler::UsePosition::pos(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

CanCover()

bool v8::internal::compiler::LiveRange::CanCover

(

LifetimePosition

position

)

const

Definition at line 456 of file register-allocator.cc.

                                                        {
  if (IsEmpty()) return false;
  return Start().Value() <= position.Value() &&
         position.Value() < End().Value();
}

References End(), IsEmpty(), Start(), and v8::internal::compiler::LifetimePosition::Value().

Referenced by Covers().

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertOperands()

void v8::internal::compiler::LiveRange::ConvertOperands ( Zone *  zone )

private

Definition at line 439 of file register-allocator.cc.

                                          {
  InstructionOperand* op = CreateAssignedOperand(zone);
  UsePosition* use_pos = first_pos();
  while (use_pos != NULL) {
    DCHECK(Start().Value() <= use_pos->pos().Value() &&
           use_pos->pos().Value() <= End().Value());
 
    if (use_pos->HasOperand()) {
      DCHECK(op->IsRegister() || op->IsDoubleRegister() ||
             !use_pos->RequiresRegister());
      use_pos->operand()->ConvertTo(op->kind(), op->index());
    }
    use_pos = use_pos->next();
  }
}

References v8::internal::compiler::InstructionOperand::ConvertTo(), CreateAssignedOperand(), DCHECK, End(), first_pos(), v8::internal::compiler::UsePosition::HasOperand(), v8::internal::compiler::InstructionOperand::index(), v8::internal::compiler::InstructionOperand::kind(), v8::internal::compiler::UsePosition::next(), NULL, v8::internal::compiler::UsePosition::operand(), v8::internal::compiler::UsePosition::pos(), v8::internal::compiler::UsePosition::RequiresRegister(), Start(), and v8::internal::compiler::LifetimePosition::Value().

Referenced by MakeSpilled(), and set_assigned_register().

Here is the call graph for this function:

Here is the caller graph for this function:

Covers()

bool v8::internal::compiler::LiveRange::Covers

(

LifetimePosition

position

)

Definition at line 463 of file register-allocator.cc.

                                                {
  if (!CanCover(position)) return false;
  UseInterval* start_search = FirstSearchIntervalForPosition(position);
  for (UseInterval* interval = start_search; interval != NULL;
       interval = interval->next()) {
    DCHECK(interval->next() == NULL ||
           interval->next()->start().Value() >= interval->start().Value());
    AdvanceLastProcessedMarker(interval, position);
    if (interval->Contains(position)) return true;
    if (interval->start().Value() > position.Value()) return false;
  }
  return false;
}

References AdvanceLastProcessedMarker(), CanCover(), DCHECK, FirstSearchIntervalForPosition(), NULL, and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

CreateAssignedOperand()

InstructionOperand * v8::internal::compiler::LiveRange::CreateAssignedOperand

(

Zone *

zone

)

Definition at line 193 of file register-allocator.cc.

                                                               {
  InstructionOperand* op = NULL;
  if (HasRegisterAssigned()) {
    DCHECK(!IsSpilled());
    switch (Kind()) {
      case GENERAL_REGISTERS:
        op = RegisterOperand::Create(assigned_register(), zone);
        break;
      case DOUBLE_REGISTERS:
        op = DoubleRegisterOperand::Create(assigned_register(), zone);
        break;
      default:
        UNREACHABLE();
    }
  } else if (IsSpilled()) {
    DCHECK(!HasRegisterAssigned());
    op = TopLevel()->GetSpillOperand();
    DCHECK(!op->IsUnallocated());
  } else {
    UnallocatedOperand* unalloc =
        new (zone) UnallocatedOperand(UnallocatedOperand::NONE);
    unalloc->set_virtual_register(id_);
    op = unalloc;
  }
  return op;
}

References assigned_register(), DCHECK, v8::internal::compiler::DOUBLE_REGISTERS, v8::internal::compiler::GENERAL_REGISTERS, GetSpillOperand(), HasRegisterAssigned(), id_, IsSpilled(), Kind(), v8::internal::compiler::UnallocatedOperand::NONE, NULL, v8::internal::compiler::UnallocatedOperand::set_virtual_register(), TopLevel(), and UNREACHABLE.

Referenced by ConvertOperands().

Here is the call graph for this function:

Here is the caller graph for this function:

current_hint_operand()

InstructionOperand* v8::internal::compiler::LiveRange::current_hint_operand ( ) const

inline

Definition at line 242 of file register-allocator.h.

                                                   {
    DCHECK(current_hint_operand_ == FirstHint());
    return current_hint_operand_;
  }

References current_hint_operand_, DCHECK, and FirstHint().

Here is the call graph for this function:

End()

LifetimePosition v8::internal::compiler::LiveRange::End ( ) const

inline

Definition at line 258 of file register-allocator.h.

                               {
    DCHECK(!IsEmpty());
    return last_interval_->end();
  }

References DCHECK, v8::internal::compiler::UseInterval::end(), IsEmpty(), and last_interval_.

Referenced by CanCover(), ConvertOperands(), and FirstIntersection().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureInterval()

void v8::internal::compiler::LiveRange::EnsureInterval	(	LifetimePosition	start,
		LifetimePosition	end,
		Zone *	zone
	)

Definition at line 361 of file register-allocator.cc.

                                           {
  RegisterAllocator::TraceAlloc("Ensure live range %d in interval [%d %d[\n",
                                id_, start.Value(), end.Value());
  LifetimePosition new_end = end;
  while (first_interval_ != NULL &&
         first_interval_->start().Value() <= end.Value()) {
    if (first_interval_->end().Value() > end.Value()) {
      new_end = first_interval_->end();
    }
    first_interval_ = first_interval_->next();
  }
 
  UseInterval* new_interval = new (zone) UseInterval(start, new_end);
  new_interval->next_ = first_interval_;
  first_interval_ = new_interval;
  if (new_interval->next() == NULL) {
    last_interval_ = new_interval;
  }
}

References v8::internal::compiler::UseInterval::end(), first_interval_, id_, last_interval_, v8::internal::compiler::UseInterval::next(), v8::internal::compiler::UseInterval::next_, NULL, v8::internal::compiler::UseInterval::start(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

first_interval()

UseInterval* v8::internal::compiler::LiveRange::first_interval ( ) const

inline

Definition at line 187 of file register-allocator.h.

{ return first_interval_; }

References first_interval_.

Referenced by FirstIntersection(), IsEmpty(), and Start().

Here is the caller graph for this function:

first_pos()

UsePosition* v8::internal::compiler::LiveRange::first_pos ( ) const

inline

Definition at line 188 of file register-allocator.h.

{ return first_pos_; }

References first_pos_.

Referenced by ConvertOperands(), NextUsePosition(), PreviousUsePositionRegisterIsBeneficial(), and ShouldBeAllocatedBefore().

Here is the caller graph for this function:

FirstHint()

InstructionOperand* v8::internal::compiler::LiveRange::FirstHint ( ) const

inline

Definition at line 246 of file register-allocator.h.

                                        {
    UsePosition* pos = first_pos_;
    while (pos != NULL && !pos->HasHint()) pos = pos->next();
    if (pos != NULL) return pos->hint();
    return NULL;
  }

References first_pos_, v8::internal::compiler::UsePosition::HasHint(), v8::internal::compiler::UsePosition::hint(), v8::internal::compiler::UsePosition::next(), and NULL.

Referenced by current_hint_operand().

Here is the call graph for this function:

Here is the caller graph for this function:

FirstIntersection()

LifetimePosition v8::internal::compiler::LiveRange::FirstIntersection

(

LiveRange *

other

)

Definition at line 478 of file register-allocator.cc.

                                                              {
  UseInterval* b = other->first_interval();
  if (b == NULL) return LifetimePosition::Invalid();
  LifetimePosition advance_last_processed_up_to = b->start();
  UseInterval* a = FirstSearchIntervalForPosition(b->start());
  while (a != NULL && b != NULL) {
    if (a->start().Value() > other->End().Value()) break;
    if (b->start().Value() > End().Value()) break;
    LifetimePosition cur_intersection = a->Intersect(b);
    if (cur_intersection.IsValid()) {
      return cur_intersection;
    }
    if (a->start().Value() < b->start().Value()) {
      a = a->next();
      if (a == NULL || a->start().Value() > other->End().Value()) break;
      AdvanceLastProcessedMarker(a, advance_last_processed_up_to);
    } else {
      b = b->next();
    }
  }
  return LifetimePosition::Invalid();
}

References AdvanceLastProcessedMarker(), End(), first_interval(), FirstSearchIntervalForPosition(), v8::internal::compiler::UseInterval::Intersect(), v8::internal::compiler::LifetimePosition::Invalid(), v8::internal::compiler::LifetimePosition::IsValid(), v8::internal::compiler::UseInterval::next(), NULL, v8::internal::compiler::UseInterval::start(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

FirstSearchIntervalForPosition()

UseInterval * v8::internal::compiler::LiveRange::FirstSearchIntervalForPosition ( LifetimePosition  position ) const

private

Definition at line 221 of file register-allocator.cc.

                                     {
  if (current_interval_ == NULL) return first_interval_;
  if (current_interval_->start().Value() > position.Value()) {
    current_interval_ = NULL;
    return first_interval_;
  }
  return current_interval_;
}

References current_interval_, first_interval_, NULL, v8::internal::compiler::UseInterval::start(), and v8::internal::compiler::LifetimePosition::Value().

Referenced by Covers(), FirstIntersection(), and SplitAt().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSpillOperand()

InstructionOperand* v8::internal::compiler::LiveRange::GetSpillOperand ( ) const

inline

Definition at line 264 of file register-allocator.h.

{ return spill_operand_; }

References spill_operand_.

Referenced by CreateAssignedOperand().

Here is the caller graph for this function:

HasAllocatedSpillOperand()

bool v8::internal::compiler::LiveRange::HasAllocatedSpillOperand

(

)

const

Definition at line 127 of file register-allocator.cc.

                                               {
  DCHECK(spill_operand_ != NULL);
  return !spill_operand_->IsIgnored();
}

References DCHECK, NULL, and spill_operand_.

Referenced by MakeSpilled().

Here is the caller graph for this function:

HasRegisterAssigned()

bool v8::internal::compiler::LiveRange::HasRegisterAssigned ( ) const

inline

Definition at line 237 of file register-allocator.h.

                                   {
    return assigned_register_ != kInvalidAssignment;
  }

References assigned_register_, and kInvalidAssignment.

Referenced by CreateAssignedOperand(), and set_assigned_register().

Here is the caller graph for this function:

id()

int v8::internal::compiler::LiveRange::id ( ) const

inline

Definition at line 193 of file register-allocator.h.

{ return id_; }

References id_.

is_non_loop_phi()

bool v8::internal::compiler::LiveRange::is_non_loop_phi ( ) const

inline

Definition at line 203 of file register-allocator.h.

{ return is_non_loop_phi_; }

References is_non_loop_phi_.

Referenced by set_is_non_loop_phi().

Here is the caller graph for this function:

is_phi()

bool v8::internal::compiler::LiveRange::is_phi ( ) const

inline

Definition at line 201 of file register-allocator.h.

{ return is_phi_; }

References is_phi_.

Referenced by set_is_phi().

Here is the caller graph for this function:

IsChild()

bool v8::internal::compiler::LiveRange::IsChild ( ) const

inline

Definition at line 192 of file register-allocator.h.

{ return parent() != NULL; }

References NULL, and parent().

Here is the call graph for this function:

IsEmpty()

bool v8::internal::compiler::LiveRange::IsEmpty ( ) const

inline

Definition at line 195 of file register-allocator.h.

{ return first_interval() == NULL; }

References first_interval(), and NULL.

Referenced by CanCover(), End(), SplitAt(), and Start().

Here is the call graph for this function:

Here is the caller graph for this function:

IsFixed()

bool v8::internal::compiler::LiveRange::IsFixed ( ) const

inline

Definition at line 194 of file register-allocator.h.

{ return id_ < 0; }

References id_.

IsSpilled()

bool v8::internal::compiler::LiveRange::IsSpilled ( ) const

inline

Definition at line 240 of file register-allocator.h.

{ return spilled_; }

References spilled_.

Referenced by CreateAssignedOperand(), MakeSpilled(), and set_assigned_register().

Here is the caller graph for this function:

Kind()

RegisterKind v8::internal::compiler::LiveRange::Kind ( ) const

inline

Definition at line 236 of file register-allocator.h.

{ return kind_; }

References kind_.

Referenced by CreateAssignedOperand().

Here is the caller graph for this function:

MakeSpilled()

void v8::internal::compiler::LiveRange::MakeSpilled

(

Zone *

zone

)

Definition at line 118 of file register-allocator.cc.

                                      {
  DCHECK(!IsSpilled());
  DCHECK(TopLevel()->HasAllocatedSpillOperand());
  spilled_ = true;
  assigned_register_ = kInvalidAssignment;
  ConvertOperands(zone);
}

References assigned_register_, ConvertOperands(), DCHECK, HasAllocatedSpillOperand(), IsSpilled(), kInvalidAssignment, spilled_, and TopLevel().

Here is the call graph for this function:

next()

LiveRange* v8::internal::compiler::LiveRange::next ( ) const

inline

Definition at line 191 of file register-allocator.h.

{ return next_; }

References next_.

Referenced by SplitAt().

Here is the caller graph for this function:

NextRegisterPosition()

UsePosition * v8::internal::compiler::LiveRange::NextRegisterPosition

(

LifetimePosition

start

)

Definition at line 174 of file register-allocator.cc.

                                                                   {
  UsePosition* pos = NextUsePosition(start);
  while (pos != NULL && !pos->RequiresRegister()) {
    pos = pos->next();
  }
  return pos;
}

References v8::internal::compiler::UsePosition::next(), NextUsePosition(), NULL, and v8::internal::compiler::UsePosition::RequiresRegister().

Referenced by CanBeSpilled().

Here is the call graph for this function:

Here is the caller graph for this function:

NextUsePosition()

UsePosition * v8::internal::compiler::LiveRange::NextUsePosition

(

LifetimePosition

start

)

Definition at line 141 of file register-allocator.cc.

                                                              {
  UsePosition* use_pos = last_processed_use_;
  if (use_pos == NULL) use_pos = first_pos();
  while (use_pos != NULL && use_pos->pos().Value() < start.Value()) {
    use_pos = use_pos->next();
  }
  last_processed_use_ = use_pos;
  return use_pos;
}

References first_pos(), last_processed_use_, v8::internal::compiler::UsePosition::next(), NULL, v8::internal::compiler::UsePosition::pos(), and v8::internal::compiler::LifetimePosition::Value().

Referenced by NextRegisterPosition(), and NextUsePositionRegisterIsBeneficial().

Here is the call graph for this function:

Here is the caller graph for this function:

NextUsePositionRegisterIsBeneficial()

UsePosition * v8::internal::compiler::LiveRange::NextUsePositionRegisterIsBeneficial

(

LifetimePosition

start

)

Definition at line 152 of file register-allocator.cc.

                            {
  UsePosition* pos = NextUsePosition(start);
  while (pos != NULL && !pos->RegisterIsBeneficial()) {
    pos = pos->next();
  }
  return pos;
}

References v8::internal::compiler::UsePosition::next(), NextUsePosition(), NULL, and v8::internal::compiler::UsePosition::RegisterIsBeneficial().

Here is the call graph for this function:

parent()

LiveRange* v8::internal::compiler::LiveRange::parent ( ) const

inline

Definition at line 189 of file register-allocator.h.

{ return parent_; }

References parent_.

Referenced by IsChild().

Here is the caller graph for this function:

PreviousUsePositionRegisterIsBeneficial()

UsePosition * v8::internal::compiler::LiveRange::PreviousUsePositionRegisterIsBeneficial

(

LifetimePosition

start

)

Definition at line 162 of file register-allocator.cc.

                            {
  UsePosition* pos = first_pos();
  UsePosition* prev = NULL;
  while (pos != NULL && pos->pos().Value() < start.Value()) {
    if (pos->RegisterIsBeneficial()) prev = pos;
    pos = pos->next();
  }
  return prev;
}

References first_pos(), v8::internal::compiler::UsePosition::next(), NULL, v8::internal::compiler::UsePosition::pos(), v8::internal::compiler::UsePosition::RegisterIsBeneficial(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

set_assigned_register()

void v8::internal::compiler::LiveRange::set_assigned_register	(	int	reg,
		Zone *	zone
	)

Definition at line 111 of file register-allocator.cc.

                                                         {
  DCHECK(!HasRegisterAssigned() && !IsSpilled());
  assigned_register_ = reg;
  ConvertOperands(zone);
}

References assigned_register_, ConvertOperands(), DCHECK, HasRegisterAssigned(), and IsSpilled().

Here is the call graph for this function:

set_is_non_loop_phi()

void v8::internal::compiler::LiveRange::set_is_non_loop_phi ( bool  is_non_loop_phi )

inline

Definition at line 204 of file register-allocator.h.

                                                 {
    is_non_loop_phi_ = is_non_loop_phi;
  }

References is_non_loop_phi(), and is_non_loop_phi_.

Here is the call graph for this function:

set_is_phi()

void v8::internal::compiler::LiveRange::set_is_phi ( bool  is_phi )

inline

Definition at line 202 of file register-allocator.h.

{ is_phi_ = is_phi; }

References is_phi(), and is_phi_.

Here is the call graph for this function:

SetSpillOperand()

void v8::internal::compiler::LiveRange::SetSpillOperand

(

InstructionOperand *

operand

)

Definition at line 133 of file register-allocator.cc.

                                                           {
  DCHECK(!operand->IsUnallocated());
  DCHECK(spill_operand_ != NULL);
  DCHECK(spill_operand_->IsIgnored());
  spill_operand_->ConvertTo(operand->kind(), operand->index());
}

References v8::internal::compiler::InstructionOperand::ConvertTo(), DCHECK, v8::internal::compiler::InstructionOperand::index(), v8::internal::compiler::InstructionOperand::kind(), NULL, and spill_operand_.

Here is the call graph for this function:

SetSpillStartIndex()

void v8::internal::compiler::LiveRange::SetSpillStartIndex ( int  start )

inline

Definition at line 267 of file register-allocator.h.

                                     {
    spill_start_index_ = Min(start, spill_start_index_);
  }

References v8::internal::compiler::Min(), and spill_start_index_.

Here is the call graph for this function:

ShortenTo()

void v8::internal::compiler::LiveRange::ShortenTo

(

LifetimePosition

start

)

Definition at line 351 of file register-allocator.cc.

                                                {
  RegisterAllocator::TraceAlloc("Shorten live range %d to [%d\n", id_,
                                start.Value());
  DCHECK(first_interval_ != NULL);
  DCHECK(first_interval_->start().Value() <= start.Value());
  DCHECK(start.Value() < first_interval_->end().Value());
  first_interval_->set_start(start);
}

References DCHECK, v8::internal::compiler::UseInterval::end(), first_interval_, id_, NULL, v8::internal::compiler::UseInterval::set_start(), v8::internal::compiler::UseInterval::start(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

ShouldBeAllocatedBefore()

bool v8::internal::compiler::LiveRange::ShouldBeAllocatedBefore

(

const LiveRange *

other

)

const

Definition at line 337 of file register-allocator.cc.

                                                                    {
  LifetimePosition start = Start();
  LifetimePosition other_start = other->Start();
  if (start.Value() == other_start.Value()) {
    UsePosition* pos = first_pos();
    if (pos == NULL) return false;
    UsePosition* other_pos = other->first_pos();
    if (other_pos == NULL) return true;
    return pos->pos().Value() < other_pos->pos().Value();
  }
  return start.Value() < other_start.Value();
}

References first_pos(), NULL, v8::internal::compiler::UsePosition::pos(), Start(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

spill_start_index()

int v8::internal::compiler::LiveRange::spill_start_index ( ) const

inline

Definition at line 198 of file register-allocator.h.

{ return spill_start_index_; }

References spill_start_index_.

SplitAt()

void v8::internal::compiler::LiveRange::SplitAt	(	LifetimePosition	position,
		LiveRange *	result,
		Zone *	zone
	)

Definition at line 245 of file register-allocator.cc.

                                    {
  DCHECK(Start().Value() < position.Value());
  DCHECK(result->IsEmpty());
  // Find the last interval that ends before the position. If the
  // position is contained in one of the intervals in the chain, we
  // split that interval and use the first part.
  UseInterval* current = FirstSearchIntervalForPosition(position);
 
  // If the split position coincides with the beginning of a use interval
  // we need to split use positons in a special way.
  bool split_at_start = false;
 
  if (current->start().Value() == position.Value()) {
    // When splitting at start we need to locate the previous use interval.
    current = first_interval_;
  }
 
  while (current != NULL) {
    if (current->Contains(position)) {
      current->SplitAt(position, zone);
      break;
    }
    UseInterval* next = current->next();
    if (next->start().Value() >= position.Value()) {
      split_at_start = (next->start().Value() == position.Value());
      break;
    }
    current = next;
  }
 
  // Partition original use intervals to the two live ranges.
  UseInterval* before = current;
  UseInterval* after = before->next();
  result->last_interval_ =
      (last_interval_ == before)
          ? after            // Only interval in the range after split.
          : last_interval_;  // Last interval of the original range.
  result->first_interval_ = after;
  last_interval_ = before;
 
  // Find the last use position before the split and the first use
  // position after it.
  UsePosition* use_after = first_pos_;
  UsePosition* use_before = NULL;
  if (split_at_start) {
    // The split position coincides with the beginning of a use interval (the
    // end of a lifetime hole). Use at this position should be attributed to
    // the split child because split child owns use interval covering it.
    while (use_after != NULL && use_after->pos().Value() < position.Value()) {
      use_before = use_after;
      use_after = use_after->next();
    }
  } else {
    while (use_after != NULL && use_after->pos().Value() <= position.Value()) {
      use_before = use_after;
      use_after = use_after->next();
    }
  }
 
  // Partition original use positions to the two live ranges.
  if (use_before != NULL) {
    use_before->next_ = NULL;
  } else {
    first_pos_ = NULL;
  }
  result->first_pos_ = use_after;
 
  // Discard cached iteration state. It might be pointing
  // to the use that no longer belongs to this live range.
  last_processed_use_ = NULL;
  current_interval_ = NULL;
 
  // Link the new live range in the chain before any of the other
  // ranges linked from the range before the split.
  result->parent_ = (parent_ == NULL) ? this : parent_;
  result->kind_ = result->parent_->kind_;
  result->next_ = next_;
  next_ = result;
 
#ifdef DEBUG
  Verify();
  result->Verify();
#endif
}

References v8::internal::compiler::UseInterval::Contains(), current_interval_, DCHECK, first_interval_, first_pos_, FirstSearchIntervalForPosition(), IsEmpty(), kind_, last_interval_, last_processed_use_, v8::internal::compiler::UseInterval::next(), v8::internal::compiler::UsePosition::next(), next(), v8::internal::compiler::UsePosition::next_, next_, NULL, parent_, v8::internal::compiler::UsePosition::pos(), v8::internal::compiler::UseInterval::SplitAt(), v8::internal::compiler::UseInterval::start(), Start(), and v8::internal::compiler::LifetimePosition::Value().

Here is the call graph for this function:

Start()

LifetimePosition v8::internal::compiler::LiveRange::Start ( ) const

inline

Definition at line 253 of file register-allocator.h.

                                 {
    DCHECK(!IsEmpty());
    return first_interval()->start();
  }

References DCHECK, first_interval(), IsEmpty(), and v8::internal::compiler::UseInterval::start().

Referenced by CanCover(), ConvertOperands(), ShouldBeAllocatedBefore(), and SplitAt().

Here is the call graph for this function:

Here is the caller graph for this function:

TopLevel()

LiveRange* v8::internal::compiler::LiveRange::TopLevel ( )

inline

Definition at line 190 of file register-allocator.h.

{ return (parent_ == NULL) ? this : parent_; }

References NULL, and parent_.

Referenced by CreateAssignedOperand(), and MakeSpilled().

Here is the caller graph for this function:

Friends And Related Function Documentation

RegisterAllocator

friend class RegisterAllocator

friend

Definition at line 316 of file register-allocator.h.

Member Data Documentation

assigned_register_

int v8::internal::compiler::LiveRange::assigned_register_

private

Definition at line 302 of file register-allocator.h.

Referenced by assigned_register(), HasRegisterAssigned(), MakeSpilled(), and set_assigned_register().

current_hint_operand_

InstructionOperand* v8::internal::compiler::LiveRange::current_hint_operand_

private

Definition at line 312 of file register-allocator.h.

Referenced by AddUsePosition(), and current_hint_operand().

current_interval_

UseInterval* v8::internal::compiler::LiveRange::current_interval_

mutableprivate

Definition at line 309 of file register-allocator.h.

Referenced by AdvanceLastProcessedMarker(), FirstSearchIntervalForPosition(), and SplitAt().

first_interval_

UseInterval* v8::internal::compiler::LiveRange::first_interval_

private

Definition at line 304 of file register-allocator.h.

Referenced by AddUseInterval(), EnsureInterval(), first_interval(), FirstSearchIntervalForPosition(), ShortenTo(), and SplitAt().

first_pos_

UsePosition* v8::internal::compiler::LiveRange::first_pos_

private

Definition at line 305 of file register-allocator.h.

Referenced by AddUsePosition(), first_pos(), FirstHint(), and SplitAt().

id_

int v8::internal::compiler::LiveRange::id_

private

Definition at line 297 of file register-allocator.h.

Referenced by AddUseInterval(), AddUsePosition(), CreateAssignedOperand(), EnsureInterval(), id(), IsFixed(), and ShortenTo().

is_non_loop_phi_

bool v8::internal::compiler::LiveRange::is_non_loop_phi_

private

Definition at line 300 of file register-allocator.h.

Referenced by is_non_loop_phi(), and set_is_non_loop_phi().

is_phi_

bool v8::internal::compiler::LiveRange::is_phi_

private

Definition at line 299 of file register-allocator.h.

Referenced by is_phi(), and set_is_phi().

kind_

RegisterKind v8::internal::compiler::LiveRange::kind_

private

Definition at line 301 of file register-allocator.h.

Referenced by Kind(), and SplitAt().

kInvalidAssignment

const int v8::internal::compiler::LiveRange::kInvalidAssignment = 0x7fffffff

static

Definition at line 183 of file register-allocator.h.

Referenced by HasRegisterAssigned(), and MakeSpilled().

last_interval_

UseInterval* v8::internal::compiler::LiveRange::last_interval_

private

Definition at line 303 of file register-allocator.h.

Referenced by AddUseInterval(), End(), EnsureInterval(), and SplitAt().

last_processed_use_

UsePosition* v8::internal::compiler::LiveRange::last_processed_use_

private

Definition at line 310 of file register-allocator.h.

Referenced by NextUsePosition(), and SplitAt().

next_

LiveRange* v8::internal::compiler::LiveRange::next_

private

Definition at line 307 of file register-allocator.h.

Referenced by next(), and SplitAt().

parent_

LiveRange* v8::internal::compiler::LiveRange::parent_

private

Definition at line 306 of file register-allocator.h.

Referenced by parent(), SplitAt(), and TopLevel().

spill_operand_

InstructionOperand* v8::internal::compiler::LiveRange::spill_operand_

private

Definition at line 313 of file register-allocator.h.

Referenced by GetSpillOperand(), HasAllocatedSpillOperand(), and SetSpillOperand().

spill_start_index_

int v8::internal::compiler::LiveRange::spill_start_index_

private

Definition at line 314 of file register-allocator.h.

Referenced by SetSpillStartIndex(), and spill_start_index().

spilled_

bool v8::internal::compiler::LiveRange::spilled_

private

Definition at line 298 of file register-allocator.h.

Referenced by IsSpilled(), and MakeSpilled().

---

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

• /mnt/V8SourceCode/src/compiler/register-allocator.h
• /mnt/V8SourceCode/src/compiler/register-allocator.cc