V8 Project
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
v8::internal::compiler::BASE_EMBEDDED Class Referenceabstract

#include <ast-graph-builder.h>

+ Collaboration diagram for v8::internal::compiler::BASE_EMBEDDED:

Public Member Functions

bool IsEffect () const
 
bool IsValue () const
 
bool IsTest () const
 
OutputFrameStateCombine GetStateCombine ()
 
virtual void ProduceValue (Node *value)=0
 
virtual Node * ConsumeValue ()=0
 
void ReplaceValue ()
 
 BreakableScope (AstGraphBuilder *owner, BreakableStatement *target, ControlBuilder *control, int drop_extra)
 
 ~BreakableScope ()
 
void BreakTarget (BreakableStatement *target)
 
void ContinueTarget (BreakableStatement *target)
 
 ContextScope (AstGraphBuilder *owner, Scope *scope, Node *context)
 
 ~ContextScope ()
 
Scope * scope () const
 
 RegisterAllocator (InstructionSequence *code)
 
bool HasTaggedValue (int virtual_register) const
 
RegisterKind RequiredRegisterKind (int virtual_register) const
 
bool Allocate ()
 
const ZoneList< LiveRange * > * live_ranges () const
 
const Vector< LiveRange * > * fixed_live_ranges () const
 
const Vector< LiveRange * > * fixed_double_live_ranges () const
 
InstructionSequence * code () const
 
Zone * zone ()
 
Zone * code_zone ()
 
int GetVirtualRegister ()
 
bool AllocationOk ()
 
BitVector * assigned_registers ()
 
BitVector * assigned_double_registers ()
 

Static Public Member Functions

static void TraceAlloc (const char *msg,...)
 

Protected Member Functions

 AstContext (AstGraphBuilder *owner, Expression::Context kind)
 
virtual ~AstContext ()
 
AstGraphBuilder * owner () const
 
Environment * environment () const
 

Private Member Functions

BreakableScope * FindBreakable (BreakableStatement *target)
 
void MeetRegisterConstraints ()
 
void ResolvePhis ()
 
void BuildLiveRanges ()
 
void AllocateGeneralRegisters ()
 
void AllocateDoubleRegisters ()
 
void ConnectRanges ()
 
void ResolveControlFlow ()
 
void PopulatePointerMaps ()
 
void AllocateRegisters ()
 
bool CanEagerlyResolveControlFlow (BasicBlock *block) const
 
bool SafePointsAreInOrder () const
 
void InitializeLivenessAnalysis ()
 
BitVector * ComputeLiveOut (BasicBlock *block)
 
void AddInitialIntervals (BasicBlock *block, BitVector *live_out)
 
bool IsOutputRegisterOf (Instruction *instr, int index)
 
bool IsOutputDoubleRegisterOf (Instruction *instr, int index)
 
void ProcessInstructions (BasicBlock *block, BitVector *live)
 
void MeetRegisterConstraints (BasicBlock *block)
 
void MeetConstraintsBetween (Instruction *first, Instruction *second, int gap_index)
 
void MeetRegisterConstraintsForLastInstructionInBlock (BasicBlock *block)
 
void ResolvePhis (BasicBlock *block)
 
InstructionOperand * AllocateFixed (UnallocatedOperand *operand, int pos, bool is_tagged)
 
LiveRange * LiveRangeFor (InstructionOperand *operand)
 
void Define (LifetimePosition position, InstructionOperand *operand, InstructionOperand *hint)
 
void Use (LifetimePosition block_start, LifetimePosition position, InstructionOperand *operand, InstructionOperand *hint)
 
void AddConstraintsGapMove (int index, InstructionOperand *from, InstructionOperand *to)
 
void AddToActive (LiveRange *range)
 
void AddToInactive (LiveRange *range)
 
void AddToUnhandledSorted (LiveRange *range)
 
void AddToUnhandledUnsorted (LiveRange *range)
 
void SortUnhandled ()
 
bool UnhandledIsSorted ()
 
void ActiveToHandled (LiveRange *range)
 
void ActiveToInactive (LiveRange *range)
 
void InactiveToHandled (LiveRange *range)
 
