#include <lithium.h>

Inheritance diagram for v8::internal::LUnallocated:

Collaboration diagram for v8::internal::LUnallocated:

Classes
class	BasicPolicyField

class	ExtendedPolicyField

class	FixedRegisterField

class	FixedSlotIndexField

class	LifetimeField

class	VirtualRegisterField

Public Types
enum	BasicPolicy { FIXED_SLOT , EXTENDED_POLICY }

enum	ExtendedPolicy { NONE , ANY , FIXED_REGISTER , FIXED_DOUBLE_REGISTER , MUST_HAVE_REGISTER , MUST_HAVE_DOUBLE_REGISTER , WRITABLE_REGISTER , SAME_AS_FIRST_INPUT }

enum	Lifetime { USED_AT_START , USED_AT_END }

Public Types inherited from v8::internal::LOperand
enum	Kind { INVALID , UNALLOCATED , CONSTANT_OPERAND , STACK_SLOT , DOUBLE_STACK_SLOT , REGISTER , DOUBLE_REGISTER }

Public Member Functions
	LUnallocated (ExtendedPolicy policy)

	LUnallocated (BasicPolicy policy, int index)

	LUnallocated (ExtendedPolicy policy, int index)

	LUnallocated (ExtendedPolicy policy, Lifetime lifetime)

LUnallocated *	CopyUnconstrained (Zone *zone)

	STATIC_ASSERT (kKindFieldWidth==3)

bool	HasAnyPolicy () const

bool	HasFixedPolicy () const

bool	HasRegisterPolicy () const

bool	HasDoubleRegisterPolicy () const

bool	HasSameAsInputPolicy () const

bool	HasFixedSlotPolicy () const

bool	HasFixedRegisterPolicy () const

bool	HasFixedDoubleRegisterPolicy () const

bool	HasWritableRegisterPolicy () const

BasicPolicy	basic_policy () const

ExtendedPolicy	extended_policy () const

int	fixed_slot_index () const

int	fixed_register_index () const

int	virtual_register () const

void	set_virtual_register (unsigned id)

bool	IsUsedAtStart ()

Public Member Functions inherited from v8::internal::LOperand
	LOperand ()

Kind	kind () const

int	index () const

bool	Equals (LOperand *other) const

void	PrintTo (StringStream *stream)

void	ConvertTo (Kind kind, int index)

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 LUnallocated *	cast (LOperand *op)

Static Public Member Functions inherited from v8::internal::LOperand
static void	SetUpCaches ()

static void	TearDownCaches ()

Static Public Attributes
static const int	kMaxVirtualRegisters = VirtualRegisterField::kMax + 1

static const int	kFixedSlotIndexWidth = FixedSlotIndexField::kSize

static const int	kMaxFixedSlotIndex = (1 << (kFixedSlotIndexWidth - 1)) - 1

static const int	kMinFixedSlotIndex = -(1 << (kFixedSlotIndexWidth - 1))

Additional Inherited Members
Protected Member Functions inherited from v8::internal::LOperand
	LOperand (Kind kind, int index)

Protected Attributes inherited from v8::internal::LOperand
unsigned	value_

Static Protected Attributes inherited from v8::internal::LOperand
static const int	kKindFieldWidth = 3

Detailed Description

Definition at line 72 of file lithium.h.

Member Enumeration Documentation

◆ BasicPolicy

enum v8::internal::LUnallocated::BasicPolicy

Enumerator
FIXED_SLOT
EXTENDED_POLICY

Definition at line 74 of file lithium.h.

                    {
     FIXED_SLOT,
     EXTENDED_POLICY
   };

◆ ExtendedPolicy

enum v8::internal::LUnallocated::ExtendedPolicy

Enumerator
NONE
ANY
FIXED_REGISTER
FIXED_DOUBLE_REGISTER
MUST_HAVE_REGISTER
MUST_HAVE_DOUBLE_REGISTER
WRITABLE_REGISTER
SAME_AS_FIRST_INPUT

Definition at line 79 of file lithium.h.

                       {
     NONE,
     ANY,
     FIXED_REGISTER,
     FIXED_DOUBLE_REGISTER,
     MUST_HAVE_REGISTER,
     MUST_HAVE_DOUBLE_REGISTER,
     WRITABLE_REGISTER,
     SAME_AS_FIRST_INPUT
   };

◆ Lifetime

enum v8::internal::LUnallocated::Lifetime

Enumerator
USED_AT_START
USED_AT_END