void InactiveToActive (LiveRange *range)
 
void FreeSpillSlot (LiveRange *range)
 
InstructionOperand * TryReuseSpillSlot (LiveRange *range)
 
bool TryAllocateFreeReg (LiveRange *range)
 
void AllocateBlockedReg (LiveRange *range)
 
LiveRange * SplitRangeAt (LiveRange *range, LifetimePosition pos)
 
LiveRange * SplitBetween (LiveRange *range, LifetimePosition start, LifetimePosition end)
 
LifetimePosition FindOptimalSplitPos (LifetimePosition start, LifetimePosition end)
 
void SpillAfter (LiveRange *range, LifetimePosition pos)
 
void SpillBetween (LiveRange *range, LifetimePosition start, LifetimePosition end)
 
void SpillBetweenUntil (LiveRange *range, LifetimePosition start, LifetimePosition until, LifetimePosition end)
 
void SplitAndSpillIntersecting (LiveRange *range)
 
LifetimePosition FindOptimalSpillingPos (LiveRange *range, LifetimePosition pos)
 
void Spill (LiveRange *range)
 
bool IsBlockBoundary (LifetimePosition pos)
 
void ResolveControlFlow (LiveRange *range, BasicBlock *block, BasicBlock *pred)
 
void SetLiveRangeAssignedRegister (LiveRange *range, int reg)
 
ParallelMove * GetConnectingParallelMove (LifetimePosition pos)
 
BasicBlock * GetBlock (LifetimePosition pos)
 
int RegisterCount () const
 
LiveRange * FixedLiveRangeFor (int index)
 
LiveRange * FixedDoubleLiveRangeFor (int index)
 
LiveRange * LiveRangeFor (int index)
 
GapInstruction * GetLastGap (BasicBlock *block)
 
const char * RegisterName (int allocation_index)
 
Instruction * InstructionAt (int index)
 
 DISALLOW_COPY_AND_ASSIGN (RegisterAllocator)
 

Static Private Member Functions

static int FixedLiveRangeID (int index)
 
static int FixedDoubleLiveRangeID (int index)
 

Private Attributes

Expression::Context kind_
 
AstGraphBuilder * owner_
 
AstContext * outer_
 
BreakableStatement * target_
 
BreakableScope * next_
 
ControlBuilder * control_
 
int drop_extra_
 
ContextScope * next_
 
Node * outer_
 
Scope * scope_
 
Zone zone_
 
InstructionSequence * code_
 
ZoneList< BitVector * > live_in_sets_
 
ZoneList< LiveRange * > live_ranges_
 
EmbeddedVector< LiveRange *, Register::kMaxNumAllocatableRegisters > fixed_live_ranges_
 
EmbeddedVector< LiveRange *, DoubleRegister::kMaxNumAllocatableRegisters > fixed_double_live_ranges_
 
ZoneList< LiveRange * > unhandled_live_ranges_
 
ZoneList< LiveRange * > active_live_ranges_
 
ZoneList< LiveRange * > inactive_live_ranges_
 
ZoneList< LiveRange * > reusable_slots_
 
RegisterKind mode_
 
int num_registers_
 
BitVector * assigned_registers_
 
BitVector * assigned_double_registers_
 
bool allocation_ok_
 

Detailed Description

Definition at line 282 of file ast-graph-builder.h.

Constructor & Destructor Documentation

◆ ~AstContext()

virtual v8::internal::compiler::BASE_EMBEDDED::~AstContext ( )
protectedvirtual

◆ ~BreakableScope()

v8::internal::compiler::BASE_EMBEDDED::~BreakableScope ( )
inline

Definition at line 373 of file ast-graph-builder.h.

373  {
374  owner_->set_breakable(next_); // Pop.
375  }
v8::internal::compiler::AstGraphBuilder::set_breakable
void set_breakable(BreakableScope *brk)
Definition: ast-graph-builder.h:52
v8::internal::compiler::BASE_EMBEDDED::next_
BreakableScope * next_
Definition: ast-graph-builder.h:384
v8::internal::compiler::BASE_EMBEDDED::owner_
AstGraphBuilder * owner_
Definition: ast-graph-builder.h:320

◆ ~ContextScope()

v8::internal::compiler::BASE_EMBEDDED::~ContextScope ( )
inline

Definition at line 408 of file ast-graph-builder.h.

408  {
409  owner_->set_execution_context(next_); // Pop.
410  owner_->set_current_context(outer_);
411  }
v8::internal::compiler::AstGraphBuilder::set_execution_context
void set_execution_context(ContextScope *ctx)
Definition: ast-graph-builder.h:53
v8::internal::compiler::BASE_EMBEDDED::outer_
AstContext * outer_
Definition: ast-graph-builder.h:321

Member Function Documentation

◆ ActiveToHandled()

void v8::internal::compiler::BASE_EMBEDDED::ActiveToHandled ( LiveRange *  range)
private

◆ ActiveToInactive()

void v8::internal::compiler::BASE_EMBEDDED::ActiveToInactive ( LiveRange *  range)
private

◆ AddConstraintsGapMove()

void v8::internal::compiler::BASE_EMBEDDED::AddConstraintsGapMove ( int  index,
InstructionOperand *  from,
InstructionOperand *  to 
)
private

◆ AddInitialIntervals()

void v8::internal::compiler::BASE_EMBEDDED::AddInitialIntervals ( BasicBlock *  block,
BitVector *  live_out 
)
private

◆ AddToActive()

void v8::internal::compiler::BASE_EMBEDDED::AddToActive ( LiveRange *  range)
private

◆ AddToInactive()

void v8::internal::compiler::BASE_EMBEDDED::AddToInactive ( LiveRange *  range)
private

◆ AddToUnhandledSorted()

void v8::internal::compiler::BASE_EMBEDDED::AddToUnhandledSorted ( LiveRange *  range)
private

◆ AddToUnhandledUnsorted()

void v8::internal::compiler::BASE_EMBEDDED::AddToUnhandledUnsorted ( LiveRange *  range)
private

◆ Allocate()

bool v8::internal::compiler::BASE_EMBEDDED::Allocate ( )

◆ AllocateBlockedReg()

void v8::internal::compiler::BASE_EMBEDDED::AllocateBlockedReg ( LiveRange *  range)
private

◆ AllocateDoubleRegisters()

void v8::internal::compiler::BASE_EMBEDDED::AllocateDoubleRegisters ( )
private

◆ AllocateFixed()

InstructionOperand* v8::internal::compiler::BASE_EMBEDDED::AllocateFixed ( UnallocatedOperand *  operand,
int  pos,
bool  is_tagged 
)
private

◆ AllocateGeneralRegisters()

void v8::internal::compiler::BASE_EMBEDDED::AllocateGeneralRegisters ( )
private

◆ AllocateRegisters()

void v8::internal::compiler::BASE_EMBEDDED::AllocateRegisters ( )
private

◆ AllocationOk()

bool v8::internal::compiler::BASE_EMBEDDED::AllocationOk ( )
inline

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

362 { return allocation_ok_; }
v8::internal::compiler::BASE_EMBEDDED::allocation_ok_
bool allocation_ok_
Definition: register-allocator.h:523

◆ assigned_double_registers()

BitVector* v8::internal::compiler::BASE_EMBEDDED::assigned_double_registers ( )
inline

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

369 { return assigned_double_registers_; }
v8::internal::compiler::BASE_EMBEDDED::assigned_double_registers_
BitVector * assigned_double_registers_
Definition: register-allocator.h:520

◆ assigned_registers()

BitVector* v8::internal::compiler::BASE_EMBEDDED::assigned_registers ( )
inline

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

368 { return assigned_registers_; }
v8::internal::compiler::BASE_EMBEDDED::assigned_registers_
BitVector * assigned_registers_
Definition: register-allocator.h:519

◆ AstContext()

v8::internal::compiler::BASE_EMBEDDED::AstContext ( AstGraphBuilder *  owner,
Expression::Context  kind 
)
protected

◆ BreakableScope()

v8::internal::compiler::BASE_EMBEDDED::BreakableScope ( AstGraphBuilder *  owner,
BreakableStatement *  target,
ControlBuilder *  control,
int  drop_extra 
)
inline