Definition at line 91 of file lithium.h.

                 {
     // USED_AT_START operand is guaranteed to be live only at
     // instruction start. Register allocator is free to assign the same register
     // to some other operand used inside instruction (i.e. temporary or
     // output).
     USED_AT_START,
  
     // USED_AT_END operand is treated as live until the end of
     // instruction. This means that register allocator will not reuse it's
     // register for any other operand inside instruction.
     USED_AT_END
   };

Constructor & Destructor Documentation

◆ LUnallocated() [1/4]

v8::internal::LUnallocated::LUnallocated ( ExtendedPolicy policy )

inlineexplicit

Definition at line 104 of file lithium.h.

                                                : LOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
   }

References v8::internal::BitFieldBase< T, shift, size, U >::encode(), EXTENDED_POLICY, USED_AT_END, and v8::internal::LOperand::value_.

Referenced by CopyUnconstrained().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LUnallocated() [2/4]

v8::internal::LUnallocated::LUnallocated	(	BasicPolicy	policy,
		int	index
	)

inline

Definition at line 110 of file lithium.h.

                                               : LOperand(UNALLOCATED, 0) {
     DCHECK(policy == FIXED_SLOT);
     value_ |= BasicPolicyField::encode(policy);
     value_ |= index << FixedSlotIndexField::kShift;
     DCHECK(this->fixed_slot_index() == index);
   }

References DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::encode(), FIXED_SLOT, fixed_slot_index(), v8::internal::LOperand::index(), v8::internal::BitFieldBase< T, shift, size, U >::kShift, and v8::internal::LOperand::value_.

Here is the call graph for this function:

◆ LUnallocated() [3/4]

v8::internal::LUnallocated::LUnallocated	(	ExtendedPolicy	policy,
		int	index
	)

inline

Definition at line 117 of file lithium.h.

                                                  : LOperand(UNALLOCATED, 0) {
     DCHECK(policy == FIXED_REGISTER || policy == FIXED_DOUBLE_REGISTER);
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
     value_ |= FixedRegisterField::encode(index);
   }

References DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::encode(), EXTENDED_POLICY, FIXED_DOUBLE_REGISTER, FIXED_REGISTER, v8::internal::LOperand::index(), USED_AT_END, and v8::internal::LOperand::value_.

Here is the call graph for this function:

◆ LUnallocated() [4/4]

v8::internal::LUnallocated::LUnallocated	(	ExtendedPolicy	policy,
		Lifetime	lifetime
	)

inline

Definition at line 125 of file lithium.h.

       : LOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(lifetime);
   }

References v8::internal::BitFieldBase< T, shift, size, U >::encode(), EXTENDED_POLICY, and v8::internal::LOperand::value_.

Here is the call graph for this function:

Member Function Documentation

◆ basic_policy()

BasicPolicy v8::internal::LUnallocated::basic_policy ( ) const

inline

Definition at line 220 of file lithium.h.

                                    {
     return BasicPolicyField::decode(value_);
   }

References v8::internal::BitFieldBase< T, shift, size, U >::decode(), and v8::internal::LOperand::value_.

Referenced by extended_policy(), HasAnyPolicy(), HasDoubleRegisterPolicy(), HasFixedDoubleRegisterPolicy(), HasFixedPolicy(), HasFixedRegisterPolicy(), HasFixedSlotPolicy(), HasRegisterPolicy(), HasSameAsInputPolicy(), HasWritableRegisterPolicy(), IsUsedAtStart(), and v8::internal::LOperand::PrintTo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cast()

static LUnallocated* v8::internal::LUnallocated::cast ( LOperand * op )

inlinestatic

Definition at line 138 of file lithium.h.

                                           {
     DCHECK(op->IsUnallocated());
     return reinterpret_cast<LUnallocated*>(op);
   }

References DCHECK.

Referenced by v8::internal::LOperand::PrintTo(), and v8::internal::UsePosition::UsePosition().

Here is the caller graph for this function:

◆ CopyUnconstrained()

LUnallocated* v8::internal::LUnallocated::CopyUnconstrained ( Zone * zone )

inline

Definition at line 132 of file lithium.h.

                                               {
     LUnallocated* result = new(zone) LUnallocated(ANY);
     result->set_virtual_register(virtual_register());
     return result;
   }

References ANY, LUnallocated(), set_virtual_register(), and virtual_register().

Here is the call graph for this function:

◆ extended_policy()

ExtendedPolicy v8::internal::LUnallocated::extended_policy ( ) const

inline

Definition at line 225 of file lithium.h.

                                          {
     DCHECK(basic_policy() == EXTENDED_POLICY);
     return ExtendedPolicyField::decode(value_);
   }