Definition at line 363 of file ast-graph-builder.h.

365  : owner_(owner),
366  target_(target),
367  next_(owner->breakable()),
368  control_(control),
369  drop_extra_(drop_extra) {
370  owner_->set_breakable(this); // Push.
371  }
v8::internal::compiler::BASE_EMBEDDED::control_
ControlBuilder * control_
Definition: ast-graph-builder.h:385
v8::internal::compiler::BASE_EMBEDDED::owner
AstGraphBuilder * owner() const
Definition: ast-graph-builder.h:309
v8::internal::compiler::BASE_EMBEDDED::drop_extra_
int drop_extra_
Definition: ast-graph-builder.h:386
v8::internal::compiler::BASE_EMBEDDED::target_
BreakableStatement * target_
Definition: ast-graph-builder.h:383

◆ BreakTarget()

void v8::internal::compiler::BASE_EMBEDDED::BreakTarget ( BreakableStatement *  target)

◆ BuildLiveRanges()

void v8::internal::compiler::BASE_EMBEDDED::BuildLiveRanges ( )
private

◆ CanEagerlyResolveControlFlow()

bool v8::internal::compiler::BASE_EMBEDDED::CanEagerlyResolveControlFlow ( BasicBlock *  block) const
private

◆ code()

InstructionSequence* v8::internal::compiler::BASE_EMBEDDED::code ( ) const
inline

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

343 { return code_; }
v8::internal::compiler::BASE_EMBEDDED::code_
InstructionSequence * code_
Definition: register-allocator.h:497

◆ code_zone()

Zone* v8::internal::compiler::BASE_EMBEDDED::code_zone ( )
inline

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

350 { return code()->zone(); }
v8::internal::compiler::BASE_EMBEDDED::code
InstructionSequence * code() const
Definition: register-allocator.h:343

◆ ComputeLiveOut()

BitVector* v8::internal::compiler::BASE_EMBEDDED::ComputeLiveOut ( BasicBlock *  block)
private

◆ ConnectRanges()

void v8::internal::compiler::BASE_EMBEDDED::ConnectRanges ( )
private

◆ ConsumeValue()

virtual Node* v8::internal::compiler::BASE_EMBEDDED::ConsumeValue ( )
pure virtual

◆ ContextScope()

v8::internal::compiler::BASE_EMBEDDED::ContextScope ( AstGraphBuilder *  owner,
Scope *  scope,
Node *  context 
)
inline

Definition at line 399 of file ast-graph-builder.h.

400  : owner_(owner),
401  next_(owner->execution_context()),
402  outer_(owner->current_context()),
403  scope_(scope) {
404  owner_->set_execution_context(this); // Push.
405  owner_->set_current_context(context);
406  }
v8::internal::compiler::BASE_EMBEDDED::scope
Scope * scope() const
Definition: ast-graph-builder.h:414
v8::internal::compiler::BASE_EMBEDDED::scope_
Scope * scope_
Definition: ast-graph-builder.h:420

◆ ContinueTarget()

void v8::internal::compiler::BASE_EMBEDDED::ContinueTarget ( BreakableStatement *  target)

◆ Define()

void v8::internal::compiler::BASE_EMBEDDED::Define ( LifetimePosition  position,
InstructionOperand *  operand,
InstructionOperand *  hint 
)
private

◆ DISALLOW_COPY_AND_ASSIGN()

v8::internal::compiler::BASE_EMBEDDED::DISALLOW_COPY_AND_ASSIGN ( RegisterAllocator  )
private

◆ environment()

Environment* v8::internal::compiler::BASE_EMBEDDED::environment ( ) const
inlineprotected

Definition at line 310 of file ast-graph-builder.h.

310 { return owner_->environment(); }

◆ FindBreakable()

BreakableScope* v8::internal::compiler::BASE_EMBEDDED::FindBreakable ( BreakableStatement *  target)
private

◆ FindOptimalSpillingPos()

LifetimePosition v8::internal::compiler::BASE_EMBEDDED::FindOptimalSpillingPos ( LiveRange *  range,
LifetimePosition  pos 
)
private

◆ FindOptimalSplitPos()

LifetimePosition v8::internal::compiler::BASE_EMBEDDED::FindOptimalSplitPos ( LifetimePosition  start,
LifetimePosition  end 
)
private

◆ fixed_double_live_ranges()

const Vector<LiveRange*>* v8::internal::compiler::BASE_EMBEDDED::fixed_double_live_ranges ( ) const
inline

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

339  {
340  return &fixed_double_live_ranges_;
341  }
v8::internal::compiler::BASE_EMBEDDED::fixed_double_live_ranges_
EmbeddedVector< LiveRange *, DoubleRegister::kMaxNumAllocatableRegisters > fixed_double_live_ranges_
Definition: register-allocator.h:510

◆ fixed_live_ranges()

const Vector<LiveRange*>* v8::internal::compiler::BASE_EMBEDDED::fixed_live_ranges ( ) const
inline

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

336  {
337  return &fixed_live_ranges_;
338  }
v8::internal::compiler::BASE_EMBEDDED::fixed_live_ranges_
EmbeddedVector< LiveRange *, Register::kMaxNumAllocatableRegisters > fixed_live_ranges_
Definition: register-allocator.h:508

◆ FixedDoubleLiveRangeFor()

LiveRange* v8::internal::compiler::BASE_EMBEDDED::FixedDoubleLiveRangeFor ( int  index)
private

◆ FixedDoubleLiveRangeID()

static int v8::internal::compiler::BASE_EMBEDDED::FixedDoubleLiveRangeID ( int  index)
staticprivate

◆ FixedLiveRangeFor()

LiveRange* v8::internal::compiler::BASE_EMBEDDED::FixedLiveRangeFor ( int  index)
private

◆ FixedLiveRangeID()

static int v8::internal::compiler::BASE_EMBEDDED::FixedLiveRangeID ( int  index)
inlinestaticprivate

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

483 { return -index - 1; }

◆ FreeSpillSlot()

void v8::internal::compiler::BASE_EMBEDDED::FreeSpillSlot ( LiveRange *  range)
private

◆ GetBlock()

BasicBlock* v8::internal::compiler::BASE_EMBEDDED::GetBlock ( LifetimePosition  pos)
private

◆ GetConnectingParallelMove()

ParallelMove* v8::internal::compiler::BASE_EMBEDDED::GetConnectingParallelMove ( LifetimePosition  pos)
private

◆ GetLastGap()

GapInstruction* v8::internal::compiler::BASE_EMBEDDED::GetLastGap ( BasicBlock *  block)
private

◆ GetStateCombine()

OutputFrameStateCombine v8::internal::compiler::BASE_EMBEDDED::GetStateCombine ( )
inline

Definition at line 290 of file ast-graph-builder.h.

290  {
291  return IsEffect() ? kIgnoreOutput : kPushOutput;
292  }
v8::internal::compiler::BASE_EMBEDDED::IsEffect
bool IsEffect() const
Definition: ast-graph-builder.h:284

References v8::internal::compiler::kIgnoreOutput, and v8::internal::compiler::kPushOutput.

◆ GetVirtualRegister()

int v8::internal::compiler::BASE_EMBEDDED::GetVirtualRegister ( )
inline

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

352  {
353  int vreg = code()->NextVirtualRegister();
354  if (vreg >= UnallocatedOperand::kMaxVirtualRegisters) {
355  allocation_ok_ = false;
356  // Maintain the invariant that we return something below the maximum.
357  return 0;
358  }
359  return vreg;
360  }

References v8::internal::compiler::UnallocatedOperand::kMaxVirtualRegisters.

◆ HasTaggedValue()

bool v8::internal::compiler::BASE_EMBEDDED::HasTaggedValue ( int  virtual_register) const

◆ InactiveToActive()

void v8::internal::compiler::BASE_EMBEDDED::InactiveToActive ( LiveRange *  range)
private

◆ InactiveToHandled()

void v8::internal::compiler::BASE_EMBEDDED::InactiveToHandled ( LiveRange *  range)
private

◆ InitializeLivenessAnalysis()

void v8::internal::compiler::BASE_EMBEDDED::InitializeLivenessAnalysis ( )
private