References basic_policy(), DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::decode(), EXTENDED_POLICY, and v8::internal::LOperand::value_.

Referenced by HasAnyPolicy(), HasDoubleRegisterPolicy(), HasFixedDoubleRegisterPolicy(), HasFixedPolicy(), HasFixedRegisterPolicy(), HasRegisterPolicy(), HasSameAsInputPolicy(), HasWritableRegisterPolicy(), and v8::internal::LOperand::PrintTo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fixed_register_index()

int v8::internal::LUnallocated::fixed_register_index ( ) const

inline

Definition at line 237 of file lithium.h.

                                    {
     DCHECK(HasFixedRegisterPolicy() || HasFixedDoubleRegisterPolicy());
     return FixedRegisterField::decode(value_);
   }

References DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::decode(), HasFixedDoubleRegisterPolicy(), HasFixedRegisterPolicy(), and v8::internal::LOperand::value_.

Referenced by v8::internal::LOperand::PrintTo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fixed_slot_index()

int v8::internal::LUnallocated::fixed_slot_index ( ) const

inline

Definition at line 231 of file lithium.h.

                                {
     DCHECK(HasFixedSlotPolicy());
     return static_cast<int>(value_) >> FixedSlotIndexField::kShift;
   }

References DCHECK, HasFixedSlotPolicy(), v8::internal::BitFieldBase< T, shift, size, U >::kShift, and v8::internal::LOperand::value_.

Referenced by LUnallocated(), and v8::internal::LOperand::PrintTo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasAnyPolicy()

bool v8::internal::LUnallocated::HasAnyPolicy ( ) const

inline

Definition at line 181 of file lithium.h.

                             {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == ANY;
   }

References ANY, basic_policy(), EXTENDED_POLICY, and extended_policy().

Referenced by v8::internal::UsePosition::UsePosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasDoubleRegisterPolicy()

bool v8::internal::LUnallocated::HasDoubleRegisterPolicy ( ) const

inline

Definition at line 195 of file lithium.h.

                                        {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == MUST_HAVE_DOUBLE_REGISTER;
   }

References basic_policy(), EXTENDED_POLICY, extended_policy(), and MUST_HAVE_DOUBLE_REGISTER.

Referenced by v8::internal::UsePosition::UsePosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasFixedDoubleRegisterPolicy()

bool v8::internal::LUnallocated::HasFixedDoubleRegisterPolicy ( ) const

inline

Definition at line 210 of file lithium.h.

                                             {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == FIXED_DOUBLE_REGISTER;
   }

References basic_policy(), EXTENDED_POLICY, extended_policy(), and FIXED_DOUBLE_REGISTER.

Referenced by fixed_register_index().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasFixedPolicy()

bool v8::internal::LUnallocated::HasFixedPolicy ( ) const

inline

Definition at line 185 of file lithium.h.

                               {
     return basic_policy() == FIXED_SLOT ||
         extended_policy() == FIXED_REGISTER ||
         extended_policy() == FIXED_DOUBLE_REGISTER;
   }

References basic_policy(), extended_policy(), FIXED_DOUBLE_REGISTER, FIXED_REGISTER, and FIXED_SLOT.

Here is the call graph for this function:

◆ HasFixedRegisterPolicy()

bool v8::internal::LUnallocated::HasFixedRegisterPolicy ( ) const

inline

Definition at line 206 of file lithium.h.

                                       {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == FIXED_REGISTER;
   }

References basic_policy(), EXTENDED_POLICY, extended_policy(), and FIXED_REGISTER.

Referenced by fixed_register_index().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasFixedSlotPolicy()

bool v8::internal::LUnallocated::HasFixedSlotPolicy ( ) const

inline

Definition at line 203 of file lithium.h.

                                   {
     return basic_policy() == FIXED_SLOT;
   }

References basic_policy(), and FIXED_SLOT.

Referenced by fixed_slot_index().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasRegisterPolicy()

bool v8::internal::LUnallocated::HasRegisterPolicy ( ) const

inline

Definition at line 190 of file lithium.h.

                                  {
     return basic_policy() == EXTENDED_POLICY && (
         extended_policy() == WRITABLE_REGISTER ||
         extended_policy() == MUST_HAVE_REGISTER);
   }

References basic_policy(), EXTENDED_POLICY, extended_policy(), MUST_HAVE_REGISTER, and WRITABLE_REGISTER.

Referenced by v8::internal::UsePosition::UsePosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasSameAsInputPolicy()