◆ InstructionAt()

Instruction* v8::internal::compiler::BASE_EMBEDDED::InstructionAt ( int  index)
inlineprivate

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

492  {
493  return code()->InstructionAt(index);
494  }

◆ IsBlockBoundary()

bool v8::internal::compiler::BASE_EMBEDDED::IsBlockBoundary ( LifetimePosition  pos)
private

◆ IsEffect()

bool v8::internal::compiler::BASE_EMBEDDED::IsEffect ( ) const
inline

Definition at line 284 of file ast-graph-builder.h.

284 { return kind_ == Expression::kEffect; }
v8::internal::compiler::BASE_EMBEDDED::kind_
Expression::Context kind_
Definition: ast-graph-builder.h:319

References v8::internal::Expression::kEffect.

◆ IsOutputDoubleRegisterOf()

bool v8::internal::compiler::BASE_EMBEDDED::IsOutputDoubleRegisterOf ( Instruction *  instr,
int  index 
)
private

◆ IsOutputRegisterOf()

bool v8::internal::compiler::BASE_EMBEDDED::IsOutputRegisterOf ( Instruction *  instr,
int  index 
)
private

◆ IsTest()

bool v8::internal::compiler::BASE_EMBEDDED::IsTest ( ) const
inline

Definition at line 286 of file ast-graph-builder.h.

286 { return kind_ == Expression::kTest; }

References v8::internal::Expression::kTest.

◆ IsValue()

bool v8::internal::compiler::BASE_EMBEDDED::IsValue ( ) const
inline

Definition at line 285 of file ast-graph-builder.h.

285 { return kind_ == Expression::kValue; }

References v8::internal::Expression::kValue.

◆ live_ranges()

const ZoneList<LiveRange*>* v8::internal::compiler::BASE_EMBEDDED::live_ranges ( ) const
inline

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

335 { return &live_ranges_; }
v8::internal::compiler::BASE_EMBEDDED::live_ranges_
ZoneList< LiveRange * > live_ranges_
Definition: register-allocator.h:504

◆ LiveRangeFor() [1/2]

LiveRange* v8::internal::compiler::BASE_EMBEDDED::LiveRangeFor ( InstructionOperand *  operand)
private

◆ LiveRangeFor() [2/2]

LiveRange* v8::internal::compiler::BASE_EMBEDDED::LiveRangeFor ( int  index)
private

◆ MeetConstraintsBetween()

void v8::internal::compiler::BASE_EMBEDDED::MeetConstraintsBetween ( Instruction *  first,
Instruction *  second,
int  gap_index 
)
private

◆ MeetRegisterConstraints() [1/2]

void v8::internal::compiler::BASE_EMBEDDED::MeetRegisterConstraints ( )
private

◆ MeetRegisterConstraints() [2/2]

void v8::internal::compiler::BASE_EMBEDDED::MeetRegisterConstraints ( BasicBlock *  block)
private

◆ MeetRegisterConstraintsForLastInstructionInBlock()

void v8::internal::compiler::BASE_EMBEDDED::MeetRegisterConstraintsForLastInstructionInBlock ( BasicBlock *  block)
private

◆ owner()

AstGraphBuilder* v8::internal::compiler::BASE_EMBEDDED::owner ( ) const
inlineprotected

Definition at line 309 of file ast-graph-builder.h.

309 { return owner_; }

◆ PopulatePointerMaps()

void v8::internal::compiler::BASE_EMBEDDED::PopulatePointerMaps ( )
private

◆ ProcessInstructions()

void v8::internal::compiler::BASE_EMBEDDED::ProcessInstructions ( BasicBlock *  block,
BitVector *  live 
)
private

◆ ProduceValue()

virtual void v8::internal::compiler::BASE_EMBEDDED::ProduceValue ( Node *  value)
pure virtual

◆ RegisterAllocator()

v8::internal::compiler::BASE_EMBEDDED::RegisterAllocator ( InstructionSequence *  code)
explicit

◆ RegisterCount()

int v8::internal::compiler::BASE_EMBEDDED::RegisterCount ( ) const
private

◆ RegisterName()

const char* v8::internal::compiler::BASE_EMBEDDED::RegisterName ( int  allocation_index)
private

◆ ReplaceValue()

void v8::internal::compiler::BASE_EMBEDDED::ReplaceValue ( )
inline

Definition at line 303 of file ast-graph-builder.h.

303 { ProduceValue(ConsumeValue()); }
v8::internal::compiler::BASE_EMBEDDED::ProduceValue
virtual void ProduceValue(Node *value)=0
v8::internal::compiler::BASE_EMBEDDED::ConsumeValue
virtual Node * ConsumeValue()=0

◆ RequiredRegisterKind()

RegisterKind v8::internal::compiler::BASE_EMBEDDED::RequiredRegisterKind ( int  virtual_register) const

◆ ResolveControlFlow() [1/2]

void v8::internal::compiler::BASE_EMBEDDED::ResolveControlFlow ( )
private

◆ ResolveControlFlow() [2/2]

void v8::internal::compiler::BASE_EMBEDDED::ResolveControlFlow ( LiveRange *  range,
BasicBlock *  block,
BasicBlock *  pred 
)
private

◆ ResolvePhis() [1/2]

void v8::internal::compiler::BASE_EMBEDDED::ResolvePhis ( )
private

◆ ResolvePhis() [2/2]

void v8::internal::compiler::BASE_EMBEDDED::ResolvePhis ( BasicBlock *  block)
private

◆ SafePointsAreInOrder()

bool v8::internal::compiler::BASE_EMBEDDED::SafePointsAreInOrder ( ) const
inlineprivate

◆ scope()

Scope* v8::internal::compiler::BASE_EMBEDDED::scope ( ) const
inline

Definition at line 414 of file ast-graph-builder.h.

414 { return scope_; }

◆ SetLiveRangeAssignedRegister()

void v8::internal::compiler::BASE_EMBEDDED::SetLiveRangeAssignedRegister ( LiveRange *  range,
int  reg 
)
inlineprivate

◆ SortUnhandled()

void v8::internal::compiler::BASE_EMBEDDED::SortUnhandled ( )
private

◆ Spill()

void v8::internal::compiler::BASE_EMBEDDED::Spill ( LiveRange *  range)
private

◆ SpillAfter()

void v8::internal::compiler::BASE_EMBEDDED::SpillAfter ( LiveRange *  range,
LifetimePosition  pos 
)
private

◆ SpillBetween()

void v8::internal::compiler::BASE_EMBEDDED::SpillBetween ( LiveRange *  range,
LifetimePosition  start,
LifetimePosition  end 
)
private

◆ SpillBetweenUntil()

void v8::internal::compiler::BASE_EMBEDDED::SpillBetweenUntil ( LiveRange *  range,
LifetimePosition  start,
LifetimePosition  until,
LifetimePosition  end 
)
private

◆ SplitAndSpillIntersecting()

void v8::internal::compiler::BASE_EMBEDDED::SplitAndSpillIntersecting ( LiveRange *  range)
private

◆ SplitBetween()

LiveRange* v8::internal::compiler::BASE_EMBEDDED::SplitBetween ( LiveRange *  range,
LifetimePosition  start,
LifetimePosition  end 
)
private

◆ SplitRangeAt()

LiveRange* v8::internal::compiler::BASE_EMBEDDED::SplitRangeAt ( LiveRange *  range,
LifetimePosition  pos 
)
private

◆ TraceAlloc()

static void v8::internal::compiler::BASE_EMBEDDED::TraceAlloc ( const char *  msg,
  ... 
)
static

◆ TryAllocateFreeReg()

bool v8::internal::compiler::BASE_EMBEDDED::TryAllocateFreeReg ( LiveRange *  range)
private

◆ TryReuseSpillSlot()

InstructionOperand* v8::internal::compiler::BASE_EMBEDDED::TryReuseSpillSlot ( LiveRange *  range)
private

◆ UnhandledIsSorted()

bool v8::internal::compiler::BASE_EMBEDDED::UnhandledIsSorted ( )
private

◆ Use()

void v8::internal::compiler::BASE_EMBEDDED::Use ( LifetimePosition  block_start,
LifetimePosition  position,
InstructionOperand *  operand,
InstructionOperand *  hint 
)
private