bool v8::internal::LUnallocated::HasSameAsInputPolicy ( ) const

inline

Definition at line 199 of file lithium.h.

                                     {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == SAME_AS_FIRST_INPUT;
   }

References basic_policy(), EXTENDED_POLICY, extended_policy(), and SAME_AS_FIRST_INPUT.

Here is the call graph for this function:

◆ HasWritableRegisterPolicy()

bool v8::internal::LUnallocated::HasWritableRegisterPolicy ( ) const

inline

Definition at line 214 of file lithium.h.

                                          {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == WRITABLE_REGISTER;
   }

References basic_policy(), EXTENDED_POLICY, extended_policy(), and WRITABLE_REGISTER.

Here is the call graph for this function:

◆ IsUsedAtStart()

bool v8::internal::LUnallocated::IsUsedAtStart ( )

inline

Definition at line 251 of file lithium.h.

                        {
     DCHECK(basic_policy() == EXTENDED_POLICY);
     return LifetimeField::decode(value_) == USED_AT_START;
   }

References basic_policy(), DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::decode(), EXTENDED_POLICY, USED_AT_START, and v8::internal::LOperand::value_.

Here is the call graph for this function:

◆ set_virtual_register()

void v8::internal::LUnallocated::set_virtual_register ( unsigned id )

inline

Definition at line 246 of file lithium.h.

                                          {
     value_ = VirtualRegisterField::update(value_, id);
   }

References v8::internal::BitFieldBase< T, shift, size, U >::update(), and v8::internal::LOperand::value_.

Referenced by CopyUnconstrained(), and v8::internal::LiveRange::CreateAssignedOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ STATIC_ASSERT()

v8::internal::LUnallocated::STATIC_ASSERT ( kKindFieldWidth = =3 )

◆ virtual_register()

int v8::internal::LUnallocated::virtual_register ( ) const

inline

Definition at line 243 of file lithium.h.

                                {
     return VirtualRegisterField::decode(value_);
   }

References v8::internal::BitFieldBase< T, shift, size, U >::decode(), and v8::internal::LOperand::value_.

Referenced by CopyUnconstrained(), and v8::internal::LOperand::PrintTo().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ kFixedSlotIndexWidth

const int v8::internal::LUnallocated::kFixedSlotIndexWidth = FixedSlotIndexField::kSize

static

Definition at line 176 of file lithium.h.

◆ kMaxFixedSlotIndex

const int v8::internal::LUnallocated::kMaxFixedSlotIndex = (1 << (kFixedSlotIndexWidth - 1)) - 1

static

Definition at line 177 of file lithium.h.

Referenced by v8::internal::OptimizedCompileJob::CreateGraph().

◆ kMaxVirtualRegisters

const int v8::internal::LUnallocated::kMaxVirtualRegisters = VirtualRegisterField::kMax + 1

static

Definition at line 175 of file lithium.h.

Referenced by v8::internal::BASE_EMBEDDED< Visitor >::GetVirtualRegister(), and v8::internal::LChunk::NewChunk().

◆ kMinFixedSlotIndex

const int v8::internal::LUnallocated::kMinFixedSlotIndex = -(1 << (kFixedSlotIndexWidth - 1))

static

Definition at line 178 of file lithium.h.

Referenced by v8::internal::OptimizedCompileJob::CreateGraph().

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

/mnt/V8SourceCode/src/lithium.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ BasicPolicy

◆ ExtendedPolicy

◆ Lifetime

Constructor & Destructor Documentation

◆ LUnallocated() [1/4]

◆ LUnallocated() [2/4]

◆ LUnallocated() [3/4]

◆ LUnallocated() [4/4]

Member Function Documentation

◆ basic_policy()

◆ cast()

◆ CopyUnconstrained()

◆ extended_policy()

◆ fixed_register_index()

◆ fixed_slot_index()

◆ HasAnyPolicy()

◆ HasDoubleRegisterPolicy()

◆ HasFixedDoubleRegisterPolicy()

◆ HasFixedPolicy()

◆ HasFixedRegisterPolicy()

◆ HasFixedSlotPolicy()

◆ HasRegisterPolicy()

◆ HasSameAsInputPolicy()

◆ HasWritableRegisterPolicy()

◆ IsUsedAtStart()

◆ set_virtual_register()

◆ STATIC_ASSERT()

◆ virtual_register()

Member Data Documentation

◆ kFixedSlotIndexWidth

◆ kMaxFixedSlotIndex

◆ kMaxVirtualRegisters

◆ kMinFixedSlotIndex