◆ zone()

Zone* v8::internal::compiler::BASE_EMBEDDED::zone ( )
inline

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

346 { return &zone_; }
v8::internal::compiler::BASE_EMBEDDED::zone_
Zone zone_
Definition: register-allocator.h:496

Member Data Documentation

◆ active_live_ranges_

ZoneList<LiveRange*> v8::internal::compiler::BASE_EMBEDDED::active_live_ranges_
private

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

◆ allocation_ok_

bool v8::internal::compiler::BASE_EMBEDDED::allocation_ok_
private

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

◆ assigned_double_registers_

BitVector* v8::internal::compiler::BASE_EMBEDDED::assigned_double_registers_
private

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

◆ assigned_registers_

BitVector* v8::internal::compiler::BASE_EMBEDDED::assigned_registers_
private

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

◆ code_

InstructionSequence* v8::internal::compiler::BASE_EMBEDDED::code_
private

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

◆ control_

ControlBuilder* v8::internal::compiler::BASE_EMBEDDED::control_
private

Definition at line 385 of file ast-graph-builder.h.

◆ drop_extra_

int v8::internal::compiler::BASE_EMBEDDED::drop_extra_
private

Definition at line 386 of file ast-graph-builder.h.

◆ fixed_double_live_ranges_

EmbeddedVector<LiveRange*, DoubleRegister::kMaxNumAllocatableRegisters> v8::internal::compiler::BASE_EMBEDDED::fixed_double_live_ranges_
private

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

◆ fixed_live_ranges_

EmbeddedVector<LiveRange*, Register::kMaxNumAllocatableRegisters> v8::internal::compiler::BASE_EMBEDDED::fixed_live_ranges_
private

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

◆ inactive_live_ranges_

ZoneList<LiveRange*> v8::internal::compiler::BASE_EMBEDDED::inactive_live_ranges_
private

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

◆ kind_

Expression::Context v8::internal::compiler::BASE_EMBEDDED::kind_
private

Definition at line 319 of file ast-graph-builder.h.

◆ live_in_sets_

ZoneList<BitVector*> v8::internal::compiler::BASE_EMBEDDED::live_in_sets_
private

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

◆ live_ranges_

ZoneList<LiveRange*> v8::internal::compiler::BASE_EMBEDDED::live_ranges_
private

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

◆ mode_

RegisterKind v8::internal::compiler::BASE_EMBEDDED::mode_
private

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

◆ next_ [1/2]

BreakableScope* v8::internal::compiler::BASE_EMBEDDED::next_
private

Definition at line 384 of file ast-graph-builder.h.

◆ next_ [2/2]

ContextScope* v8::internal::compiler::BASE_EMBEDDED::next_
private

Definition at line 418 of file ast-graph-builder.h.

◆ num_registers_

int v8::internal::compiler::BASE_EMBEDDED::num_registers_
private

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

◆ outer_ [1/2]

AstContext* v8::internal::compiler::BASE_EMBEDDED::outer_
private

Definition at line 321 of file ast-graph-builder.h.

◆ outer_ [2/2]

Node* v8::internal::compiler::BASE_EMBEDDED::outer_
private

Definition at line 419 of file ast-graph-builder.h.

◆ owner_

AstGraphBuilder * v8::internal::compiler::BASE_EMBEDDED::owner_
private

Definition at line 320 of file ast-graph-builder.h.

◆ reusable_slots_

ZoneList<LiveRange*> v8::internal::compiler::BASE_EMBEDDED::reusable_slots_
private

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

◆ scope_

Scope* v8::internal::compiler::BASE_EMBEDDED::scope_
private

Definition at line 420 of file ast-graph-builder.h.

◆ target_

BreakableStatement* v8::internal::compiler::BASE_EMBEDDED::target_
private

Definition at line 383 of file ast-graph-builder.h.

◆ unhandled_live_ranges_

ZoneList<LiveRange*> v8::internal::compiler::BASE_EMBEDDED::unhandled_live_ranges_
private

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

◆ zone_

Zone v8::internal::compiler::BASE_EMBEDDED::zone_
private

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

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