#include <lithium-codegen-arm.h>

Inheritance diagram for v8::internal::LCodeGen:

Collaboration diagram for v8::internal::LCodeGen:

Classes
class	BASE_EMBEDDED

class	X87Stack

Public Types
enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

enum	StackMode { kMustUseFramePointer , kCanUseStackPointer }

enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

enum	X87OperandType { kX87DoubleOperand , kX87FloatOperand , kX87IntOperand }

enum	IntegerSignedness { SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 , SIGNED_INT32 , UNSIGNED_INT32 }

Public Member Functions
	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

LinkRegisterStatus	GetLinkRegisterState () const

Register	ToRegister (LOperand *op) const

Register	EmitLoadRegister (LOperand *op, Register scratch)

DwVfpRegister	ToDoubleRegister (LOperand *op) const

DwVfpRegister	EmitLoadDoubleRegister (LOperand *op, SwVfpRegister flt_scratch, DwVfpRegister dbl_scratch)

int32_t	ToRepresentation (LConstantOperand *op, const Representation &r) const

int32_t	ToInteger32 (LConstantOperand *op) const

Smi *	ToSmi (LConstantOperand *op) const

double	ToDouble (LConstantOperand *op) const

Operand	ToOperand (LOperand *op)

MemOperand	ToMemOperand (LOperand *op) const

MemOperand	ToHighMemOperand (LOperand *op) const

bool	IsInteger32 (LConstantOperand *op) const

bool	IsSmi (LConstantOperand *op) const

Handle< Object >	ToHandle (LConstantOperand *op) const

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredNumberTagIU (LInstruction instr, LOperand value, LOperand temp1, LOperand temp2, IntegerSignedness signedness)

void	DoDeferredTaggedToI (LTaggedToI *instr)

void	DoDeferredMathAbsTaggedHeapNumber (LMathAbs *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal instr, Label map_check, Label *bool_load)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register result, Register object, Register index)

void	DoParallelMove (LParallelMove *move)

void	DoGap (LGap *instr)

MemOperand	PrepareKeyedOperand (Register key, Register base, bool key_is_constant, int constant_key, int element_size, int shift_size, int base_offset)

void	WriteTranslation (LEnvironment environment, Translation translation)

	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

	~LCodeGen ()

Scope *	scope () const

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

LinkRegisterStatus	GetLinkRegisterState () const

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

Register	ToRegister (LOperand *op) const

Register	ToRegister32 (LOperand *op) const

Operand	ToOperand (LOperand *op)

Operand	ToOperand32 (LOperand *op)

MemOperand	ToMemOperand (LOperand *op, StackMode stack_mode=kCanUseStackPointer) const

Handle< Object >	ToHandle (LConstantOperand *op) const

template<class LI >
Operand	ToShiftedRightOperand32 (LOperand right, LI shift_info)

int	JSShiftAmountFromLConstant (LOperand *constant)

bool	IsInteger32Constant (LConstantOperand *op) const

bool	IsSmi (LConstantOperand *op) const

int32_t	ToInteger32 (LConstantOperand *op) const

Smi *	ToSmi (LConstantOperand *op) const

double	ToDouble (LConstantOperand *op) const

DoubleRegister	ToDoubleRegister (LOperand *op) const

	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

Operand	ToOperand (LOperand *op) const

Register	ToRegister (LOperand *op) const

XMMRegister	ToDoubleRegister (LOperand *op) const

bool	IsInteger32 (LConstantOperand *op) const

bool	IsSmi (LConstantOperand *op) const

Immediate	ToImmediate (LOperand *op, const Representation &r) const

double	ToDouble (LConstantOperand *op) const

Handle< Object >	ToHandle (LConstantOperand *op) const

Operand	HighOperand (LOperand *op)

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredNumberTagIU (LInstruction instr, LOperand value, LOperand *temp, IntegerSignedness signedness)

void	DoDeferredTaggedToI (LTaggedToI instr, Label done)

void	DoDeferredMathAbsTaggedHeapNumber (LMathAbs *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal instr, Label map_check)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register object, Register index)

void	DoParallelMove (LParallelMove *move)

void	DoGap (LGap *instr)

void	WriteTranslation (LEnvironment environment, Translation translation)

void	EnsureRelocSpaceForDeoptimization ()

	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

RAStatus	GetRAState () const

Register	ToRegister (LOperand *op) const

Register	EmitLoadRegister (LOperand *op, Register scratch)

DoubleRegister	ToDoubleRegister (LOperand *op) const

DoubleRegister	EmitLoadDoubleRegister (LOperand *op, FloatRegister flt_scratch, DoubleRegister dbl_scratch)

int32_t	ToRepresentation (LConstantOperand *op, const Representation &r) const

int32_t	ToInteger32 (LConstantOperand *op) const

Smi *	ToSmi (LConstantOperand *op) const

double	ToDouble (LConstantOperand *op) const

Operand	ToOperand (LOperand *op)

MemOperand	ToMemOperand (LOperand *op) const

MemOperand	ToHighMemOperand (LOperand *op) const

bool	IsInteger32 (LConstantOperand *op) const

bool	IsSmi (LConstantOperand *op) const

Handle< Object >	ToHandle (LConstantOperand *op) const

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredNumberTagIU (LInstruction instr, LOperand value, LOperand temp1, LOperand temp2, IntegerSignedness signedness)

void	DoDeferredTaggedToI (LTaggedToI *instr)

void	DoDeferredMathAbsTaggedHeapNumber (LMathAbs *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal instr, Label map_check)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register result, Register object, Register index)

void	DoParallelMove (LParallelMove *move)

void	DoGap (LGap *instr)

MemOperand	PrepareKeyedOperand (Register key, Register base, bool key_is_constant, int constant_key, int element_size, int shift_size, int base_offset)

void	WriteTranslation (LEnvironment environment, Translation translation)

	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

RAStatus	GetRAState () const

Register	ToRegister (LOperand *op) const

Register	EmitLoadRegister (LOperand *op, Register scratch)

DoubleRegister	ToDoubleRegister (LOperand *op) const

DoubleRegister	EmitLoadDoubleRegister (LOperand *op, FloatRegister flt_scratch, DoubleRegister dbl_scratch)

int32_t	ToRepresentation_donotuse (LConstantOperand *op, const Representation &r) const

int32_t	ToInteger32 (LConstantOperand *op) const

Smi *	ToSmi (LConstantOperand *op) const

double	ToDouble (LConstantOperand *op) const

Operand	ToOperand (LOperand *op)

MemOperand	ToMemOperand (LOperand *op) const

MemOperand	ToHighMemOperand (LOperand *op) const

bool	IsInteger32 (LConstantOperand *op) const

bool	IsSmi (LConstantOperand *op) const

Handle< Object >	ToHandle (LConstantOperand *op) const

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredNumberTagIU (LInstruction instr, LOperand value, LOperand temp1, LOperand temp2, IntegerSignedness signedness)

void	DoDeferredTaggedToI (LTaggedToI *instr)

void	DoDeferredMathAbsTaggedHeapNumber (LMathAbs *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal instr, Label map_check)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register result, Register object, Register index)

void	DoParallelMove (LParallelMove *move)

void	DoGap (LGap *instr)

MemOperand	PrepareKeyedOperand (Register key, Register base, bool key_is_constant, int constant_key, int element_size, int shift_size, int base_offset)

void	WriteTranslation (LEnvironment environment, Translation translation)

	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

Register	ToRegister (LOperand *op) const

XMMRegister	ToDoubleRegister (LOperand *op) const

bool	IsInteger32Constant (LConstantOperand *op) const

bool	IsDehoistedKeyConstant (LConstantOperand *op) const

bool	IsSmiConstant (LConstantOperand *op) const

int32_t	ToRepresentation (LConstantOperand *op, const Representation &r) const

int32_t	ToInteger32 (LConstantOperand *op) const

Smi *	ToSmi (LConstantOperand *op) const

double	ToDouble (LConstantOperand *op) const

ExternalReference	ToExternalReference (LConstantOperand *op) const

Handle< Object >	ToHandle (LConstantOperand *op) const

Operand	ToOperand (LOperand *op) const

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredNumberTagIU (LInstruction instr, LOperand value, LOperand temp1, LOperand temp2, IntegerSignedness signedness)

void	DoDeferredTaggedToI (LTaggedToI instr, Label done)

void	DoDeferredMathAbsTaggedHeapNumber (LMathAbs *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal instr, Label map_check)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register object, Register index)

void	DoParallelMove (LParallelMove *move)

void	DoGap (LGap *instr)

void	WriteTranslation (LEnvironment environment, Translation translation)

	LCodeGen (LChunk chunk, MacroAssembler assembler, CompilationInfo *info)

int	LookupDestination (int block_id) const

bool	IsNextEmittedBlock (int block_id) const

bool	NeedsEagerFrame () const

bool	NeedsDeferredFrame () const

Operand	ToOperand (LOperand *op) const

Register	ToRegister (LOperand *op) const

X87Register	ToX87Register (LOperand *op) const

bool	IsInteger32 (LConstantOperand *op) const

bool	IsSmi (LConstantOperand *op) const

Immediate	ToImmediate (LOperand *op, const Representation &r) const

double	ToDouble (LConstantOperand *op) const

void	X87Mov (X87Register reg, Operand src, X87OperandType operand=kX87DoubleOperand)

void	X87Mov (Operand src, X87Register reg, X87OperandType operand=kX87DoubleOperand)

void	X87Mov (X87Register reg, X87Register src, X87OperandType operand=kX87DoubleOperand)

void	X87PrepareBinaryOp (X87Register left, X87Register right, X87Register result)

void	X87LoadForUsage (X87Register reg)

void	X87LoadForUsage (X87Register reg1, X87Register reg2)

void	X87PrepareToWrite (X87Register reg)

void	X87CommitWrite (X87Register reg)

void	X87Fxch (X87Register reg, int other_slot=0)

void	X87Free (X87Register reg)

bool	X87StackEmpty ()

Handle< Object >	ToHandle (LConstantOperand *op) const

Operand	HighOperand (LOperand *op)

bool	GenerateCode ()

void	FinishCode (Handle< Code > code)

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredNumberTagIU (LInstruction instr, LOperand value, LOperand *temp, IntegerSignedness signedness)

void	DoDeferredTaggedToI (LTaggedToI instr, Label done)

void	DoDeferredMathAbsTaggedHeapNumber (LMathAbs *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal instr, Label map_check)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register object, Register index)

void	DoParallelMove (LParallelMove *move)

void	DoGap (LGap *instr)

void	WriteTranslation (LEnvironment environment, Translation translation)

void	EnsureRelocSpaceForDeoptimization ()

Private Types
enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	R1State { R1_UNINITIALIZED , R1_CONTAINS_TARGET }

enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	EDIState { EDI_UNINITIALIZED , EDI_CONTAINS_TARGET , EDI_UNINITIALIZED , EDI_CONTAINS_TARGET }

enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	A1State { A1_UNINITIALIZED , A1_CONTAINS_TARGET , A1_UNINITIALIZED , A1_CONTAINS_TARGET }

enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	A1State { A1_UNINITIALIZED , A1_CONTAINS_TARGET , A1_UNINITIALIZED , A1_CONTAINS_TARGET }

enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	RDIState { RDI_UNINITIALIZED , RDI_CONTAINS_TARGET }

enum	SafepointMode { RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS , RECORD_SIMPLE_SAFEPOINT , RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS }

enum	EDIState { EDI_UNINITIALIZED , EDI_CONTAINS_TARGET , EDI_UNINITIALIZED , EDI_CONTAINS_TARGET }

typedef std::map< int, X87Stack * >	X87StackMap

Private Member Functions
StrictMode	strict_mode () const

Scope *	scope () const

Register	scratch0 ()

LowDwVfpRegister	double_scratch0 ()

LInstruction *	GetNextInstruction ()

void	EmitClassOfTest (Label if_true, Label if_false, Handle< String > class_name, Register input, Register temporary, Register temporary2)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	SaveCallerDoubles ()

void	RestoreCallerDoubles ()

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

int	CallCodeSize (Handle< Code > code, RelocInfo::Mode mode)

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, TargetAddressStorageMode storage_mode=CAN_INLINE_TARGET_ADDRESS)

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode, TargetAddressStorageMode storage_mode=CAN_INLINE_TARGET_ADDRESS)

void	CallRuntime (const Runtime::Function function, int num_arguments, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int num_arguments, LInstruction *instr)

void	LoadContextFromDeferred (LOperand *context)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, R1State r1_state)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

void	DeoptimizeIf (Condition condition, LInstruction instr, const char detail, Deoptimizer::BailoutType bailout_type)

void	DeoptimizeIf (Condition condition, LInstruction instr, const char detail)

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	PopulateDeoptimizationData (Handle< Code > code)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

Register	ToRegister (int index) const

DwVfpRegister	ToDoubleRegister (int index) const

MemOperand	BuildSeqStringOperand (Register string, LOperand *index, String::Encoding encoding)

void	EmitIntegerMathAbs (LMathAbs *instr)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordAndWritePosition (int position) OVERRIDE

void	EmitGoto (int block)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition condition)

template<class InstrType >
void	EmitFalseBranch (InstrType instr, Condition condition)

void	EmitNumberUntagD (LNumberUntagD *instr, Register input, DwVfpRegister result, NumberUntagDMode mode)

Condition	EmitTypeofIs (Label true_label, Label false_label, Register input, Handle< String > type_name)

Condition	EmitIsObject (Register input, Register temp1, Label is_not_object, Label is_object)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

void	EmitIsConstructCall (Register temp1, Register temp2)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, int *offset, AllocationSiteMode mode)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

void	DoLoadKeyedExternalArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedDoubleArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedArray (LLoadKeyed *instr)

void	DoStoreKeyedExternalArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedDoubleArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedArray (LStoreKeyed *instr)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

DoubleRegister	double_scratch ()

void	DoDeferredNumberTagD (LNumberTagD *instr)

void	DoDeferredStackCheck (LStackCheck *instr)

void	DoDeferredStringCharCodeAt (LStringCharCodeAt *instr)

void	DoDeferredStringCharFromCode (LStringCharFromCode *instr)

void	DoDeferredMathAbsTagged (LMathAbsTagged instr, Label exit, Label *allocation_entry)

void	DoDeferredNumberTagU (LInstruction instr, LOperand value, LOperand temp1, LOperand temp2)

void	DoDeferredTaggedToI (LTaggedToI instr, LOperand value, LOperand temp1, LOperand temp2)

void	DoDeferredAllocate (LAllocate *instr)

void	DoDeferredInstanceOfKnownGlobal (LInstanceOfKnownGlobal *instr)

void	DoDeferredInstanceMigration (LCheckMaps *instr, Register object)

void	DoDeferredLoadMutableDouble (LLoadFieldByIndex *instr, Register result, Register object, Register index)

void	EmitGoto (int block)

void	DoGap (LGap *instr)

template<class InstrType >
void	EmitBranchGeneric (InstrType instr, const BranchGenerator &branch)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition condition)

template<class InstrType >
void	EmitCompareAndBranch (InstrType instr, Condition condition, const Register &lhs, const Operand &rhs)

template<class InstrType >
void	EmitTestAndBranch (InstrType instr, Condition condition, const Register &value, uint64_t mask)

template<class InstrType >
void	EmitBranchIfNonZeroNumber (InstrType instr, const FPRegister &value, const FPRegister &scratch)

template<class InstrType >
void	EmitBranchIfHeapNumber (InstrType instr, const Register &value)

template<class InstrType >
void	EmitBranchIfRoot (InstrType instr, const Register &value, Heap::RootListIndex index)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, Register scratch, int *offset, AllocationSiteMode mode)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationData (Handle< Code > code)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

MemOperand	BuildSeqStringOperand (Register string, Register temp, LOperand *index, String::Encoding encoding)

void	DeoptimizeBranch (LInstruction instr, const char detail, BranchType branch_type, Register reg=NoReg, int bit=-1, Deoptimizer::BailoutType *override_bailout_type=NULL)

void	Deoptimize (LInstruction instr, const char detail, Deoptimizer::BailoutType *override_bailout_type=NULL)

void	DeoptimizeIf (Condition cond, LInstruction instr, const char detail)

void	DeoptimizeIfZero (Register rt, LInstruction instr, const char detail)

void	DeoptimizeIfNotZero (Register rt, LInstruction instr, const char detail)

void	DeoptimizeIfNegative (Register rt, LInstruction instr, const char detail)

void	DeoptimizeIfSmi (Register rt, LInstruction instr, const char detail)

void	DeoptimizeIfNotSmi (Register rt, LInstruction instr, const char detail)

void	DeoptimizeIfRoot (Register rt, Heap::RootListIndex index, LInstruction instr, const char detail)

void	DeoptimizeIfNotRoot (Register rt, Heap::RootListIndex index, LInstruction instr, const char detail)

void	DeoptimizeIfNotHeapNumber (Register object, LInstruction *instr)

void	DeoptimizeIfMinusZero (DoubleRegister input, LInstruction instr, const char detail)

void	DeoptimizeIfBitSet (Register rt, int bit, LInstruction instr, const char detail)

void	DeoptimizeIfBitClear (Register rt, int bit, LInstruction instr, const char detail)

MemOperand	PrepareKeyedExternalArrayOperand (Register key, Register base, Register scratch, bool key_is_smi, bool key_is_constant, int constant_key, ElementsKind elements_kind, int base_offset)

MemOperand	PrepareKeyedArrayOperand (Register base, Register elements, Register key, bool key_is_tagged, ElementsKind elements_kind, Representation representation, int base_offset)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	WriteTranslation (LEnvironment environment, Translation translation)

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	SaveCallerDoubles ()

void	RestoreCallerDoubles ()

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr)

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode)

void	CallRuntime (const Runtime::Function function, int num_arguments, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int num_arguments, LInstruction *instr)

void	LoadContextFromDeferred (LOperand *context)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, Register function_reg=NoReg)

void	RecordAndWritePosition (int position) OVERRIDE

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

StrictMode	strict_mode () const

Scope *	scope () const

XMMRegister	double_scratch0 () const

void	EmitClassOfTest (Label if_true, Label if_false, Handle< String > class_name, Register input, Register temporary, Register temporary2)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	SaveCallerDoubles ()

void	RestoreCallerDoubles ()

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

void	GenerateBodyInstructionPost (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr)

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode)

void	CallRuntime (const Runtime::Function fun, int argc, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int argc, LInstruction *instr)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	LoadContextFromDeferred (LOperand *context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, EDIState edi_state)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

void	DeoptimizeIf (Condition cc, LInstruction instr, const char detail, Deoptimizer::BailoutType bailout_type)

void	DeoptimizeIf (Condition cc, LInstruction instr, const char detail)

bool	DeoptEveryNTimes ()

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	PopulateDeoptimizationData (Handle< Code > code)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

Register	ToRegister (int index) const

XMMRegister	ToDoubleRegister (int index) const

int32_t	ToRepresentation (LConstantOperand *op, const Representation &r) const

int32_t	ToInteger32 (LConstantOperand *op) const

ExternalReference	ToExternalReference (LConstantOperand *op) const

Operand	BuildFastArrayOperand (LOperand elements_pointer, LOperand key, Representation key_representation, ElementsKind elements_kind, uint32_t base_offset)

Operand	BuildSeqStringOperand (Register string, LOperand *index, String::Encoding encoding)

void	EmitIntegerMathAbs (LMathAbs *instr)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordAndWritePosition (int position) OVERRIDE

void	EmitGoto (int block)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition cc)

template<class InstrType >
void	EmitFalseBranch (InstrType instr, Condition cc)

void	EmitNumberUntagD (LNumberUntagD *instr, Register input, Register temp, XMMRegister result, NumberUntagDMode mode)

Condition	EmitTypeofIs (LTypeofIsAndBranch *instr, Register input)

Condition	EmitIsObject (Register input, Register temp1, Label is_not_object, Label is_object)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

void	EmitIsConstructCall (Register temp)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, int *offset, AllocationSiteMode mode)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

void	DoLoadKeyedExternalArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedDoubleArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedArray (LLoadKeyed *instr)

void	DoStoreKeyedExternalArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedDoubleArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedArray (LStoreKeyed *instr)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

void	EmitReturn (LReturn *instr, bool dynamic_frame_alignment)

void	EmitPushTaggedOperand (LOperand *operand)

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

StrictMode	strict_mode () const

Scope *	scope () const

Register	scratch0 ()

Register	scratch1 ()

DoubleRegister	double_scratch0 ()

LInstruction *	GetNextInstruction ()

void	EmitClassOfTest (Label if_true, Label if_false, Handle< String > class_name, Register input, Register temporary, Register temporary2)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	SaveCallerDoubles ()

void	RestoreCallerDoubles ()

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr)

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode)

void	CallRuntime (const Runtime::Function function, int num_arguments, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int num_arguments, LInstruction *instr)

void	LoadContextFromDeferred (LOperand *context)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, A1State a1_state)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

void	DeoptimizeIf (Condition condition, LInstruction instr, Deoptimizer::BailoutType bailout_type, const char detail, Register src1=zero_reg, const Operand &src2=Operand(zero_reg))

void	DeoptimizeIf (Condition condition, LInstruction instr, const char detail=NULL, Register src1=zero_reg, const Operand &src2=Operand(zero_reg))

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	PopulateDeoptimizationData (Handle< Code > code)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

Register	ToRegister (int index) const

DoubleRegister	ToDoubleRegister (int index) const

MemOperand	BuildSeqStringOperand (Register string, LOperand *index, String::Encoding encoding)

void	EmitIntegerMathAbs (LMathAbs *instr)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordAndWritePosition (int position) OVERRIDE

void	EmitGoto (int block)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition condition, Register src1, const Operand &src2)

template<class InstrType >
void	EmitBranchF (InstrType instr, Condition condition, FPURegister src1, FPURegister src2)

template<class InstrType >
void	EmitFalseBranch (InstrType instr, Condition condition, Register src1, const Operand &src2)

template<class InstrType >
void	EmitFalseBranchF (InstrType instr, Condition condition, FPURegister src1, FPURegister src2)

void	EmitCmpI (LOperand left, LOperand right)

void	EmitNumberUntagD (LNumberUntagD *instr, Register input, DoubleRegister result, NumberUntagDMode mode)

Condition	EmitTypeofIs (Label true_label, Label false_label, Register input, Handle< String > type_name, Register cmp1, Operand cmp2)

Condition	EmitIsObject (Register input, Register temp1, Register temp2, Label is_not_object, Label is_object)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

void	EmitIsConstructCall (Register temp1, Register temp2)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, int *offset, AllocationSiteMode mode)

void	EmitSignedIntegerDivisionByConstant (Register result, Register dividend, int32_t divisor, Register remainder, Register scratch, LEnvironment *environment)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

void	DoLoadKeyedExternalArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedDoubleArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedArray (LLoadKeyed *instr)

void	DoStoreKeyedExternalArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedDoubleArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedArray (LStoreKeyed *instr)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

StrictMode	strict_mode () const

Scope *	scope () const

Register	scratch0 ()

Register	scratch1 ()

DoubleRegister	double_scratch0 ()

LInstruction *	GetNextInstruction ()

void	EmitClassOfTest (Label if_true, Label if_false, Handle< String > class_name, Register input, Register temporary, Register temporary2)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	SaveCallerDoubles ()

void	RestoreCallerDoubles ()

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr)

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode)

void	CallRuntime (const Runtime::Function function, int num_arguments, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int num_arguments, LInstruction *instr)

void	LoadContextFromDeferred (LOperand *context)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, A1State a1_state)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

void	DeoptimizeIf (Condition condition, LInstruction instr, Deoptimizer::BailoutType bailout_type, const char detail, Register src1=zero_reg, const Operand &src2=Operand(zero_reg))

void	DeoptimizeIf (Condition condition, LInstruction instr, const char detail, Register src1=zero_reg, const Operand &src2=Operand(zero_reg))

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	PopulateDeoptimizationData (Handle< Code > code)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

Register	ToRegister (int index) const

DoubleRegister	ToDoubleRegister (int index) const

MemOperand	BuildSeqStringOperand (Register string, LOperand *index, String::Encoding encoding)

void	EmitIntegerMathAbs (LMathAbs *instr)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordAndWritePosition (int position) OVERRIDE

void	EmitGoto (int block)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition condition, Register src1, const Operand &src2)

template<class InstrType >
void	EmitBranchF (InstrType instr, Condition condition, FPURegister src1, FPURegister src2)

template<class InstrType >
void	EmitFalseBranch (InstrType instr, Condition condition, Register src1, const Operand &src2)

template<class InstrType >
void	EmitFalseBranchF (InstrType instr, Condition condition, FPURegister src1, FPURegister src2)

void	EmitCmpI (LOperand left, LOperand right)

void	EmitNumberUntagD (LNumberUntagD *instr, Register input, DoubleRegister result, NumberUntagDMode mode)

Condition	EmitTypeofIs (Label true_label, Label false_label, Register input, Handle< String > type_name, Register cmp1, Operand cmp2)

Condition	EmitIsObject (Register input, Register temp1, Register temp2, Label is_not_object, Label is_object)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

void	EmitIsConstructCall (Register temp1, Register temp2)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, int *offset, AllocationSiteMode mode)

void	EmitSignedIntegerDivisionByConstant (Register result, Register dividend, int32_t divisor, Register remainder, Register scratch, LEnvironment *environment)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

void	DoLoadKeyedExternalArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedDoubleArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedArray (LLoadKeyed *instr)

void	DoStoreKeyedExternalArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedDoubleArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedArray (LStoreKeyed *instr)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

StrictMode	strict_mode () const

LPlatformChunk *	chunk () const

Scope *	scope () const

HGraph *	graph () const

XMMRegister	double_scratch0 () const

void	EmitClassOfTest (Label if_true, Label if_false, Handle< String > class_name, Register input, Register temporary, Register scratch)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	SaveCallerDoubles ()

void	RestoreCallerDoubles ()

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

void	GenerateBodyInstructionPost (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode, int argc)

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr)

void	CallRuntime (const Runtime::Function function, int num_arguments, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int num_arguments, LInstruction *instr)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	LoadContextFromDeferred (LOperand *context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, RDIState rdi_state)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode, int argc)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

void	DeoptimizeIf (Condition cc, LInstruction instr, const char detail, Deoptimizer::BailoutType bailout_type)

void	DeoptimizeIf (Condition cc, LInstruction instr, const char detail)

bool	DeoptEveryNTimes ()

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	PopulateDeoptimizationData (Handle< Code > code)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

Register	ToRegister (int index) const

XMMRegister	ToDoubleRegister (int index) const

Operand	BuildFastArrayOperand (LOperand elements_pointer, LOperand key, Representation key_representation, ElementsKind elements_kind, uint32_t base_offset)

Operand	BuildSeqStringOperand (Register string, LOperand *index, String::Encoding encoding)

void	EmitIntegerMathAbs (LMathAbs *instr)

void	EmitSmiMathAbs (LMathAbs *instr)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordAndWritePosition (int position) OVERRIDE

void	EmitGoto (int block)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition cc)

template<class InstrType >
void	EmitFalseBranch (InstrType instr, Condition cc)

void	EmitNumberUntagD (LNumberUntagD *instr, Register input, XMMRegister result, NumberUntagDMode mode)

Condition	EmitTypeofIs (LTypeofIsAndBranch *instr, Register input)

Condition	EmitIsObject (Register input, Label is_not_object, Label is_object)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

void	EmitIsConstructCall (Register temp)

void	EmitPushTaggedOperand (LOperand *operand)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, int *offset, AllocationSiteMode mode)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

void	DoLoadKeyedExternalArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedDoubleArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedArray (LLoadKeyed *instr)

void	DoStoreKeyedExternalArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedDoubleArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedArray (LStoreKeyed *instr)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

StrictMode	strict_mode () const

Scope *	scope () const

void	EmitClassOfTest (Label if_true, Label if_false, Handle< String > class_name, Register input, Register temporary, Register temporary2)

int	GetStackSlotCount () const

void	AddDeferredCode (LDeferredCode *code)

void	GenerateBodyInstructionPre (LInstruction *instr) OVERRIDE

void	GenerateBodyInstructionPost (LInstruction *instr) OVERRIDE

bool	GeneratePrologue ()

bool	GenerateDeferredCode ()

bool	GenerateJumpTable ()

bool	GenerateSafepointTable ()

void	GenerateOsrPrologue ()

void	CallCode (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr)

void	CallCodeGeneric (Handle< Code > code, RelocInfo::Mode mode, LInstruction *instr, SafepointMode safepoint_mode)

void	CallRuntime (const Runtime::Function fun, int argc, LInstruction instr, SaveFPRegsMode save_doubles=kDontSaveFPRegs)

void	CallRuntime (Runtime::FunctionId id, int argc, LInstruction *instr)

void	CallRuntimeFromDeferred (Runtime::FunctionId id, int argc, LInstruction instr, LOperand context)

void	LoadContextFromDeferred (LOperand *context)

void	CallKnownFunction (Handle< JSFunction > function, int formal_parameter_count, int arity, LInstruction *instr, EDIState edi_state)

void	RecordSafepointWithLazyDeopt (LInstruction *instr, SafepointMode safepoint_mode)

void	RegisterEnvironmentForDeoptimization (LEnvironment *environment, Safepoint::DeoptMode mode)

void	DeoptimizeIf (Condition cc, LInstruction instr, const char detail, Deoptimizer::BailoutType bailout_type)

void	DeoptimizeIf (Condition cc, LInstruction instr, const char detail)

bool	DeoptEveryNTimes ()

void	AddToTranslation (LEnvironment environment, Translation translation, LOperand op, bool is_tagged, bool is_uint32, int object_index_pointer, int *dematerialized_index_pointer)

void	PopulateDeoptimizationData (Handle< Code > code)

int	DefineDeoptimizationLiteral (Handle< Object > literal)

void	PopulateDeoptimizationLiteralsWithInlinedFunctions ()

Register	ToRegister (int index) const

X87Register	ToX87Register (int index) const

int32_t	ToRepresentation (LConstantOperand *op, const Representation &r) const

int32_t	ToInteger32 (LConstantOperand *op) const

ExternalReference	ToExternalReference (LConstantOperand *op) const

Operand	BuildFastArrayOperand (LOperand elements_pointer, LOperand key, Representation key_representation, ElementsKind elements_kind, uint32_t base_offset)

Operand	BuildSeqStringOperand (Register string, LOperand *index, String::Encoding encoding)

void	EmitIntegerMathAbs (LMathAbs *instr)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::Kind kind, int arguments, Safepoint::DeoptMode mode)

void	RecordSafepoint (LPointerMap *pointers, Safepoint::DeoptMode mode)

void	RecordSafepoint (Safepoint::DeoptMode mode)

void	RecordSafepointWithRegisters (LPointerMap *pointers, int arguments, Safepoint::DeoptMode mode)

void	RecordAndWritePosition (int position) OVERRIDE

void	EmitGoto (int block)

template<class InstrType >
void	EmitBranch (InstrType instr, Condition cc)

template<class InstrType >
void	EmitFalseBranch (InstrType instr, Condition cc)

void	EmitNumberUntagDNoSSE2 (LNumberUntagD *instr, Register input, Register temp, X87Register res_reg, NumberUntagDMode mode)

Condition	EmitTypeofIs (LTypeofIsAndBranch *instr, Register input)

Condition	EmitIsObject (Register input, Register temp1, Label is_not_object, Label is_object)

Condition	EmitIsString (Register input, Register temp1, Label *is_not_string, SmiCheck check_needed)

void	EmitIsConstructCall (Register temp)

void	EmitDeepCopy (Handle< JSObject > object, Register result, Register source, int *offset, AllocationSiteMode mode)

void	EnsureSpaceForLazyDeopt (int space_needed) OVERRIDE

void	DoLoadKeyedExternalArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedDoubleArray (LLoadKeyed *instr)

void	DoLoadKeyedFixedArray (LLoadKeyed *instr)

void	DoStoreKeyedExternalArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedDoubleArray (LStoreKeyed *instr)

void	DoStoreKeyedFixedArray (LStoreKeyed *instr)

template<class T >
void	EmitVectorLoadICRegisters (T *instr)

void	EmitReturn (LReturn *instr, bool dynamic_frame_alignment)

void	EmitPushTaggedOperand (LOperand *operand)

void	X87Fld (Operand src, X87OperandType opts)

void	EmitFlushX87ForDeopt ()

void	FlushX87StackIfNecessary (LInstruction *instr)

	DISALLOW_COPY_AND_ASSIGN (LCodeGen)

Static Private Member Functions
static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

static Condition	TokenToCondition (Token::Value op, bool is_unsigned)

Private Attributes
ZoneList< LEnvironment * >	deoptimizations_

ZoneList< Deoptimizer::JumpTableEntry >	jump_table_

ZoneList< Handle< Object > >	deoptimization_literals_

int	inlined_function_count_

Scope *const	scope_

TranslationBuffer	translations_

ZoneList< LDeferredCode * >	deferred_

int	osr_pc_offset_

bool	frame_is_built_

SafepointTableBuilder	safepoints_

LGapResolver	resolver_

Safepoint::Kind	expected_safepoint_kind_

ZoneList< Deoptimizer::JumpTableEntry * >	jump_table_

bool	after_push_argument_

bool	inlined_arguments_

int	old_position_

bool	dynamic_frame_alignment_

bool	support_aligned_spilled_doubles_

X87Stack	x87_stack_

X87StackMap	x87_stack_map_

Friends
class	LDeferredCode

class	LEnvironment

class	SafepointGenerator

class	LGapResolver

class	X87Stack

Detailed Description

Definition at line 24 of file lithium-codegen-arm.h.

Member Typedef Documentation

◆ X87StackMap

typedef std::map<int, X87Stack*> v8::internal::LCodeGen::X87StackMap

private

Definition at line 439 of file lithium-codegen-x87.h.

Member Enumeration Documentation

◆ A1State [1/2]

enum v8::internal::LCodeGen::A1State

private

Enumerator
A1_UNINITIALIZED
A1_CONTAINS_TARGET
A1_UNINITIALIZED
A1_CONTAINS_TARGET

Definition at line 213 of file lithium-codegen-mips.h.

                {
     A1_UNINITIALIZED,
     A1_CONTAINS_TARGET
   };

◆ A1State [2/2]

enum v8::internal::LCodeGen::A1State

private

Enumerator
A1_UNINITIALIZED
A1_CONTAINS_TARGET
A1_UNINITIALIZED
A1_CONTAINS_TARGET

Definition at line 214 of file lithium-codegen-mips64.h.

                {
     A1_UNINITIALIZED,
     A1_CONTAINS_TARGET
   };

◆ EDIState [1/2]

enum v8::internal::LCodeGen::EDIState

private

Enumerator
EDI_UNINITIALIZED
EDI_CONTAINS_TARGET
EDI_UNINITIALIZED
EDI_CONTAINS_TARGET

Definition at line 194 of file lithium-codegen-ia32.h.

                 {
     EDI_UNINITIALIZED,
     EDI_CONTAINS_TARGET
   };

◆ EDIState [2/2]

enum v8::internal::LCodeGen::EDIState

private

Enumerator
EDI_UNINITIALIZED
EDI_CONTAINS_TARGET
EDI_UNINITIALIZED
EDI_CONTAINS_TARGET

Definition at line 221 of file lithium-codegen-x87.h.

                 {
     EDI_UNINITIALIZED,
     EDI_CONTAINS_TARGET
   };

◆ IntegerSignedness [1/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 105 of file lithium-codegen-arm.h.

105 { SIGNED_INT32, UNSIGNED_INT32 };

v8::internal::LCodeGen::UNSIGNED_INT32

@ UNSIGNED_INT32

Definition: lithium-codegen-arm.h:105

v8::internal::LCodeGen::SIGNED_INT32

@ SIGNED_INT32

Definition: lithium-codegen-arm.h:105

◆ IntegerSignedness [2/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 84 of file lithium-codegen-arm64.h.

84 { SIGNED_INT32, UNSIGNED_INT32 };

◆ IntegerSignedness [3/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 95 of file lithium-codegen-ia32.h.

95 { SIGNED_INT32, UNSIGNED_INT32 };

◆ IntegerSignedness [4/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 103 of file lithium-codegen-mips.h.

103 { SIGNED_INT32, UNSIGNED_INT32 };

◆ IntegerSignedness [5/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 104 of file lithium-codegen-mips64.h.

104 { SIGNED_INT32, UNSIGNED_INT32 };

◆ IntegerSignedness [6/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 88 of file lithium-codegen-x64.h.

88 { SIGNED_INT32, UNSIGNED_INT32 };

◆ IntegerSignedness [7/7]

enum v8::internal::LCodeGen::IntegerSignedness

Enumerator
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32
SIGNED_INT32
UNSIGNED_INT32

Definition at line 129 of file lithium-codegen-x87.h.

129 { SIGNED_INT32, UNSIGNED_INT32 };

◆ R1State

enum v8::internal::LCodeGen::R1State

private

Enumerator
R1_UNINITIALIZED
R1_CONTAINS_TARGET

Definition at line 219 of file lithium-codegen-arm.h.

                {
     R1_UNINITIALIZED,
     R1_CONTAINS_TARGET
   };

◆ RDIState

enum v8::internal::LCodeGen::RDIState

private

Enumerator
RDI_UNINITIALIZED
RDI_CONTAINS_TARGET

Definition at line 191 of file lithium-codegen-x64.h.

                 {
     RDI_UNINITIALIZED,
     RDI_CONTAINS_TARGET
   };

◆ SafepointMode [1/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 181 of file lithium-codegen-arm.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
   };

◆ SafepointMode [2/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 289 of file lithium-codegen-arm64.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
   };

◆ SafepointMode [3/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 161 of file lithium-codegen-ia32.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
   };

◆ SafepointMode [4/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 181 of file lithium-codegen-mips.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
   };

◆ SafepointMode [5/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 182 of file lithium-codegen-mips64.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
   };

◆ SafepointMode [6/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 156 of file lithium-codegen-x64.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS
   };

◆ SafepointMode [7/7]

enum v8::internal::LCodeGen::SafepointMode

private

Enumerator
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS
RECORD_SIMPLE_SAFEPOINT
RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS

Definition at line 190 of file lithium-codegen-x87.h.

                      {
     RECORD_SIMPLE_SAFEPOINT,
     RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
   };

◆ StackMode

enum v8::internal::LCodeGen::StackMode

Enumerator
kMustUseFramePointer
kCanUseStackPointer

Definition at line 90 of file lithium-codegen-arm64.h.

90 { kMustUseFramePointer, kCanUseStackPointer };

v8::internal::LCodeGen::kCanUseStackPointer

@ kCanUseStackPointer

Definition: lithium-codegen-arm64.h:90

v8::internal::LCodeGen::kMustUseFramePointer

@ kMustUseFramePointer

Definition: lithium-codegen-arm64.h:90

◆ X87OperandType

enum v8::internal::LCodeGen::X87OperandType

Enumerator
kX87DoubleOperand
kX87FloatOperand
kX87IntOperand

Definition at line 82 of file lithium-codegen-x87.h.

82 { kX87DoubleOperand, kX87FloatOperand, kX87IntOperand };

v8::internal::LCodeGen::kX87IntOperand

@ kX87IntOperand

Definition: lithium-codegen-x87.h:82

v8::internal::LCodeGen::kX87DoubleOperand

@ kX87DoubleOperand

Definition: lithium-codegen-x87.h:82

v8::internal::LCodeGen::kX87FloatOperand

@ kX87FloatOperand

Definition: lithium-codegen-x87.h:82

Constructor & Destructor Documentation

◆ LCodeGen() [1/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 26 of file lithium-codegen-arm.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

◆ LCodeGen() [2/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 27 of file lithium-codegen-arm64.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple),
         after_push_argument_(false),
         inlined_arguments_(false) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

◆ ~LCodeGen()

v8::internal::LCodeGen::~LCodeGen ( )

inline

Definition at line 46 of file lithium-codegen-arm64.h.

               {
     DCHECK(!after_push_argument_ || inlined_arguments_);
   }

References after_push_argument_, DCHECK, and inlined_arguments_.

◆ LCodeGen() [3/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 28 of file lithium-codegen-ia32.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         dynamic_frame_alignment_(false),
         support_aligned_spilled_doubles_(false),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

◆ LCodeGen() [4/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 25 of file lithium-codegen-mips.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

◆ LCodeGen() [5/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 25 of file lithium-codegen-mips64.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

◆ LCodeGen() [6/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 27 of file lithium-codegen-x64.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

◆ LCodeGen() [7/7]

v8::internal::LCodeGen::LCodeGen	(	LChunk *	chunk,
		MacroAssembler *	assembler,
		CompilationInfo *	info
	)

inline

Definition at line 29 of file lithium-codegen-x87.h.

       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
         deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         dynamic_frame_alignment_(false),
         support_aligned_spilled_doubles_(false),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         x87_stack_(assembler),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
   }

References PopulateDeoptimizationLiteralsWithInlinedFunctions().

Here is the call graph for this function:

Member Function Documentation

◆ AddDeferredCode() [1/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 165 of file lithium-codegen-arm.h.

165 { deferred_.Add(code, zone()); }

References deferred_.

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

Here is the caller graph for this function:

◆ AddDeferredCode() [2/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 263 of file lithium-codegen-arm64.h.

263 { deferred_.Add(code, zone()); }

References deferred_.

◆ AddDeferredCode() [3/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 144 of file lithium-codegen-ia32.h.

144 { deferred_.Add(code, zone()); }

References deferred_.

◆ AddDeferredCode() [4/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 165 of file lithium-codegen-mips.h.

165 { deferred_.Add(code, zone()); }

References deferred_.

◆ AddDeferredCode() [5/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 166 of file lithium-codegen-mips64.h.

166 { deferred_.Add(code, zone()); }

References deferred_.

◆ AddDeferredCode() [6/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 138 of file lithium-codegen-x64.h.

138 { deferred_.Add(code, zone()); }

References deferred_.

◆ AddDeferredCode() [7/7]

void v8::internal::LCodeGen::AddDeferredCode ( LDeferredCode * code )

inlineprivate

Definition at line 176 of file lithium-codegen-x87.h.

176 { deferred_.Add(code, zone()); }

References deferred_.

◆ AddToTranslation() [1/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

Definition at line 662 of file lithium-codegen-arm.cc.

                                                                    {
   if (op == LEnvironment::materialization_marker()) {
     int object_index = (*object_index_pointer)++;
     if (environment->ObjectIsDuplicateAt(object_index)) {
       int dupe_of = environment->ObjectDuplicateOfAt(object_index);
       translation->DuplicateObject(dupe_of);
       return;
     }
     int object_length = environment->ObjectLengthAt(object_index);
     if (environment->ObjectIsArgumentsAt(object_index)) {
       translation->BeginArgumentsObject(object_length);
     } else {
       translation->BeginCapturedObject(object_length);
     }
     int dematerialized_index = *dematerialized_index_pointer;
     int env_offset = environment->translation_size() + dematerialized_index;
     *dematerialized_index_pointer += object_length;
     for (int i = 0; i < object_length; ++i) {
       LOperand* value = environment->values()->at(env_offset + i);
       AddToTranslation(environment,
                        translation,
                        value,
                        environment->HasTaggedValueAt(env_offset + i),
                        environment->HasUint32ValueAt(env_offset + i),
                        object_index_pointer,
                        dematerialized_index_pointer);
     }
     return;
   }
  
   if (op->IsStackSlot()) {
     if (is_tagged) {
       translation->StoreStackSlot(op->index());
     } else if (is_uint32) {
       translation->StoreUint32StackSlot(op->index());
     } else {
       translation->StoreInt32StackSlot(op->index());
     }
   } else if (op->IsDoubleStackSlot()) {
     translation->StoreDoubleStackSlot(op->index());
   } else if (op->IsRegister()) {
     Register reg = ToRegister(op);
     if (is_tagged) {
       translation->StoreRegister(reg);
     } else if (is_uint32) {
       translation->StoreUint32Register(reg);
     } else {
       translation->StoreInt32Register(reg);
     }
   } else if (op->IsDoubleRegister()) {
     DoubleRegister reg = ToDoubleRegister(op);
     translation->StoreDoubleRegister(reg);
   } else if (op->IsConstantOperand()) {
     HConstant* constant = chunk()->LookupConstant(LConstantOperand::cast(op));
     int src_index = DefineDeoptimizationLiteral(constant->handle(isolate()));
     translation->StoreLiteral(src_index);
   } else {
     UNREACHABLE();
   }
 }

References chunk(), DefineDeoptimizationLiteral(), v8::internal::LOperand::index(), ToDoubleRegister(), ToRegister(), and UNREACHABLE.

Referenced by WriteTranslation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddToTranslation() [2/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

◆ AddToTranslation() [3/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

◆ AddToTranslation() [4/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

◆ AddToTranslation() [5/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

◆ AddToTranslation() [6/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

◆ AddToTranslation() [7/7]

void v8::internal::LCodeGen::AddToTranslation	(	LEnvironment *	environment,
		Translation *	translation,
		LOperand *	op,
		bool	is_tagged,
		bool	is_uint32,
		int *	object_index_pointer,
		int *	dematerialized_index_pointer
	)

private

◆ BuildFastArrayOperand() [1/3]

Operand v8::internal::LCodeGen::BuildFastArrayOperand	(	LOperand *	elements_pointer,
		LOperand *	key,
		Representation	key_representation,
		ElementsKind	elements_kind,
		uint32_t	base_offset
	)

private

◆ BuildFastArrayOperand() [2/3]

Operand v8::internal::LCodeGen::BuildFastArrayOperand	(	LOperand *	elements_pointer,
		LOperand *	key,
		Representation	key_representation,
		ElementsKind	elements_kind,
		uint32_t	base_offset
	)

private

◆ BuildFastArrayOperand() [3/3]

Operand v8::internal::LCodeGen::BuildFastArrayOperand	(	LOperand *	elements_pointer,
		LOperand *	key,
		Representation	key_representation,
		ElementsKind	elements_kind,
		uint32_t	base_offset
	)

private

◆ BuildSeqStringOperand() [1/7]

MemOperand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		LOperand *	index,
		String::Encoding	encoding
	)

private

Definition at line 1970 of file lithium-codegen-arm.cc.

                                                                     {
   if (index->IsConstantOperand()) {
     int offset = ToInteger32(LConstantOperand::cast(index));
     if (encoding == String::TWO_BYTE_ENCODING) {
       offset *= kUC16Size;
     }
     STATIC_ASSERT(kCharSize == 1);
     return FieldMemOperand(string, SeqString::kHeaderSize + offset);
   }
   Register scratch = scratch0();
   DCHECK(!scratch.is(string));
   DCHECK(!scratch.is(ToRegister(index)));
   if (encoding == String::ONE_BYTE_ENCODING) {
     __ add(scratch, string, Operand(ToRegister(index)));
   } else {
     STATIC_ASSERT(kUC16Size == 2);
     __ add(scratch, string, Operand(ToRegister(index), LSL, 1));
   }
   return FieldMemOperand(scratch, SeqString::kHeaderSize);
 }

References __, DCHECK, v8::internal::FieldMemOperand(), v8::internal::Register::is(), v8::internal::kCharSize, v8::internal::SeqString::kHeaderSize, v8::internal::kUC16Size, v8::internal::LSL, v8::internal::String::ONE_BYTE_ENCODING, scratch0(), v8::internal::STATIC_ASSERT(), ToInteger32(), ToRegister(), and v8::internal::String::TWO_BYTE_ENCODING.

Here is the call graph for this function:

◆ BuildSeqStringOperand() [2/7]

Operand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		LOperand *	index,
		String::Encoding	encoding
	)

private

◆ BuildSeqStringOperand() [3/7]

MemOperand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		LOperand *	index,
		String::Encoding	encoding
	)

private

◆ BuildSeqStringOperand() [4/7]

MemOperand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		LOperand *	index,
		String::Encoding	encoding
	)

private

◆ BuildSeqStringOperand() [5/7]

Operand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		LOperand *	index,
		String::Encoding	encoding
	)

private

◆ BuildSeqStringOperand() [6/7]

Operand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		LOperand *	index,
		String::Encoding	encoding
	)

private

◆ BuildSeqStringOperand() [7/7]

MemOperand v8::internal::LCodeGen::BuildSeqStringOperand	(	Register	string,
		Register	temp,
		LOperand *	index,
		String::Encoding	encoding
	)

private

Definition at line 4783 of file lithium-codegen-arm64.cc.

                                                                     {
   if (index->IsConstantOperand()) {
     int offset = ToInteger32(LConstantOperand::cast(index));
     if (encoding == String::TWO_BYTE_ENCODING) {
       offset *= kUC16Size;
     }
     STATIC_ASSERT(kCharSize == 1);
     return FieldMemOperand(string, SeqString::kHeaderSize + offset);
   }
  
   __ Add(temp, string, SeqString::kHeaderSize - kHeapObjectTag);
   if (encoding == String::ONE_BYTE_ENCODING) {
     return MemOperand(temp, ToRegister32(index), SXTW);
   } else {
     STATIC_ASSERT(kUC16Size == 2);
     return MemOperand(temp, ToRegister32(index), SXTW, 1);
   }
 }

References __, v8::internal::FieldMemOperand(), v8::internal::kCharSize, v8::internal::SeqString::kHeaderSize, v8::internal::kHeapObjectTag, v8::internal::kUC16Size, v8::internal::String::ONE_BYTE_ENCODING, v8::internal::STATIC_ASSERT(), v8::internal::SXTW, ToInteger32(), ToRegister32(), and v8::internal::String::TWO_BYTE_ENCODING.

Here is the call graph for this function:

◆ CallCode() [1/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr
	)

private

Definition at line 381 of file lithium-codegen-arm64.cc.

                                              {
   CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);
 }

References CallCodeGeneric(), mode(), and RECORD_SIMPLE_SAFEPOINT.

Here is the call graph for this function:

◆ CallCode() [2/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr
	)

private

◆ CallCode() [3/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr
	)

private

◆ CallCode() [4/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr
	)

private

◆ CallCode() [5/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr
	)

private

◆ CallCode() [6/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr
	)

private

◆ CallCode() [7/7]

void v8::internal::LCodeGen::CallCode	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		TargetAddressStorageMode	storage_mode = `CAN_INLINE_TARGET_ADDRESS`
	)

private

Definition at line 740 of file lithium-codegen-arm.cc.

                                                                {
   CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT, storage_mode);
 }

References CallCodeGeneric(), mode(), and RECORD_SIMPLE_SAFEPOINT.

Here is the call graph for this function:

◆ CallCodeGeneric() [1/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

Definition at line 388 of file lithium-codegen-arm64.cc.

                                                              {
   DCHECK(instr != NULL);
  
   Assembler::BlockPoolsScope scope(masm_);
   __ Call(code, mode);
   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
  
   if ((code->kind() == Code::BINARY_OP_IC) ||
       (code->kind() == Code::COMPARE_IC)) {
     // Signal that we don't inline smi code before these stubs in the
     // optimizing code generator.
     InlineSmiCheckInfo::EmitNotInlined(masm());
   }
 }

References __, DCHECK, v8::internal::InlineSmiCheckInfo::EmitNotInlined(), mode(), NULL, RecordSafepointWithLazyDeopt(), and scope().

Here is the call graph for this function:

◆ CallCodeGeneric() [2/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ CallCodeGeneric() [3/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ CallCodeGeneric() [4/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ CallCodeGeneric() [5/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ CallCodeGeneric() [6/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode,
		int	argc
	)

private

◆ CallCodeGeneric() [7/7]

void v8::internal::LCodeGen::CallCodeGeneric	(	Handle< Code >	code,
		RelocInfo::Mode	mode,
		LInstruction *	instr,
		SafepointMode	safepoint_mode,
		TargetAddressStorageMode	storage_mode = `CAN_INLINE_TARGET_ADDRESS`
	)

private

Definition at line 748 of file lithium-codegen-arm.cc.

                                                                       {
   DCHECK(instr != NULL);
   // Block literal pool emission to ensure nop indicating no inlined smi code
   // is in the correct position.
   Assembler::BlockConstPoolScope block_const_pool(masm());
   __ Call(code, mode, TypeFeedbackId::None(), al, storage_mode);
   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
  
   // Signal that we don't inline smi code before these stubs in the
   // optimizing code generator.
   if (code->kind() == Code::BINARY_OP_IC ||
       code->kind() == Code::COMPARE_IC) {
     __ nop();
   }
 }

References __, v8::internal::al, DCHECK, mode(), v8::internal::TypeFeedbackId::None(), NULL, and RecordSafepointWithLazyDeopt().

Referenced by CallCode(), and DoDeferredInstanceOfKnownGlobal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallCodeSize()

int v8::internal::LCodeGen::CallCodeSize	(	Handle< Code >	code,
		RelocInfo::Mode	mode
	)

private

Definition at line 730 of file lithium-codegen-arm.cc.

                                                                 {
   int size = masm()->CallSize(code, mode);
   if (code->kind() == Code::BINARY_OP_IC ||
       code->kind() == Code::COMPARE_IC) {
     size += Assembler::kInstrSize;  // extra nop() added in CallCodeGeneric.
   }
   return size;
 }

References v8::internal::Assembler::kInstrSize, mode(), and size.

Referenced by DoDeferredInstanceOfKnownGlobal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallKnownFunction() [1/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		A1State	a1_state
	)

private

Definition at line 3548 of file lithium-codegen-mips.cc.

                                                    {
   bool dont_adapt_arguments =
       formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
   bool can_invoke_directly =
       dont_adapt_arguments || formal_parameter_count == arity;
  
   LPointerMap* pointers = instr->pointer_map();
  
   if (can_invoke_directly) {
     if (a1_state == A1_UNINITIALIZED) {
       __ li(a1, function);
     }
  
     // Change context.
     __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
  
     // Set r0 to arguments count if adaption is not needed. Assumes that r0
     // is available to write to at this point.
     if (dont_adapt_arguments) {
       __ li(a0, Operand(arity));
     }
  
     // Invoke function.
     __ lw(at, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
     __ Call(at);
  
     // Set up deoptimization.
     RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
   } else {
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount count(arity);
     ParameterCount expected(formal_parameter_count);
     __ InvokeFunction(function, expected, count, CALL_FUNCTION, generator);
   }
 }

References __, A1_UNINITIALIZED, CALL_FUNCTION, v8::internal::cp, v8::internal::FieldMemOperand(), v8::internal::JSFunction::kCodeEntryOffset, v8::internal::JSFunction::kContextOffset, v8::internal::SharedFunctionInfo::kDontAdaptArgumentsSentinel, v8::internal::LInstruction::pointer_map(), RECORD_SIMPLE_SAFEPOINT, RecordSafepointWithLazyDeopt(), and SafepointGenerator.

Here is the call graph for this function:

◆ CallKnownFunction() [2/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		A1State	a1_state
	)

private

◆ CallKnownFunction() [3/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		EDIState	edi_state
	)

private

◆ CallKnownFunction() [4/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		EDIState	edi_state
	)

private

◆ CallKnownFunction() [5/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		R1State	r1_state
	)

private

Definition at line 3631 of file lithium-codegen-arm.cc.

                                                    {
   bool dont_adapt_arguments =
       formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
   bool can_invoke_directly =
       dont_adapt_arguments || formal_parameter_count == arity;
  
   LPointerMap* pointers = instr->pointer_map();
  
   if (can_invoke_directly) {
     if (r1_state == R1_UNINITIALIZED) {
       __ Move(r1, function);
     }
  
     // Change context.
     __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset));
  
     // Set r0 to arguments count if adaption is not needed. Assumes that r0
     // is available to write to at this point.
     if (dont_adapt_arguments) {
       __ mov(r0, Operand(arity));
     }
  
     // Invoke function.
     __ ldr(ip, FieldMemOperand(r1, JSFunction::kCodeEntryOffset));
     __ Call(ip);
  
     // Set up deoptimization.
     RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
   } else {
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount count(arity);
     ParameterCount expected(formal_parameter_count);
     __ InvokeFunction(function, expected, count, CALL_FUNCTION, generator);
   }
 }

References __, CALL_FUNCTION, v8::internal::cp, v8::internal::FieldMemOperand(), v8::internal::ip, v8::internal::JSFunction::kCodeEntryOffset, v8::internal::JSFunction::kContextOffset, v8::internal::SharedFunctionInfo::kDontAdaptArgumentsSentinel, v8::internal::LInstruction::pointer_map(), v8::internal::r0, v8::internal::r1, R1_UNINITIALIZED, RECORD_SIMPLE_SAFEPOINT, RecordSafepointWithLazyDeopt(), and SafepointGenerator.

Here is the call graph for this function:

◆ CallKnownFunction() [6/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		RDIState	rdi_state
	)

private

◆ CallKnownFunction() [7/7]

void v8::internal::LCodeGen::CallKnownFunction	(	Handle< JSFunction >	function,
		int	formal_parameter_count,
		int	arity,
		LInstruction *	instr,
		Register	function_reg = `NoReg`
	)

private

Definition at line 1987 of file lithium-codegen-arm64.cc.

                                                         {
   bool dont_adapt_arguments =
       formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
   bool can_invoke_directly =
       dont_adapt_arguments || formal_parameter_count == arity;
  
   // The function interface relies on the following register assignments.
   DCHECK(function_reg.Is(x1) || function_reg.IsNone());
   Register arity_reg = x0;
  
   LPointerMap* pointers = instr->pointer_map();
  
   // If necessary, load the function object.
   if (function_reg.IsNone()) {
     function_reg = x1;
     __ LoadObject(function_reg, function);
   }
  
   if (FLAG_debug_code) {
     Label is_not_smi;
     // Try to confirm that function_reg (x1) is a tagged pointer.
     __ JumpIfNotSmi(function_reg, &is_not_smi);
     __ Abort(kExpectedFunctionObject);
     __ Bind(&is_not_smi);
   }
  
   if (can_invoke_directly) {
     // Change context.
     __ Ldr(cp, FieldMemOperand(function_reg, JSFunction::kContextOffset));
  
     // Set the arguments count if adaption is not needed. Assumes that x0 is
     // available to write to at this point.
     if (dont_adapt_arguments) {
       __ Mov(arity_reg, arity);
     }
  
     // Invoke function.
     __ Ldr(x10, FieldMemOperand(function_reg, JSFunction::kCodeEntryOffset));
     __ Call(x10);
  
     // Set up deoptimization.
     RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
   } else {
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount count(arity);
     ParameterCount expected(formal_parameter_count);
     __ InvokeFunction(function_reg, expected, count, CALL_FUNCTION, generator);
   }
 }

References __, CALL_FUNCTION, v8::internal::cp, DCHECK, v8::internal::FieldMemOperand(), v8::internal::CPURegister::Is(), v8::internal::CPURegister::IsNone(), v8::internal::JSFunction::kCodeEntryOffset, v8::internal::JSFunction::kContextOffset, v8::internal::SharedFunctionInfo::kDontAdaptArgumentsSentinel, v8::internal::LInstruction::pointer_map(), RECORD_SIMPLE_SAFEPOINT, RecordSafepointWithLazyDeopt(), and SafepointGenerator.

Here is the call graph for this function:

◆ CallRuntime() [1/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	fun,
		int	argc,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

◆ CallRuntime() [2/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	fun,
		int	argc,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

◆ CallRuntime() [3/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	function,
		int	num_arguments,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

Definition at line 769 of file lithium-codegen-arm.cc.

                                                         {
   DCHECK(instr != NULL);
  
   __ CallRuntime(function, num_arguments, save_doubles);
  
   RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
 }

References __, DCHECK, NULL, RECORD_SIMPLE_SAFEPOINT, and RecordSafepointWithLazyDeopt().

Referenced by CallRuntime(), and GeneratePrologue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallRuntime() [4/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	function,
		int	num_arguments,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

◆ CallRuntime() [5/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	function,
		int	num_arguments,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

◆ CallRuntime() [6/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	function,
		int	num_arguments,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

◆ CallRuntime() [7/14]

void v8::internal::LCodeGen::CallRuntime	(	const Runtime::Function *	function,
		int	num_arguments,
		LInstruction *	instr,
		SaveFPRegsMode	save_doubles = `kDontSaveFPRegs`
	)

private

◆ CallRuntime() [8/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr
	)

inlineprivate

Definition at line 180 of file lithium-codegen-ia32.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, argc, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntime() [9/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr
	)

inlineprivate

Definition at line 207 of file lithium-codegen-x87.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, argc, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntime() [10/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	num_arguments,
		LInstruction *	instr
	)

inlineprivate

Definition at line 206 of file lithium-codegen-arm.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, num_arguments, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntime() [11/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	num_arguments,
		LInstruction *	instr
	)

inlineprivate

Definition at line 308 of file lithium-codegen-arm64.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, num_arguments, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntime() [12/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	num_arguments,
		LInstruction *	instr
	)

inlineprivate

Definition at line 200 of file lithium-codegen-mips.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, num_arguments, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntime() [13/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	num_arguments,
		LInstruction *	instr
	)

inlineprivate

Definition at line 201 of file lithium-codegen-mips64.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, num_arguments, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntime() [14/14]

void v8::internal::LCodeGen::CallRuntime	(	Runtime::FunctionId	id,
		int	num_arguments,
		LInstruction *	instr
	)

inlineprivate

Definition at line 177 of file lithium-codegen-x64.h.

                                         {
     const Runtime::Function* function = Runtime::FunctionForId(id);
     CallRuntime(function, num_arguments, instr);
   }

References CallRuntime(), and v8::internal::Runtime::FunctionForId().

Here is the call graph for this function:

◆ CallRuntimeFromDeferred() [1/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

Definition at line 796 of file lithium-codegen-arm.cc.

                                                           {
   LoadContextFromDeferred(context);
   __ CallRuntimeSaveDoubles(id);
   RecordSafepointWithRegisters(
       instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
 }

References __, LoadContextFromDeferred(), v8::internal::LInstruction::pointer_map(), and RecordSafepointWithRegisters().

Referenced by DoDeferredAllocate(), DoDeferredMathAbsTagged(), DoDeferredMathAbsTaggedHeapNumber(), DoDeferredStringCharCodeAt(), and DoDeferredStringCharFromCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallRuntimeFromDeferred() [2/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

◆ CallRuntimeFromDeferred() [3/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

◆ CallRuntimeFromDeferred() [4/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

◆ CallRuntimeFromDeferred() [5/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

◆ CallRuntimeFromDeferred() [6/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

◆ CallRuntimeFromDeferred() [7/7]

void v8::internal::LCodeGen::CallRuntimeFromDeferred	(	Runtime::FunctionId	id,
		int	argc,
		LInstruction *	instr,
		LOperand *	context
	)

private

◆ chunk()

LPlatformChunk* v8::internal::LCodeGen::chunk ( ) const

inlineprivate

Definition at line 123 of file lithium-codegen-x64.h.

123 { return chunk_; }

Referenced by AddToTranslation(), GenerateCode(), GenerateDeferredCode(), GetStackSlotCount(), graph(), LookupDestination(), PopulateDeoptimizationLiteralsWithInlinedFunctions(), RestoreCallerDoubles(), SaveCallerDoubles(), ToOperand(), and ToOperand32().

Here is the caller graph for this function:

◆ DefineDeoptimizationLiteral() [1/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

Definition at line 974 of file lithium-codegen-arm.cc.

                                                                 {
   int result = deoptimization_literals_.length();
   for (int i = 0; i < deoptimization_literals_.length(); ++i) {
     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
   }
   deoptimization_literals_.Add(literal, zone());
   return result;
 }

References deoptimization_literals_.

Referenced by AddToTranslation(), PopulateDeoptimizationLiteralsWithInlinedFunctions(), and WriteTranslation().

Here is the caller graph for this function:

◆ DefineDeoptimizationLiteral() [2/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

◆ DefineDeoptimizationLiteral() [3/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

◆ DefineDeoptimizationLiteral() [4/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

◆ DefineDeoptimizationLiteral() [5/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

◆ DefineDeoptimizationLiteral() [6/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

◆ DefineDeoptimizationLiteral() [7/7]

int v8::internal::LCodeGen::DefineDeoptimizationLiteral ( Handle< Object > literal )

private

◆ DeoptEveryNTimes() [1/3]

bool v8::internal::LCodeGen::DeoptEveryNTimes ( )

inlineprivate

Definition at line 216 of file lithium-codegen-ia32.h.

                           {
     return FLAG_deopt_every_n_times != 0 && !info()->IsStub();
   }

◆ DeoptEveryNTimes() [2/3]

bool v8::internal::LCodeGen::DeoptEveryNTimes ( )

inlineprivate

Definition at line 213 of file lithium-codegen-x64.h.

                           {
     return FLAG_deopt_every_n_times != 0 && !info()->IsStub();
   }

◆ DeoptEveryNTimes() [3/3]

bool v8::internal::LCodeGen::DeoptEveryNTimes ( )

inlineprivate

Definition at line 243 of file lithium-codegen-x87.h.

                           {
     return FLAG_deopt_every_n_times != 0 && !info()->IsStub();
   }

◆ Deoptimize()

void v8::internal::LCodeGen::Deoptimize	(	LInstruction *	instr,
		const char *	detail,
		Deoptimizer::BailoutType *	override_bailout_type = `NULL`
	)

private

Definition at line 1066 of file lithium-codegen-arm64.cc.

                                                                          {
   DeoptimizeBranch(instr, detail, always, NoReg, -1, override_bailout_type);
 }

References v8::internal::always, and DeoptimizeBranch().

Here is the call graph for this function:

◆ DeoptimizeBranch()

void v8::internal::LCodeGen::DeoptimizeBranch	(	LInstruction *	instr,
		const char *	detail,
		BranchType	branch_type,
		Register	reg = `NoReg`,
		int	bit = `-1`,
		Deoptimizer::BailoutType *	override_bailout_type = `NULL`
	)

private

Definition at line 991 of file lithium-codegen-arm64.cc.

                                                                           {
   LEnvironment* environment = instr->environment();
   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
   Deoptimizer::BailoutType bailout_type =
     info()->IsStub() ? Deoptimizer::LAZY : Deoptimizer::EAGER;
  
   if (override_bailout_type != NULL) {
     bailout_type = *override_bailout_type;
   }
  
   DCHECK(environment->HasBeenRegistered());
   DCHECK(info()->IsOptimizing() || info()->IsStub());
   int id = environment->deoptimization_index();
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
  
   if (entry == NULL) {
     Abort(kBailoutWasNotPrepared);
   }
  
   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
     Label not_zero;
     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
  
     __ Push(x0, x1, x2);
     __ Mrs(x2, NZCV);
     __ Mov(x0, count);
     __ Ldr(w1, MemOperand(x0));
     __ Subs(x1, x1, 1);
     __ B(gt, &not_zero);
     __ Mov(w1, FLAG_deopt_every_n_times);
     __ Str(w1, MemOperand(x0));
     __ Pop(x2, x1, x0);
     DCHECK(frame_is_built_);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     __ Unreachable();
  
     __ Bind(&not_zero);
     __ Str(w1, MemOperand(x0));
     __ Msr(NZCV, x2);
     __ Pop(x2, x1, x0);
   }
  
   if (info()->ShouldTrapOnDeopt()) {
     Label dont_trap;
     __ B(&dont_trap, InvertBranchType(branch_type), reg, bit);
     __ Debug("trap_on_deopt", __LINE__, BREAK);
     __ Bind(&dont_trap);
   }
  
   Deoptimizer::Reason reason(instr->hydrogen_value()->position().raw(),
                              instr->Mnemonic(), detail);
   DCHECK(info()->IsStub() || frame_is_built_);
   // Go through jump table if we need to build frame, or restore caller doubles.
   if (branch_type == always &&
       frame_is_built_ && !info()->saves_caller_doubles()) {
     DeoptComment(reason);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
   } else {
     Deoptimizer::JumpTableEntry* table_entry =
         new (zone()) Deoptimizer::JumpTableEntry(entry, reason, bailout_type,
                                                  !frame_is_built_);
     // We often have several deopts to the same entry, reuse the last
     // jump entry if this is the case.
     if (jump_table_.is_empty() ||
         !table_entry->IsEquivalentTo(*jump_table_.last())) {
       jump_table_.Add(table_entry, zone());
     }
     __ B(&jump_table_.last()->label, branch_type, reg, bit);
   }
 }

References __, v8::internal::always, v8::internal::B, v8::internal::BREAK, DCHECK, v8::internal::Deoptimizer::EAGER, v8::internal::LInstruction::environment(), frame_is_built_, v8::internal::Deoptimizer::GetDeoptimizationEntry(), v8::internal::gt, v8::internal::LInstruction::hydrogen_value(), v8::internal::InvertBranchType(), v8::internal::Deoptimizer::JumpTableEntry::IsEquivalentTo(), jump_table_, v8::internal::Deoptimizer::LAZY, LEnvironment, v8::internal::LInstruction::Mnemonic(), v8::internal::not_zero, NULL, v8::internal::NZCV, v8::internal::HValue::position(), v8::internal::compiler::Push(), v8::internal::HSourcePosition::raw(), RegisterEnvironmentForDeoptimization(), and v8::internal::RelocInfo::RUNTIME_ENTRY.

Referenced by Deoptimize(), DeoptimizeIfBitClear(), DeoptimizeIfBitSet(), DeoptimizeIfNotZero(), and DeoptimizeIfZero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIf() [1/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cc,
		LInstruction *	instr,
		const char *	detail
	)

private

◆ DeoptimizeIf() [2/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cc,
		LInstruction *	instr,
		const char *	detail
	)

private

◆ DeoptimizeIf() [3/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cc,
		LInstruction *	instr,
		const char *	detail
	)

private

◆ DeoptimizeIf() [4/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cc,
		LInstruction *	instr,
		const char *	detail,
		Deoptimizer::BailoutType	bailout_type
	)

private

◆ DeoptimizeIf() [5/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cc,
		LInstruction *	instr,
		const char *	detail,
		Deoptimizer::BailoutType	bailout_type
	)

private

◆ DeoptimizeIf() [6/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cc,
		LInstruction *	instr,
		const char *	detail,
		Deoptimizer::BailoutType	bailout_type
	)

private

◆ DeoptimizeIf() [7/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	cond,
		LInstruction *	instr,
		const char *	detail
	)

private

◆ DeoptimizeIf() [8/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	condition,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 921 of file lithium-codegen-arm.cc.

                                                 {
   Deoptimizer::BailoutType bailout_type = info()->IsStub()
       ? Deoptimizer::LAZY
       : Deoptimizer::EAGER;
   DeoptimizeIf(condition, instr, detail, bailout_type);
 }

References DeoptimizeIf(), v8::internal::Deoptimizer::EAGER, and v8::internal::Deoptimizer::LAZY.

Here is the call graph for this function:

◆ DeoptimizeIf() [9/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	condition,
		LInstruction *	instr,
		const char *	detail,
		Deoptimizer::BailoutType	bailout_type
	)

private

Definition at line 844 of file lithium-codegen-arm.cc.

                                                                  {
   LEnvironment* environment = instr->environment();
   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
   DCHECK(environment->HasBeenRegistered());
   int id = environment->deoptimization_index();
   DCHECK(info()->IsOptimizing() || info()->IsStub());
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
   if (entry == NULL) {
     Abort(kBailoutWasNotPrepared);
     return;
   }
  
   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
     Register scratch = scratch0();
     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
  
     // Store the condition on the stack if necessary
     if (condition != al) {
       __ mov(scratch, Operand::Zero(), LeaveCC, NegateCondition(condition));
       __ mov(scratch, Operand(1), LeaveCC, condition);
       __ push(scratch);
     }
  
     __ push(r1);
     __ mov(scratch, Operand(count));
     __ ldr(r1, MemOperand(scratch));
     __ sub(r1, r1, Operand(1), SetCC);
     __ mov(r1, Operand(FLAG_deopt_every_n_times), LeaveCC, eq);
     __ str(r1, MemOperand(scratch));
     __ pop(r1);
  
     if (condition != al) {
       // Clean up the stack before the deoptimizer call
       __ pop(scratch);
     }
  
     __ Call(entry, RelocInfo::RUNTIME_ENTRY, eq);
  
     // 'Restore' the condition in a slightly hacky way. (It would be better
     // to use 'msr' and 'mrs' instructions here, but they are not supported by
     // our ARM simulator).
     if (condition != al) {
       condition = ne;
       __ cmp(scratch, Operand::Zero());
     }
   }
  
   if (info()->ShouldTrapOnDeopt()) {
     __ stop("trap_on_deopt", condition);
   }
  
   Deoptimizer::Reason reason(instr->hydrogen_value()->position().raw(),
                              instr->Mnemonic(), detail);
   DCHECK(info()->IsStub() || frame_is_built_);
   // Go through jump table if we need to handle condition, build frame, or
   // restore caller doubles.
   if (condition == al && frame_is_built_ &&
       !info()->saves_caller_doubles()) {
     DeoptComment(reason);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
   } else {
     Deoptimizer::JumpTableEntry table_entry(entry, reason, bailout_type,
                                             !frame_is_built_);
     // We often have several deopts to the same entry, reuse the last
     // jump entry if this is the case.
     if (jump_table_.is_empty() ||
         !table_entry.IsEquivalentTo(jump_table_.last())) {
       jump_table_.Add(table_entry, zone());
     }
     __ b(condition, &jump_table_.last().label);
   }
 }

References __, v8::internal::al, DCHECK, v8::internal::LInstruction::environment(), v8::internal::eq, frame_is_built_, v8::internal::Deoptimizer::GetDeoptimizationEntry(), v8::internal::LInstruction::hydrogen_value(), v8::internal::Deoptimizer::JumpTableEntry::IsEquivalentTo(), jump_table_, v8::internal::LeaveCC, LEnvironment, v8::internal::LInstruction::Mnemonic(), v8::internal::ne, v8::internal::NegateCondition(), NULL, v8::internal::HValue::position(), v8::internal::r1, v8::internal::HSourcePosition::raw(), RegisterEnvironmentForDeoptimization(), v8::internal::RelocInfo::RUNTIME_ENTRY, scratch0(), and v8::internal::SetCC.

Referenced by DeoptimizeIf(), DeoptimizeIfMinusZero(), DeoptimizeIfNotHeapNumber(), DeoptimizeIfNotRoot(), DeoptimizeIfRoot(), DoDeferredInstanceMigration(), DoDeferredMathAbsTaggedHeapNumber(), DoDeferredTaggedToI(), DoLoadKeyedExternalArray(), DoLoadKeyedFixedArray(), DoLoadKeyedFixedDoubleArray(), EmitIntegerMathAbs(), and EmitNumberUntagD().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIf() [10/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	condition,
		LInstruction *	instr,
		const char *	detail,
		Register	src1 = `zero_reg`,
		const Operand &	src2 = `Operand(zero_reg)`
	)

private

◆ DeoptimizeIf() [11/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	condition,
		LInstruction *	instr,
		const char *	detail = `NULL`,
		Register	src1 = `zero_reg`,
		const Operand &	src2 = `Operand(zero_reg)`
	)

private

Definition at line 884 of file lithium-codegen-mips.cc.

                                                  {
   Deoptimizer::BailoutType bailout_type = info()->IsStub()
       ? Deoptimizer::LAZY
       : Deoptimizer::EAGER;
   DeoptimizeIf(condition, instr, bailout_type, detail, src1, src2);
 }

References DeoptimizeIf(), v8::internal::Deoptimizer::EAGER, and v8::internal::Deoptimizer::LAZY.

Here is the call graph for this function:

◆ DeoptimizeIf() [12/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	condition,
		LInstruction *	instr,
		Deoptimizer::BailoutType	bailout_type,
		const char *	detail,
		Register	src1 = `zero_reg`,
		const Operand &	src2 = `Operand(zero_reg)`
	)

private

Definition at line 817 of file lithium-codegen-mips.cc.

                                                  {
   LEnvironment* environment = instr->environment();
   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
   DCHECK(environment->HasBeenRegistered());
   int id = environment->deoptimization_index();
   DCHECK(info()->IsOptimizing() || info()->IsStub());
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
   if (entry == NULL) {
     Abort(kBailoutWasNotPrepared);
     return;
   }
  
   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
     Register scratch = scratch0();
     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
     Label no_deopt;
     __ Push(a1, scratch);
     __ li(scratch, Operand(count));
     __ lw(a1, MemOperand(scratch));
     __ Subu(a1, a1, Operand(1));
     __ Branch(&no_deopt, ne, a1, Operand(zero_reg));
     __ li(a1, Operand(FLAG_deopt_every_n_times));
     __ sw(a1, MemOperand(scratch));
     __ Pop(a1, scratch);
  
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     __ bind(&no_deopt);
     __ sw(a1, MemOperand(scratch));
     __ Pop(a1, scratch);
   }
  
   if (info()->ShouldTrapOnDeopt()) {
     Label skip;
     if (condition != al) {
       __ Branch(&skip, NegateCondition(condition), src1, src2);
     }
     __ stop("trap_on_deopt");
     __ bind(&skip);
   }
  
   Deoptimizer::Reason reason(instr->hydrogen_value()->position().raw(),
                              instr->Mnemonic(), detail);
   DCHECK(info()->IsStub() || frame_is_built_);
   // Go through jump table if we need to handle condition, build frame, or
   // restore caller doubles.
   if (condition == al && frame_is_built_ &&
       !info()->saves_caller_doubles()) {
     DeoptComment(reason);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY, condition, src1, src2);
   } else {
     Deoptimizer::JumpTableEntry table_entry(entry, reason, bailout_type,
                                             !frame_is_built_);
     // We often have several deopts to the same entry, reuse the last
     // jump entry if this is the case.
     if (jump_table_.is_empty() ||
         !table_entry.IsEquivalentTo(jump_table_.last())) {
       jump_table_.Add(table_entry, zone());
     }
     __ Branch(&jump_table_.last().label, condition, src1, src2);
   }
 }

References __, v8::internal::al, DCHECK, v8::internal::LInstruction::environment(), frame_is_built_, v8::internal::Deoptimizer::GetDeoptimizationEntry(), v8::internal::LInstruction::hydrogen_value(), v8::internal::Deoptimizer::JumpTableEntry::IsEquivalentTo(), jump_table_, LEnvironment, v8::internal::LInstruction::Mnemonic(), v8::internal::ne, v8::internal::NegateCondition(), NULL, v8::internal::HValue::position(), v8::internal::compiler::Push(), v8::internal::HSourcePosition::raw(), RegisterEnvironmentForDeoptimization(), v8::internal::RelocInfo::RUNTIME_ENTRY, and scratch0().

Here is the call graph for this function:

◆ DeoptimizeIf() [13/13]

void v8::internal::LCodeGen::DeoptimizeIf	(	Condition	condition,
		LInstruction *	instr,
		Deoptimizer::BailoutType	bailout_type,
		const char *	detail,
		Register	src1 = `zero_reg`,
		const Operand &	src2 = `Operand(zero_reg)`
	)

private

◆ DeoptimizeIfBitClear()

void v8::internal::LCodeGen::DeoptimizeIfBitClear	(	Register	rt,
		int	bit,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1142 of file lithium-codegen-arm64.cc.

                                                         {
   DeoptimizeBranch(instr, detail, reg_bit_clear, rt, bit);
 }

References DeoptimizeBranch(), and v8::internal::reg_bit_clear.

Referenced by DeoptimizeIfSmi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIfBitSet()

void v8::internal::LCodeGen::DeoptimizeIfBitSet	(	Register	rt,
		int	bit,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1136 of file lithium-codegen-arm64.cc.

                                                       {
   DeoptimizeBranch(instr, detail, reg_bit_set, rt, bit);
 }

References DeoptimizeBranch(), and v8::internal::reg_bit_set.

Referenced by DeoptimizeIfNegative(), and DeoptimizeIfNotSmi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIfMinusZero()

void v8::internal::LCodeGen::DeoptimizeIfMinusZero	(	DoubleRegister	input,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1123 of file lithium-codegen-arm64.cc.

                                                          {
   __ TestForMinusZero(input);
   DeoptimizeIf(vs, instr, detail);
 }

References __, DeoptimizeIf(), and v8::internal::vs.

Here is the call graph for this function:

◆ DeoptimizeIfNegative()

void v8::internal::LCodeGen::DeoptimizeIfNegative	(	Register	rt,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1090 of file lithium-codegen-arm64.cc.

                                                         {
   int sign_bit = rt.Is64Bits() ? kXSignBit : kWSignBit;
   DeoptimizeIfBitSet(rt, sign_bit, instr, detail);
 }

References DeoptimizeIfBitSet(), v8::internal::CPURegister::Is64Bits(), v8::internal::kWSignBit, and v8::internal::kXSignBit.

Referenced by DoDeferredTaggedToI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIfNotHeapNumber()

void v8::internal::LCodeGen::DeoptimizeIfNotHeapNumber	(	Register	object,
		LInstruction *	instr
	)

private

Definition at line 1130 of file lithium-codegen-arm64.cc.

                                                                              {
   __ CompareObjectMap(object, Heap::kHeapNumberMapRootIndex);
   DeoptimizeIf(ne, instr, "not heap number");
 }

References __, DeoptimizeIf(), and v8::internal::ne.

Referenced by DoDeferredMathAbsTagged(), and DoDeferredTaggedToI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIfNotRoot()

void v8::internal::LCodeGen::DeoptimizeIfNotRoot	(	Register	rt,
		Heap::RootListIndex	index,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1116 of file lithium-codegen-arm64.cc.

                                                                             {
   __ CompareRoot(rt, index);
   DeoptimizeIf(ne, instr, detail);
 }

References __, DeoptimizeIf(), and v8::internal::ne.

Referenced by DoDeferredTaggedToI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeIfNotSmi()

void v8::internal::LCodeGen::DeoptimizeIfNotSmi	(	Register	rt,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1103 of file lithium-codegen-arm64.cc.

                                                       {
   DeoptimizeIfBitSet(rt, MaskToBit(kSmiTagMask), instr, detail);
 }

References DeoptimizeIfBitSet(), v8::internal::kSmiTagMask, and v8::internal::MaskToBit().

Here is the call graph for this function:

◆ DeoptimizeIfNotZero()

void v8::internal::LCodeGen::DeoptimizeIfNotZero	(	Register	rt,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1084 of file lithium-codegen-arm64.cc.

                                                        {
   DeoptimizeBranch(instr, detail, reg_not_zero, rt);
 }

References DeoptimizeBranch(), and v8::internal::reg_not_zero.

Here is the call graph for this function:

◆ DeoptimizeIfRoot()

void v8::internal::LCodeGen::DeoptimizeIfRoot	(	Register	rt,
		Heap::RootListIndex	index,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1109 of file lithium-codegen-arm64.cc.

                                                                          {
   __ CompareRoot(rt, index);
   DeoptimizeIf(eq, instr, detail);
 }

References __, DeoptimizeIf(), and v8::internal::eq.

Here is the call graph for this function:

◆ DeoptimizeIfSmi()

void v8::internal::LCodeGen::DeoptimizeIfSmi	(	Register	rt,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1097 of file lithium-codegen-arm64.cc.

                                                    {
   DeoptimizeIfBitClear(rt, MaskToBit(kSmiTagMask), instr, detail);
 }

References DeoptimizeIfBitClear(), v8::internal::kSmiTagMask, and v8::internal::MaskToBit().

Here is the call graph for this function:

◆ DeoptimizeIfZero()

void v8::internal::LCodeGen::DeoptimizeIfZero	(	Register	rt,
		LInstruction *	instr,
		const char *	detail
	)

private

Definition at line 1078 of file lithium-codegen-arm64.cc.

                                                     {
   DeoptimizeBranch(instr, detail, reg_zero, rt);
 }

References DeoptimizeBranch(), and v8::internal::reg_zero.

Here is the call graph for this function:

◆ DISALLOW_COPY_AND_ASSIGN() [1/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DISALLOW_COPY_AND_ASSIGN() [2/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DISALLOW_COPY_AND_ASSIGN() [3/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DISALLOW_COPY_AND_ASSIGN() [4/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DISALLOW_COPY_AND_ASSIGN() [5/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DISALLOW_COPY_AND_ASSIGN() [6/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DISALLOW_COPY_AND_ASSIGN() [7/7]

v8::internal::LCodeGen::DISALLOW_COPY_AND_ASSIGN ( LCodeGen )

private

◆ DoDeferredAllocate() [1/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

Definition at line 5389 of file lithium-codegen-arm.cc.

                                                   {
   Register result = ToRegister(instr->result());
  
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand(Smi::FromInt(0)));
  
   PushSafepointRegistersScope scope(this);
   if (instr->size()->IsRegister()) {
     Register size = ToRegister(instr->size());
     DCHECK(!size.is(result));
     __ SmiTag(size);
     __ push(size);
   } else {
     int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
     if (size >= 0 && size <= Smi::kMaxValue) {
       __ Push(Smi::FromInt(size));
     } else {
       // We should never get here at runtime => abort
       __ stop("invalid allocation size");
       return;
     }
   }
  
   int flags = AllocateDoubleAlignFlag::encode(
       instr->hydrogen()->MustAllocateDoubleAligned());
   if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
     DCHECK(!instr->hydrogen()->IsOldDataSpaceAllocation());
     DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
     flags = AllocateTargetSpace::update(flags, OLD_POINTER_SPACE);
   } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
     DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
     flags = AllocateTargetSpace::update(flags, OLD_DATA_SPACE);
   } else {
     flags = AllocateTargetSpace::update(flags, NEW_SPACE);
   }
   __ Push(Smi::FromInt(flags));
  
   CallRuntimeFromDeferred(
       Runtime::kAllocateInTargetSpace, 2, instr, instr->context());
   __ StoreToSafepointRegisterSlot(r0, result);
 }

References __, CallRuntimeFromDeferred(), DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::encode(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::Smi::FromInt(), v8::internal::Smi::kMaxValue, v8::internal::NEW_SPACE, v8::internal::OLD_DATA_SPACE, v8::internal::OLD_POINTER_SPACE, v8::internal::compiler::Push(), v8::internal::r0, scope(), size, ToInteger32(), ToRegister(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ DoDeferredAllocate() [2/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

private

◆ DoDeferredAllocate() [3/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

◆ DoDeferredAllocate() [4/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

◆ DoDeferredAllocate() [5/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

◆ DoDeferredAllocate() [6/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

◆ DoDeferredAllocate() [7/7]

void v8::internal::LCodeGen::DoDeferredAllocate ( LAllocate * instr )

◆ DoDeferredInstanceMigration() [1/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

Definition at line 5178 of file lithium-codegen-arm.cc.

                                                                              {
   {
     PushSafepointRegistersScope scope(this);
     __ push(object);
     __ mov(cp, Operand::Zero());
     __ CallRuntimeSaveDoubles(Runtime::kTryMigrateInstance);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 1, Safepoint::kNoLazyDeopt);
     __ StoreToSafepointRegisterSlot(r0, scratch0());
   }
   __ tst(scratch0(), Operand(kSmiTagMask));
   DeoptimizeIf(eq, instr, "instance migration failed");
 }

References __, v8::internal::cp, DeoptimizeIf(), v8::internal::eq, v8::internal::kSmiTagMask, v8::internal::r0, RecordSafepointWithRegisters(), scope(), and scratch0().

Here is the call graph for this function:

◆ DoDeferredInstanceMigration() [2/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

private

◆ DoDeferredInstanceMigration() [3/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

◆ DoDeferredInstanceMigration() [4/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

◆ DoDeferredInstanceMigration() [5/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

◆ DoDeferredInstanceMigration() [6/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

◆ DoDeferredInstanceMigration() [7/7]

void v8::internal::LCodeGen::DoDeferredInstanceMigration	(	LCheckMaps *	instr,
		Register	object
	)

◆ DoDeferredInstanceOfKnownGlobal() [1/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal ( LInstanceOfKnownGlobal * instr )

private

Definition at line 3137 of file lithium-codegen-arm64.cc.

                                                                             {
   Register result = ToRegister(instr->result());
   DCHECK(result.Is(x0));  // InstanceofStub returns its result in x0.
   InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kArgsInRegisters);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kReturnTrueFalseObject);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kCallSiteInlineCheck);
  
   PushSafepointRegistersScope scope(this);
   LoadContextFromDeferred(instr->context());
  
   // Prepare InstanceofStub arguments.
   DCHECK(ToRegister(instr->value()).Is(InstanceofStub::left()));
   __ LoadObject(InstanceofStub::right(), instr->function());
  
   InstanceofStub stub(isolate(), flags);
   CallCodeGeneric(stub.GetCode(),
                   RelocInfo::CODE_TARGET,
                   instr,
                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
  
   // Put the result value into the result register slot.
   __ StoreToSafepointRegisterSlot(result, result);
 }

References __, CallCodeGeneric(), v8::internal::RelocInfo::CODE_TARGET, DCHECK, v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::CPURegister::Is(), v8::internal::InstanceofStub::kArgsInRegisters, v8::internal::InstanceofStub::kCallSiteInlineCheck, v8::internal::InstanceofStub::kNoFlags, v8::internal::InstanceofStub::kReturnTrueFalseObject, v8::internal::InstanceofStub::left(), LEnvironment, LoadContextFromDeferred(), RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS, v8::internal::InstanceofStub::right(), safepoints_, scope(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredInstanceOfKnownGlobal() [2/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal	(	LInstanceOfKnownGlobal *	instr,
		Label *	map_check
	)

Definition at line 2769 of file lithium-codegen-mips.cc.

                                                                  {
   Register result = ToRegister(instr->result());
   DCHECK(result.is(v0));
  
   InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kArgsInRegisters);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kCallSiteInlineCheck);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kReturnTrueFalseObject);
   InstanceofStub stub(isolate(), flags);
  
   PushSafepointRegistersScope scope(this);
   LoadContextFromDeferred(instr->context());
  
   // Get the temp register reserved by the instruction. This needs to be t0 as
   // its slot of the pushing of safepoint registers is used to communicate the
   // offset to the location of the map check.
   Register temp = ToRegister(instr->temp());
   DCHECK(temp.is(t0));
   __ li(InstanceofStub::right(), instr->function());
   static const int kAdditionalDelta = 7;
   int delta = masm_->InstructionsGeneratedSince(map_check) + kAdditionalDelta;
   Label before_push_delta;
   __ bind(&before_push_delta);
   {
     Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
     __ li(temp, Operand(delta * kPointerSize), CONSTANT_SIZE);
     __ StoreToSafepointRegisterSlot(temp, temp);
   }
   CallCodeGeneric(stub.GetCode(),
                   RelocInfo::CODE_TARGET,
                   instr,
                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
   // Put the result value into the result register slot and
   // restore all registers.
   __ StoreToSafepointRegisterSlot(result, result);
 }

References __, CallCodeGeneric(), v8::internal::RelocInfo::CODE_TARGET, v8::internal::CONSTANT_SIZE, DCHECK, v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::Register::is(), v8::internal::InstanceofStub::kArgsInRegisters, v8::internal::InstanceofStub::kCallSiteInlineCheck, v8::internal::InstanceofStub::kNoFlags, v8::internal::kPointerSize, v8::internal::InstanceofStub::kReturnTrueFalseObject, LEnvironment, LoadContextFromDeferred(), RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS, v8::internal::InstanceofStub::right(), safepoints_, scope(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredInstanceOfKnownGlobal() [3/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal	(	LInstanceOfKnownGlobal *	instr,
		Label *	map_check
	)

◆ DoDeferredInstanceOfKnownGlobal() [4/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal	(	LInstanceOfKnownGlobal *	instr,
		Label *	map_check
	)

◆ DoDeferredInstanceOfKnownGlobal() [5/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal	(	LInstanceOfKnownGlobal *	instr,
		Label *	map_check
	)

◆ DoDeferredInstanceOfKnownGlobal() [6/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal	(	LInstanceOfKnownGlobal *	instr,
		Label *	map_check
	)

◆ DoDeferredInstanceOfKnownGlobal() [7/7]

void v8::internal::LCodeGen::DoDeferredInstanceOfKnownGlobal	(	LInstanceOfKnownGlobal *	instr,
		Label *	map_check,
		Label *	bool_load
	)

Definition at line 2865 of file lithium-codegen-arm.cc.

                                                                  {
   InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kArgsInRegisters);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kCallSiteInlineCheck);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kReturnTrueFalseObject);
   InstanceofStub stub(isolate(), flags);
  
   PushSafepointRegistersScope scope(this);
   LoadContextFromDeferred(instr->context());
  
   __ Move(InstanceofStub::right(), instr->function());
  
   int call_size = CallCodeSize(stub.GetCode(), RelocInfo::CODE_TARGET);
   int additional_delta = (call_size / Assembler::kInstrSize) + 4;
   // Make sure that code size is predicable, since we use specific constants
   // offsets in the code to find embedded values..
   PredictableCodeSizeScope predictable(
       masm_, (additional_delta + 1) * Assembler::kInstrSize);
   // Make sure we don't emit any additional entries in the constant pool before
   // the call to ensure that the CallCodeSize() calculated the correct number of
   // instructions for the constant pool load.
   {
     ConstantPoolUnavailableScope constant_pool_unavailable(masm_);
     int map_check_delta =
         masm_->InstructionsGeneratedSince(map_check) + additional_delta;
     int bool_load_delta =
         masm_->InstructionsGeneratedSince(bool_load) + additional_delta;
     Label before_push_delta;
     __ bind(&before_push_delta);
     __ BlockConstPoolFor(additional_delta);
     // r5 is used to communicate the offset to the location of the map check.
     __ mov(r5, Operand(map_check_delta * kPointerSize));
     // r6 is used to communicate the offset to the location of the bool load.
     __ mov(r6, Operand(bool_load_delta * kPointerSize));
     // The mov above can generate one or two instructions. The delta was
     // computed for two instructions, so we need to pad here in case of one
     // instruction.
     while (masm_->InstructionsGeneratedSince(&before_push_delta) != 4) {
       __ nop();
     }
   }
   CallCodeGeneric(stub.GetCode(),
                   RelocInfo::CODE_TARGET,
                   instr,
                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
   // Put the result value (r0) into the result register slot and
   // restore all registers.
   __ StoreToSafepointRegisterSlot(r0, ToRegister(instr->result()));
 }

References __, CallCodeGeneric(), CallCodeSize(), v8::internal::RelocInfo::CODE_TARGET, v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::InstanceofStub::kArgsInRegisters, v8::internal::InstanceofStub::kCallSiteInlineCheck, v8::internal::Assembler::kInstrSize, v8::internal::InstanceofStub::kNoFlags, v8::internal::kPointerSize, v8::internal::InstanceofStub::kReturnTrueFalseObject, LEnvironment, LoadContextFromDeferred(), v8::internal::r0, v8::internal::r5, v8::internal::r6, RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS, v8::internal::InstanceofStub::right(), safepoints_, scope(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredLoadMutableDouble() [1/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	object,
		Register	index
	)

◆ DoDeferredLoadMutableDouble() [2/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	object,
		Register	index
	)

◆ DoDeferredLoadMutableDouble() [3/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	object,
		Register	index
	)

◆ DoDeferredLoadMutableDouble() [4/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	result,
		Register	object,
		Register	index
	)

Definition at line 5820 of file lithium-codegen-arm.cc.

                                                            {
   PushSafepointRegistersScope scope(this);
   __ Push(object);
   __ Push(index);
   __ mov(cp, Operand::Zero());
   __ CallRuntimeSaveDoubles(Runtime::kLoadMutableDouble);
   RecordSafepointWithRegisters(
       instr->pointer_map(), 2, Safepoint::kNoLazyDeopt);
   __ StoreToSafepointRegisterSlot(r0, result);
 }

References __, v8::internal::cp, v8::internal::compiler::Push(), v8::internal::r0, RecordSafepointWithRegisters(), and scope().

Here is the call graph for this function:

◆ DoDeferredLoadMutableDouble() [5/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	result,
		Register	object,
		Register	index
	)

private

◆ DoDeferredLoadMutableDouble() [6/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	result,
		Register	object,
		Register	index
	)

◆ DoDeferredLoadMutableDouble() [7/7]

void v8::internal::LCodeGen::DoDeferredLoadMutableDouble	(	LLoadFieldByIndex *	instr,
		Register	result,
		Register	object,
		Register	index
	)

◆ DoDeferredMathAbsTagged()

void v8::internal::LCodeGen::DoDeferredMathAbsTagged	(	LMathAbsTagged *	instr,
		Label *	exit,
		Label *	allocation_entry
	)

private

Definition at line 3741 of file lithium-codegen-arm64.cc.

                                                                 {
   // Handle the tricky cases of MathAbsTagged:
   //  - HeapNumber inputs.
   //    - Negative inputs produce a positive result, so a new HeapNumber is
   //      allocated to hold it.
   //    - Positive inputs are returned as-is, since there is no need to allocate
   //      a new HeapNumber for the result.
   //  - The (smi) input -0x80000000, produces +0x80000000, which does not fit
   //    a smi. In this case, the inline code sets the result and jumps directly
   //    to the allocation_entry label.
   DCHECK(instr->context() != NULL);
   DCHECK(ToRegister(instr->context()).is(cp));
   Register input = ToRegister(instr->value());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
   Register result_bits = ToRegister(instr->temp3());
   Register result = ToRegister(instr->result());
  
   Label runtime_allocation;
  
   // Deoptimize if the input is not a HeapNumber.
   DeoptimizeIfNotHeapNumber(input, instr);
  
   // If the argument is positive, we can return it as-is, without any need to
   // allocate a new HeapNumber for the result. We have to do this in integer
   // registers (rather than with fabs) because we need to be able to distinguish
   // the two zeroes.
   __ Ldr(result_bits, FieldMemOperand(input, HeapNumber::kValueOffset));
   __ Mov(result, input);
   __ Tbz(result_bits, kXSignBit, exit);
  
   // Calculate abs(input) by clearing the sign bit.
   __ Bic(result_bits, result_bits, kXSignMask);
  
   // Allocate a new HeapNumber to hold the result.
   //  result_bits   The bit representation of the (double) result.
   __ Bind(allocation_entry);
   __ AllocateHeapNumber(result, &runtime_allocation, temp1, temp2);
   // The inline (non-deferred) code will store result_bits into result.
   __ B(exit);
  
   __ Bind(&runtime_allocation);
   if (FLAG_debug_code) {
     // Because result is in the pointer map, we need to make sure it has a valid
     // tagged value before we call the runtime. We speculatively set it to the
     // input (for abs(+x)) or to a smi (for abs(-SMI_MIN)), so it should already
     // be valid.
     Label result_ok;
     Register input = ToRegister(instr->value());
     __ JumpIfSmi(result, &result_ok);
     __ Cmp(input, result);
     __ Assert(eq, kUnexpectedValue);
     __ Bind(&result_ok);
   }
  
   { PushSafepointRegistersScope scope(this);
     CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr,
                             instr->context());
     __ StoreToSafepointRegisterSlot(x0, result);
   }
   // The inline (non-deferred) code will store result_bits into result.
 }

References __, v8::internal::B, CallRuntimeFromDeferred(), v8::internal::LMathAbsTagged::context(), v8::internal::cp, DCHECK, DeoptimizeIfNotHeapNumber(), v8::internal::eq, v8::internal::FieldMemOperand(), v8::internal::Register::is(), v8::internal::HeapNumber::kValueOffset, v8::internal::kXSignBit, v8::internal::kXSignMask, NULL, v8::internal::LTemplateResultInstruction< R >::result(), scope(), v8::internal::LMathAbsTagged::temp1(), v8::internal::LMathAbsTagged::temp2(), v8::internal::LMathAbsTagged::temp3(), ToRegister(), and v8::internal::LMathAbsTagged::value().

Here is the call graph for this function:

◆ DoDeferredMathAbsTaggedHeapNumber() [1/6]

void v8::internal::LCodeGen::DoDeferredMathAbsTaggedHeapNumber ( LMathAbs * instr )

Definition at line 3672 of file lithium-codegen-arm.cc.

                                                                 {
   DCHECK(instr->context() != NULL);
   DCHECK(ToRegister(instr->context()).is(cp));
   Register input = ToRegister(instr->value());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
  
   // Deoptimize if not a heap number.
   __ ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
   __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
   __ cmp(scratch, Operand(ip));
   DeoptimizeIf(ne, instr, "not a heap number");
  
   Label done;
   Register exponent = scratch0();
   scratch = no_reg;
   __ ldr(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
   // Check the sign of the argument. If the argument is positive, just
   // return it.
   __ tst(exponent, Operand(HeapNumber::kSignMask));
   // Move the input to the result if necessary.
   __ Move(result, input);
   __ b(eq, &done);
  
   // Input is negative. Reverse its sign.
   // Preserve the value of all registers.
   {
     PushSafepointRegistersScope scope(this);
  
     // Registers were saved at the safepoint, so we can use
     // many scratch registers.
     Register tmp1 = input.is(r1) ? r0 : r1;
     Register tmp2 = input.is(r2) ? r0 : r2;
     Register tmp3 = input.is(r3) ? r0 : r3;
     Register tmp4 = input.is(r4) ? r0 : r4;
  
     // exponent: floating point exponent value.
  
     Label allocated, slow;
     __ LoadRoot(tmp4, Heap::kHeapNumberMapRootIndex);
     __ AllocateHeapNumber(tmp1, tmp2, tmp3, tmp4, &slow);
     __ b(&allocated);
  
     // Slow case: Call the runtime system to do the number allocation.
     __ bind(&slow);
  
     CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr,
                             instr->context());
     // Set the pointer to the new heap number in tmp.
     if (!tmp1.is(r0)) __ mov(tmp1, Operand(r0));
     // Restore input_reg after call to runtime.
     __ LoadFromSafepointRegisterSlot(input, input);
     __ ldr(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
  
     __ bind(&allocated);
     // exponent: floating point exponent value.
     // tmp1: allocated heap number.
     __ bic(exponent, exponent, Operand(HeapNumber::kSignMask));
     __ str(exponent, FieldMemOperand(tmp1, HeapNumber::kExponentOffset));
     __ ldr(tmp2, FieldMemOperand(input, HeapNumber::kMantissaOffset));
     __ str(tmp2, FieldMemOperand(tmp1, HeapNumber::kMantissaOffset));
  
     __ StoreToSafepointRegisterSlot(tmp1, result);
   }
  
   __ bind(&done);
 }

References __, CallRuntimeFromDeferred(), v8::internal::cp, DCHECK, DeoptimizeIf(), v8::internal::eq, v8::internal::FieldMemOperand(), v8::internal::ip, v8::internal::Register::is(), v8::internal::HeapObject::kMapOffset, v8::internal::HeapNumber::kSignMask, v8::internal::ne, v8::internal::no_reg, NULL, v8::internal::r0, v8::internal::r1, v8::internal::r2, v8::internal::r3, v8::internal::r4, scope(), scratch0(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredMathAbsTaggedHeapNumber() [2/6]

void v8::internal::LCodeGen::DoDeferredMathAbsTaggedHeapNumber ( LMathAbs * instr )

◆ DoDeferredMathAbsTaggedHeapNumber() [3/6]

void v8::internal::LCodeGen::DoDeferredMathAbsTaggedHeapNumber ( LMathAbs * instr )

◆ DoDeferredMathAbsTaggedHeapNumber() [4/6]

void v8::internal::LCodeGen::DoDeferredMathAbsTaggedHeapNumber ( LMathAbs * instr )

◆ DoDeferredMathAbsTaggedHeapNumber() [5/6]

void v8::internal::LCodeGen::DoDeferredMathAbsTaggedHeapNumber ( LMathAbs * instr )

◆ DoDeferredMathAbsTaggedHeapNumber() [6/6]

void v8::internal::LCodeGen::DoDeferredMathAbsTaggedHeapNumber ( LMathAbs * instr )

◆ DoDeferredNumberTagD() [1/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

Definition at line 4814 of file lithium-codegen-arm.cc.

                                                       {
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   Register reg = ToRegister(instr->result());
   __ mov(reg, Operand::Zero());
  
   PushSafepointRegistersScope scope(this);
   // NumberTagI and NumberTagD use the context from the frame, rather than
   // the environment's HContext or HInlinedContext value.
   // They only call Runtime::kAllocateHeapNumber.
   // The corresponding HChange instructions are added in a phase that does
   // not have easy access to the local context.
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
   RecordSafepointWithRegisters(
       instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
   __ sub(r0, r0, Operand(kHeapObjectTag));
   __ StoreToSafepointRegisterSlot(r0, reg);
 }

References __, v8::internal::cp, v8::internal::fp, v8::internal::StandardFrameConstants::kContextOffset, v8::internal::kHeapObjectTag, v8::internal::r0, RecordSafepointWithRegisters(), scope(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredNumberTagD() [2/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

private

◆ DoDeferredNumberTagD() [3/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

◆ DoDeferredNumberTagD() [4/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

◆ DoDeferredNumberTagD() [5/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

◆ DoDeferredNumberTagD() [6/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

◆ DoDeferredNumberTagD() [7/7]

void v8::internal::LCodeGen::DoDeferredNumberTagD ( LNumberTagD * instr )

◆ DoDeferredNumberTagIU() [1/6]

void v8::internal::LCodeGen::DoDeferredNumberTagIU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp,
		IntegerSignedness	signedness
	)

◆ DoDeferredNumberTagIU() [2/6]

void v8::internal::LCodeGen::DoDeferredNumberTagIU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp,
		IntegerSignedness	signedness
	)

◆ DoDeferredNumberTagIU() [3/6]

void v8::internal::LCodeGen::DoDeferredNumberTagIU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp1,
		LOperand *	temp2,
		IntegerSignedness	signedness
	)

Definition at line 4713 of file lithium-codegen-arm.cc.

                                                                    {
   Label done, slow;
   Register src = ToRegister(value);
   Register dst = ToRegister(instr->result());
   Register tmp1 = scratch0();
   Register tmp2 = ToRegister(temp1);
   Register tmp3 = ToRegister(temp2);
   LowDwVfpRegister dbl_scratch = double_scratch0();
  
   if (signedness == SIGNED_INT32) {
     // There was overflow, so bits 30 and 31 of the original integer
     // disagree. Try to allocate a heap number in new space and store
     // the value in there. If that fails, call the runtime system.
     if (dst.is(src)) {
       __ SmiUntag(src, dst);
       __ eor(src, src, Operand(0x80000000));
     }
     __ vmov(dbl_scratch.low(), src);
     __ vcvt_f64_s32(dbl_scratch, dbl_scratch.low());
   } else {
     __ vmov(dbl_scratch.low(), src);
     __ vcvt_f64_u32(dbl_scratch, dbl_scratch.low());
   }
  
   if (FLAG_inline_new) {
     __ LoadRoot(tmp3, Heap::kHeapNumberMapRootIndex);
     __ AllocateHeapNumber(dst, tmp1, tmp2, tmp3, &slow, DONT_TAG_RESULT);
     __ b(&done);
   }
  
   // Slow case: Call the runtime system to do the number allocation.
   __ bind(&slow);
   {
     // TODO(3095996): Put a valid pointer value in the stack slot where the
     // result register is stored, as this register is in the pointer map, but
     // contains an integer value.
     __ mov(dst, Operand::Zero());
  
     // Preserve the value of all registers.
     PushSafepointRegistersScope scope(this);
  
     // NumberTagI and NumberTagD use the context from the frame, rather than
     // the environment's HContext or HInlinedContext value.
     // They only call Runtime::kAllocateHeapNumber.
     // The corresponding HChange instructions are added in a phase that does
     // not have easy access to the local context.
     __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
     __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
     __ sub(r0, r0, Operand(kHeapObjectTag));
     __ StoreToSafepointRegisterSlot(r0, dst);
   }
  
   // Done. Put the value in dbl_scratch into the value of the allocated heap
   // number.
   __ bind(&done);
   __ vstr(dbl_scratch, dst, HeapNumber::kValueOffset);
   __ add(dst, dst, Operand(kHeapObjectTag));
 }

References __, v8::internal::cp, v8::internal::DONT_TAG_RESULT, double_scratch0(), v8::internal::fp, v8::internal::Register::is(), v8::internal::StandardFrameConstants::kContextOffset, v8::internal::kHeapObjectTag, v8::internal::HeapNumber::kValueOffset, v8::internal::LowDwVfpRegister::low(), v8::internal::LInstruction::pointer_map(), v8::internal::r0, RecordSafepointWithRegisters(), v8::internal::LInstruction::result(), scope(), scratch0(), SIGNED_INT32, and ToRegister().

Here is the call graph for this function:

◆ DoDeferredNumberTagIU() [4/6]

void v8::internal::LCodeGen::DoDeferredNumberTagIU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp1,
		LOperand *	temp2,
		IntegerSignedness	signedness
	)

◆ DoDeferredNumberTagIU() [5/6]

void v8::internal::LCodeGen::DoDeferredNumberTagIU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp1,
		LOperand *	temp2,
		IntegerSignedness	signedness
	)

◆ DoDeferredNumberTagIU() [6/6]

void v8::internal::LCodeGen::DoDeferredNumberTagIU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp1,
		LOperand *	temp2,
		IntegerSignedness	signedness
	)

◆ DoDeferredNumberTagU()

void v8::internal::LCodeGen::DoDeferredNumberTagU	(	LInstruction *	instr,
		LOperand *	value,
		LOperand *	temp1,
		LOperand *	temp2
	)

private

Definition at line 4572 of file lithium-codegen-arm64.cc.

                                                      {
   Label slow, convert_and_store;
   Register src = ToRegister32(value);
   Register dst = ToRegister(instr->result());
   Register scratch1 = ToRegister(temp1);
  
   if (FLAG_inline_new) {
     Register scratch2 = ToRegister(temp2);
     __ AllocateHeapNumber(dst, &slow, scratch1, scratch2);
     __ B(&convert_and_store);
   }
  
   // Slow case: call the runtime system to do the number allocation.
   __ Bind(&slow);
   // TODO(3095996): Put a valid pointer value in the stack slot where the result
   // register is stored, as this register is in the pointer map, but contains an
   // integer value.
   __ Mov(dst, 0);
   {
     // Preserve the value of all registers.
     PushSafepointRegistersScope scope(this);
  
     // NumberTagU and NumberTagD use the context from the frame, rather than
     // the environment's HContext or HInlinedContext value.
     // They only call Runtime::kAllocateHeapNumber.
     // The corresponding HChange instructions are added in a phase that does
     // not have easy access to the local context.
     __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
     __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
     RecordSafepointWithRegisters(
       instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
     __ StoreToSafepointRegisterSlot(x0, dst);
   }
  
   // Convert number to floating point and store in the newly allocated heap
   // number.
   __ Bind(&convert_and_store);
   DoubleRegister dbl_scratch = double_scratch();
   __ Ucvtf(dbl_scratch, src);
   __ Str(dbl_scratch, FieldMemOperand(dst, HeapNumber::kValueOffset));
 }

References __, v8::internal::B, v8::internal::cp, double_scratch(), v8::internal::FieldMemOperand(), v8::internal::fp, v8::internal::StandardFrameConstants::kContextOffset, v8::internal::HeapNumber::kValueOffset, v8::internal::LInstruction::pointer_map(), RecordSafepointWithRegisters(), v8::internal::LInstruction::result(), scope(), scratch1(), ToRegister(), and ToRegister32().

Here is the call graph for this function:

◆ DoDeferredStackCheck() [1/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

Definition at line 5676 of file lithium-codegen-arm.cc.

                                                       {
   PushSafepointRegistersScope scope(this);
   LoadContextFromDeferred(instr->context());
   __ CallRuntimeSaveDoubles(Runtime::kStackGuard);
   RecordSafepointWithLazyDeopt(
       instr, RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   DCHECK(instr->HasEnvironment());
   LEnvironment* env = instr->environment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
 }

References __, DCHECK, LEnvironment, LoadContextFromDeferred(), RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS, RecordSafepointWithLazyDeopt(), safepoints_, and scope().

Here is the call graph for this function:

◆ DoDeferredStackCheck() [2/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

private

◆ DoDeferredStackCheck() [3/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

◆ DoDeferredStackCheck() [4/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

◆ DoDeferredStackCheck() [5/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

◆ DoDeferredStackCheck() [6/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

◆ DoDeferredStackCheck() [7/7]

void v8::internal::LCodeGen::DoDeferredStackCheck ( LStackCheck * instr )

◆ DoDeferredStringCharCodeAt() [1/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

Definition at line 4550 of file lithium-codegen-arm.cc.

                                                                   {
   Register string = ToRegister(instr->string());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
  
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand::Zero());
  
   PushSafepointRegistersScope scope(this);
   __ push(string);
   // Push the index as a smi. This is safe because of the checks in
   // DoStringCharCodeAt above.
   if (instr->index()->IsConstantOperand()) {
     int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
     __ mov(scratch, Operand(Smi::FromInt(const_index)));
     __ push(scratch);
   } else {
     Register index = ToRegister(instr->index());
     __ SmiTag(index);
     __ push(index);
   }
   CallRuntimeFromDeferred(Runtime::kStringCharCodeAtRT, 2, instr,
                           instr->context());
   __ AssertSmi(r0);
   __ SmiUntag(r0);
   __ StoreToSafepointRegisterSlot(r0, result);
 }

References __, CallRuntimeFromDeferred(), v8::internal::Smi::FromInt(), v8::internal::r0, scope(), scratch0(), ToInteger32(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredStringCharCodeAt() [2/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

private

◆ DoDeferredStringCharCodeAt() [3/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

◆ DoDeferredStringCharCodeAt() [4/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

◆ DoDeferredStringCharCodeAt() [5/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

◆ DoDeferredStringCharCodeAt() [6/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

◆ DoDeferredStringCharCodeAt() [7/7]

void v8::internal::LCodeGen::DoDeferredStringCharCodeAt ( LStringCharCodeAt * instr )

◆ DoDeferredStringCharFromCode() [1/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

Definition at line 4614 of file lithium-codegen-arm.cc.

                                                                       {
   Register char_code = ToRegister(instr->char_code());
   Register result = ToRegister(instr->result());
  
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand::Zero());
  
   PushSafepointRegistersScope scope(this);
   __ SmiTag(char_code);
   __ push(char_code);
   CallRuntimeFromDeferred(Runtime::kCharFromCode, 1, instr, instr->context());
   __ StoreToSafepointRegisterSlot(r0, result);
 }

References __, CallRuntimeFromDeferred(), v8::internal::r0, scope(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredStringCharFromCode() [2/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

private

◆ DoDeferredStringCharFromCode() [3/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

◆ DoDeferredStringCharFromCode() [4/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

◆ DoDeferredStringCharFromCode() [5/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

◆ DoDeferredStringCharFromCode() [6/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

◆ DoDeferredStringCharFromCode() [7/7]

void v8::internal::LCodeGen::DoDeferredStringCharFromCode ( LStringCharFromCode * instr )

◆ DoDeferredTaggedToI() [1/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI ( LTaggedToI * instr )

Definition at line 4926 of file lithium-codegen-arm.cc.

                                                     {
   Register input_reg = ToRegister(instr->value());
   Register scratch1 = scratch0();
   Register scratch2 = ToRegister(instr->temp());
   LowDwVfpRegister double_scratch = double_scratch0();
   DwVfpRegister double_scratch2 = ToDoubleRegister(instr->temp2());
  
   DCHECK(!scratch1.is(input_reg) && !scratch1.is(scratch2));
   DCHECK(!scratch2.is(input_reg) && !scratch2.is(scratch1));
  
   Label done;
  
   // The input was optimistically untagged; revert it.
   // The carry flag is set when we reach this deferred code as we just executed
   // SmiUntag(heap_object, SetCC)
   STATIC_ASSERT(kHeapObjectTag == 1);
   __ adc(scratch2, input_reg, Operand(input_reg));
  
   // Heap number map check.
   __ ldr(scratch1, FieldMemOperand(scratch2, HeapObject::kMapOffset));
   __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
   __ cmp(scratch1, Operand(ip));
  
   if (instr->truncating()) {
     // Performs a truncating conversion of a floating point number as used by
     // the JS bitwise operations.
     Label no_heap_number, check_bools, check_false;
     __ b(ne, &no_heap_number);
     __ TruncateHeapNumberToI(input_reg, scratch2);
     __ b(&done);
  
     // Check for Oddballs. Undefined/False is converted to zero and True to one
     // for truncating conversions.
     __ bind(&no_heap_number);
     __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
     __ cmp(scratch2, Operand(ip));
     __ b(ne, &check_bools);
     __ mov(input_reg, Operand::Zero());
     __ b(&done);
  
     __ bind(&check_bools);
     __ LoadRoot(ip, Heap::kTrueValueRootIndex);
     __ cmp(scratch2, Operand(ip));
     __ b(ne, &check_false);
     __ mov(input_reg, Operand(1));
     __ b(&done);
  
     __ bind(&check_false);
     __ LoadRoot(ip, Heap::kFalseValueRootIndex);
     __ cmp(scratch2, Operand(ip));
     DeoptimizeIf(ne, instr, "not a heap number/undefined/true/false");
     __ mov(input_reg, Operand::Zero());
   } else {
     DeoptimizeIf(ne, instr, "not a heap number");
  
     __ sub(ip, scratch2, Operand(kHeapObjectTag));
     __ vldr(double_scratch2, ip, HeapNumber::kValueOffset);
     __ TryDoubleToInt32Exact(input_reg, double_scratch2, double_scratch);
     DeoptimizeIf(ne, instr, "lost precision or NaN");
  
     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
       __ cmp(input_reg, Operand::Zero());
       __ b(ne, &done);
       __ VmovHigh(scratch1, double_scratch2);
       __ tst(scratch1, Operand(HeapNumber::kSignMask));
       DeoptimizeIf(ne, instr, "minus zero");
     }
   }
   __ bind(&done);
 }

References __, DCHECK, DeoptimizeIf(), double_scratch(), double_scratch0(), v8::internal::FieldMemOperand(), v8::internal::ip, v8::internal::Register::is(), v8::internal::HValue::kBailoutOnMinusZero, v8::internal::kHeapObjectTag, v8::internal::HeapObject::kMapOffset, v8::internal::HeapNumber::kSignMask, v8::internal::HeapNumber::kValueOffset, v8::internal::ne, scratch0(), scratch1(), v8::internal::STATIC_ASSERT(), ToDoubleRegister(), and ToRegister().

Here is the call graph for this function:

◆ DoDeferredTaggedToI() [2/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI ( LTaggedToI * instr )

◆ DoDeferredTaggedToI() [3/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI ( LTaggedToI * instr )

◆ DoDeferredTaggedToI() [4/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI	(	LTaggedToI *	instr,
		Label *	done
	)

◆ DoDeferredTaggedToI() [5/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI	(	LTaggedToI *	instr,
		Label *	done
	)

◆ DoDeferredTaggedToI() [6/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI	(	LTaggedToI *	instr,
		Label *	done
	)

◆ DoDeferredTaggedToI() [7/7]

void v8::internal::LCodeGen::DoDeferredTaggedToI	(	LTaggedToI *	instr,
		LOperand *	value,
		LOperand *	temp1,
		LOperand *	temp2
	)

private

Definition at line 5589 of file lithium-codegen-arm64.cc.

                                                     {
   Register input = ToRegister(value);
   Register scratch1 = ToRegister(temp1);
   DoubleRegister dbl_scratch1 = double_scratch();
  
   Label done;
  
   if (instr->truncating()) {
     Register output = ToRegister(instr->result());
     Label check_bools;
  
     // If it's not a heap number, jump to undefined check.
     __ JumpIfNotHeapNumber(input, &check_bools);
  
     // A heap number: load value and convert to int32 using truncating function.
     __ TruncateHeapNumberToI(output, input);
     __ B(&done);
  
     __ Bind(&check_bools);
  
     Register true_root = output;
     Register false_root = scratch1;
     __ LoadTrueFalseRoots(true_root, false_root);
     __ Cmp(input, true_root);
     __ Cset(output, eq);
     __ Ccmp(input, false_root, ZFlag, ne);
     __ B(eq, &done);
  
     // Output contains zero, undefined is converted to zero for truncating
     // conversions.
     DeoptimizeIfNotRoot(input, Heap::kUndefinedValueRootIndex, instr,
                         "not a heap number/undefined/true/false");
   } else {
     Register output = ToRegister32(instr->result());
     DoubleRegister dbl_scratch2 = ToDoubleRegister(temp2);
  
     DeoptimizeIfNotHeapNumber(input, instr);
  
     // A heap number: load value and convert to int32 using non-truncating
     // function. If the result is out of range, branch to deoptimize.
     __ Ldr(dbl_scratch1, FieldMemOperand(input, HeapNumber::kValueOffset));
     __ TryRepresentDoubleAsInt32(output, dbl_scratch1, dbl_scratch2);
     DeoptimizeIf(ne, instr, "lost precision or NaN");
  
     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
       __ Cmp(output, 0);
       __ B(ne, &done);
       __ Fmov(scratch1, dbl_scratch1);
       DeoptimizeIfNegative(scratch1, instr, "minus zero");
     }
   }
   __ Bind(&done);
 }

References __, v8::internal::B, DeoptimizeIf(), DeoptimizeIfNegative(), DeoptimizeIfNotHeapNumber(), DeoptimizeIfNotRoot(), double_scratch(), v8::internal::eq, v8::internal::FieldMemOperand(), v8::internal::HValue::kBailoutOnMinusZero, v8::internal::HeapNumber::kValueOffset, v8::internal::ne, scratch1(), ToDoubleRegister(), ToRegister(), ToRegister32(), and v8::internal::ZFlag.

Here is the call graph for this function:

◆ DoGap() [1/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

Definition at line 1088 of file lithium-codegen-arm.cc.

                               {
   for (int i = LGap::FIRST_INNER_POSITION;
        i <= LGap::LAST_INNER_POSITION;
        i++) {
     LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
     LParallelMove* move = gap->GetParallelMove(inner_pos);
     if (move != NULL) DoParallelMove(move);
   }
 }

References DoParallelMove(), v8::internal::LGap::FIRST_INNER_POSITION, v8::internal::LGap::GetParallelMove(), v8::internal::LGap::LAST_INNER_POSITION, and NULL.

Here is the call graph for this function:

◆ DoGap() [2/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

private

◆ DoGap() [3/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

◆ DoGap() [4/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

◆ DoGap() [5/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

◆ DoGap() [6/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

◆ DoGap() [7/7]

void v8::internal::LCodeGen::DoGap ( LGap * instr )

◆ DoLoadKeyedExternalArray() [1/6]

void v8::internal::LCodeGen::DoLoadKeyedExternalArray ( LLoadKeyed * instr )

private

Definition at line 3214 of file lithium-codegen-arm.cc.

                                                          {
   Register external_pointer = ToRegister(instr->elements());
   Register key = no_reg;
   ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
       ? (element_size_shift - kSmiTagSize) : element_size_shift;
   int base_offset = instr->base_offset();
  
   if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
       elements_kind == FLOAT32_ELEMENTS ||
       elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
       elements_kind == FLOAT64_ELEMENTS) {
     int base_offset = instr->base_offset();
     DwVfpRegister result = ToDoubleRegister(instr->result());
     Operand operand = key_is_constant
         ? Operand(constant_key << element_size_shift)
         : Operand(key, LSL, shift_size);
     __ add(scratch0(), external_pointer, operand);
     if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
         elements_kind == FLOAT32_ELEMENTS) {
       __ vldr(double_scratch0().low(), scratch0(), base_offset);
       __ vcvt_f64_f32(result, double_scratch0().low());
     } else  {  // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
       __ vldr(result, scratch0(), base_offset);
     }
   } else {
     Register result = ToRegister(instr->result());
     MemOperand mem_operand = PrepareKeyedOperand(
         key, external_pointer, key_is_constant, constant_key,
         element_size_shift, shift_size, base_offset);
     switch (elements_kind) {
       case EXTERNAL_INT8_ELEMENTS:
       case INT8_ELEMENTS:
         __ ldrsb(result, mem_operand);
         break;
       case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
       case EXTERNAL_UINT8_ELEMENTS:
       case UINT8_ELEMENTS:
       case UINT8_CLAMPED_ELEMENTS:
         __ ldrb(result, mem_operand);
         break;
       case EXTERNAL_INT16_ELEMENTS:
       case INT16_ELEMENTS:
         __ ldrsh(result, mem_operand);
         break;
       case EXTERNAL_UINT16_ELEMENTS:
       case UINT16_ELEMENTS:
         __ ldrh(result, mem_operand);
         break;
       case EXTERNAL_INT32_ELEMENTS:
       case INT32_ELEMENTS:
         __ ldr(result, mem_operand);
         break;
       case EXTERNAL_UINT32_ELEMENTS:
       case UINT32_ELEMENTS:
         __ ldr(result, mem_operand);
         if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
           __ cmp(result, Operand(0x80000000));
           DeoptimizeIf(cs, instr, "negative value");
         }
         break;
       case FLOAT32_ELEMENTS:
       case FLOAT64_ELEMENTS:
       case EXTERNAL_FLOAT32_ELEMENTS:
       case EXTERNAL_FLOAT64_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_SMI_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case SLOPPY_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
   }
 }

Here is the call graph for this function:

◆ DoLoadKeyedExternalArray() [2/6]

void v8::internal::LCodeGen::DoLoadKeyedExternalArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedExternalArray() [3/6]

void v8::internal::LCodeGen::DoLoadKeyedExternalArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedExternalArray() [4/6]

void v8::internal::LCodeGen::DoLoadKeyedExternalArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedExternalArray() [5/6]

void v8::internal::LCodeGen::DoLoadKeyedExternalArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedExternalArray() [6/6]

void v8::internal::LCodeGen::DoLoadKeyedExternalArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedArray() [1/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedArray ( LLoadKeyed * instr )

private

Definition at line 3341 of file lithium-codegen-arm.cc.

                                                       {
   Register elements = ToRegister(instr->elements());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
   Register store_base = scratch;
   int offset = instr->base_offset();
  
   if (instr->key()->IsConstantOperand()) {
     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
     offset += ToInteger32(const_operand) * kPointerSize;
     store_base = elements;
   } else {
     Register key = ToRegister(instr->key());
     // Even though the HLoadKeyed instruction forces the input
     // representation for the key to be an integer, the input gets replaced
     // during bound check elimination with the index argument to the bounds
     // check, which can be tagged, so that case must be handled here, too.
     if (instr->hydrogen()->key()->representation().IsSmi()) {
       __ add(scratch, elements, Operand::PointerOffsetFromSmiKey(key));
     } else {
       __ add(scratch, elements, Operand(key, LSL, kPointerSizeLog2));
     }
   }
   __ ldr(result, MemOperand(store_base, offset));
  
   // Check for the hole value.
   if (instr->hydrogen()->RequiresHoleCheck()) {
     if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) {
       __ SmiTst(result);
       DeoptimizeIf(ne, instr, "not a Smi");
     } else {
       __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
       __ cmp(result, scratch);
       DeoptimizeIf(eq, instr, "hole");
     }
   }
 }

References __, v8::internal::LLoadKeyed< T >::base_offset(), DeoptimizeIf(), v8::internal::LLoadKeyed< T >::elements(), v8::internal::LLoadKeyed< T >::elements_kind(), v8::internal::eq, v8::internal::IsFastSmiElementsKind(), v8::internal::LLoadKeyed< T >::key(), v8::internal::kPointerSize, v8::internal::kPointerSizeLog2, v8::internal::LSL, v8::internal::ne, v8::internal::LTemplateResultInstruction< R >::result(), scratch0(), ToInteger32(), and ToRegister().

Here is the call graph for this function:

◆ DoLoadKeyedFixedArray() [2/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedArray() [3/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedArray() [4/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedArray() [5/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedArray() [6/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedDoubleArray() [1/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedDoubleArray ( LLoadKeyed * instr )

private

Definition at line 3305 of file lithium-codegen-arm.cc.

                                                             {
   Register elements = ToRegister(instr->elements());
   bool key_is_constant = instr->key()->IsConstantOperand();
   Register key = no_reg;
   DwVfpRegister result = ToDoubleRegister(instr->result());
   Register scratch = scratch0();
  
   int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
  
   int base_offset = instr->base_offset();
   if (key_is_constant) {
     int constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
     base_offset += constant_key * kDoubleSize;
   }
   __ add(scratch, elements, Operand(base_offset));
  
   if (!key_is_constant) {
     key = ToRegister(instr->key());
     int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
         ? (element_size_shift - kSmiTagSize) : element_size_shift;
     __ add(scratch, scratch, Operand(key, LSL, shift_size));
   }
  
   __ vldr(result, scratch, 0);
  
   if (instr->hydrogen()->RequiresHoleCheck()) {
     __ ldr(scratch, MemOperand(scratch, sizeof(kHoleNanLower32)));
     __ cmp(scratch, Operand(kHoleNanUpper32));
     DeoptimizeIf(eq, instr, "hole");
   }
 }

References __, v8::internal::LLoadKeyed< T >::base_offset(), DeoptimizeIf(), v8::internal::LLoadKeyed< T >::elements(), v8::internal::ElementsKindToShiftSize(), v8::internal::eq, v8::internal::FAST_DOUBLE_ELEMENTS, v8::internal::kDoubleSize, v8::internal::LLoadKeyed< T >::key(), v8::internal::kHoleNanLower32, v8::internal::kHoleNanUpper32, v8::internal::kSmiTagSize, v8::internal::LSL, v8::internal::no_reg, v8::internal::LTemplateResultInstruction< R >::result(), scratch0(), ToDoubleRegister(), ToInteger32(), and ToRegister().

Here is the call graph for this function:

◆ DoLoadKeyedFixedDoubleArray() [2/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedDoubleArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedDoubleArray() [3/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedDoubleArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedDoubleArray() [4/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedDoubleArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedDoubleArray() [5/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedDoubleArray ( LLoadKeyed * instr )

private

◆ DoLoadKeyedFixedDoubleArray() [6/6]

void v8::internal::LCodeGen::DoLoadKeyedFixedDoubleArray ( LLoadKeyed * instr )

private

◆ DoParallelMove() [1/6]

void v8::internal::LCodeGen::DoParallelMove ( LParallelMove * move )

Definition at line 1083 of file lithium-codegen-arm.cc.

                                                  {
   resolver_.Resolve(move);
 }

References resolver_.

Referenced by DoGap().

Here is the caller graph for this function:

◆ DoParallelMove() [2/6]

void v8::internal::LCodeGen::DoParallelMove ( LParallelMove * move )

◆ DoParallelMove() [3/6]

void v8::internal::LCodeGen::DoParallelMove ( LParallelMove * move )

◆ DoParallelMove() [4/6]

void v8::internal::LCodeGen::DoParallelMove ( LParallelMove * move )

◆ DoParallelMove() [5/6]

void v8::internal::LCodeGen::DoParallelMove ( LParallelMove * move )

◆ DoParallelMove() [6/6]

void v8::internal::LCodeGen::DoParallelMove ( LParallelMove * move )

◆ DoStoreKeyedExternalArray() [1/6]

void v8::internal::LCodeGen::DoStoreKeyedExternalArray ( LStoreKeyed * instr )

private

Definition at line 4266 of file lithium-codegen-arm.cc.

                                                            {
   Register external_pointer = ToRegister(instr->elements());
   Register key = no_reg;
   ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
       ? (element_size_shift - kSmiTagSize) : element_size_shift;
   int base_offset = instr->base_offset();
  
   if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
       elements_kind == FLOAT32_ELEMENTS ||
       elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
       elements_kind == FLOAT64_ELEMENTS) {
     Register address = scratch0();
     DwVfpRegister value(ToDoubleRegister(instr->value()));
     if (key_is_constant) {
       if (constant_key != 0) {
         __ add(address, external_pointer,
                Operand(constant_key << element_size_shift));
       } else {
         address = external_pointer;
       }
     } else {
       __ add(address, external_pointer, Operand(key, LSL, shift_size));
     }
     if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
         elements_kind == FLOAT32_ELEMENTS) {
       __ vcvt_f32_f64(double_scratch0().low(), value);
       __ vstr(double_scratch0().low(), address, base_offset);
     } else {  // Storing doubles, not floats.
       __ vstr(value, address, base_offset);
     }
   } else {
     Register value(ToRegister(instr->value()));
     MemOperand mem_operand = PrepareKeyedOperand(
         key, external_pointer, key_is_constant, constant_key,
         element_size_shift, shift_size,
         base_offset);
     switch (elements_kind) {
       case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
       case EXTERNAL_INT8_ELEMENTS:
       case EXTERNAL_UINT8_ELEMENTS:
       case UINT8_ELEMENTS:
       case UINT8_CLAMPED_ELEMENTS:
       case INT8_ELEMENTS:
         __ strb(value, mem_operand);
         break;
       case EXTERNAL_INT16_ELEMENTS:
       case EXTERNAL_UINT16_ELEMENTS:
       case INT16_ELEMENTS:
       case UINT16_ELEMENTS:
         __ strh(value, mem_operand);
         break;
       case EXTERNAL_INT32_ELEMENTS:
       case EXTERNAL_UINT32_ELEMENTS:
       case INT32_ELEMENTS:
       case UINT32_ELEMENTS:
         __ str(value, mem_operand);
         break;
       case FLOAT32_ELEMENTS:
       case FLOAT64_ELEMENTS:
       case EXTERNAL_FLOAT32_ELEMENTS:
       case EXTERNAL_FLOAT64_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_SMI_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case SLOPPY_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
   }
 }

Here is the call graph for this function:

◆ DoStoreKeyedExternalArray() [2/6]

void v8::internal::LCodeGen::DoStoreKeyedExternalArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedExternalArray() [3/6]

void v8::internal::LCodeGen::DoStoreKeyedExternalArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedExternalArray() [4/6]

void v8::internal::LCodeGen::DoStoreKeyedExternalArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedExternalArray() [5/6]

void v8::internal::LCodeGen::DoStoreKeyedExternalArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedExternalArray() [6/6]

void v8::internal::LCodeGen::DoStoreKeyedExternalArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedArray() [1/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedArray ( LStoreKeyed * instr )

private

Definition at line 4395 of file lithium-codegen-arm.cc.

                                                         {
   Register value = ToRegister(instr->value());
   Register elements = ToRegister(instr->elements());
   Register key = instr->key()->IsRegister() ? ToRegister(instr->key())
       : no_reg;
   Register scratch = scratch0();
   Register store_base = scratch;
   int offset = instr->base_offset();
  
   // Do the store.
   if (instr->key()->IsConstantOperand()) {
     DCHECK(!instr->hydrogen()->NeedsWriteBarrier());
     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
     offset += ToInteger32(const_operand) * kPointerSize;
     store_base = elements;
   } else {
     // Even though the HLoadKeyed instruction forces the input
     // representation for the key to be an integer, the input gets replaced
     // during bound check elimination with the index argument to the bounds
     // check, which can be tagged, so that case must be handled here, too.
     if (instr->hydrogen()->key()->representation().IsSmi()) {
       __ add(scratch, elements, Operand::PointerOffsetFromSmiKey(key));
     } else {
       __ add(scratch, elements, Operand(key, LSL, kPointerSizeLog2));
     }
   }
   __ str(value, MemOperand(store_base, offset));
  
   if (instr->hydrogen()->NeedsWriteBarrier()) {
     SmiCheck check_needed =
         instr->hydrogen()->value()->type().IsHeapObject()
             ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
     // Compute address of modified element and store it into key register.
     __ add(key, store_base, Operand(offset));
     __ RecordWrite(elements,
                    key,
                    value,
                    GetLinkRegisterState(),
                    kSaveFPRegs,
                    EMIT_REMEMBERED_SET,
                    check_needed,
                    instr->hydrogen()->PointersToHereCheckForValue());
   }
 }

References __, v8::internal::LStoreKeyed< T >::base_offset(), DCHECK, v8::internal::LStoreKeyed< T >::elements(), v8::internal::EMIT_REMEMBERED_SET, GetLinkRegisterState(), v8::internal::INLINE_SMI_CHECK, v8::internal::LStoreKeyed< T >::key(), v8::internal::kPointerSize, v8::internal::kPointerSizeLog2, v8::internal::kSaveFPRegs, v8::internal::LSL, v8::internal::no_reg, v8::internal::OMIT_SMI_CHECK, scratch0(), ToInteger32(), ToRegister(), and v8::internal::LStoreKeyed< T >::value().

Here is the call graph for this function:

◆ DoStoreKeyedFixedArray() [2/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedArray() [3/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedArray() [4/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedArray() [5/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedArray() [6/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedDoubleArray() [1/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedDoubleArray ( LStoreKeyed * instr )

private

Definition at line 4354 of file lithium-codegen-arm.cc.

                                                               {
   DwVfpRegister value = ToDoubleRegister(instr->value());
   Register elements = ToRegister(instr->elements());
   Register scratch = scratch0();
   DwVfpRegister double_scratch = double_scratch0();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int base_offset = instr->base_offset();
  
   // Calculate the effective address of the slot in the array to store the
   // double value.
   int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
   if (key_is_constant) {
     int constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
     __ add(scratch, elements,
            Operand((constant_key << element_size_shift) + base_offset));
   } else {
     int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
         ? (element_size_shift - kSmiTagSize) : element_size_shift;
     __ add(scratch, elements, Operand(base_offset));
     __ add(scratch, scratch,
            Operand(ToRegister(instr->key()), LSL, shift_size));
   }
  
   if (instr->NeedsCanonicalization()) {
     // Force a canonical NaN.
     if (masm()->emit_debug_code()) {
       __ vmrs(ip);
       __ tst(ip, Operand(kVFPDefaultNaNModeControlBit));
       __ Assert(ne, kDefaultNaNModeNotSet);
     }
     __ VFPCanonicalizeNaN(double_scratch, value);
     __ vstr(double_scratch, scratch, 0);
   } else {
     __ vstr(value, scratch, 0);
   }
 }

References __, v8::internal::LStoreKeyed< T >::base_offset(), double_scratch(), double_scratch0(), v8::internal::LStoreKeyed< T >::elements(), v8::internal::ElementsKindToShiftSize(), v8::internal::FAST_DOUBLE_ELEMENTS, v8::internal::ip, v8::internal::LStoreKeyed< T >::key(), v8::internal::kSmiTagSize, v8::internal::kVFPDefaultNaNModeControlBit, v8::internal::LSL, v8::internal::ne, v8::internal::LStoreKeyed< T >::NeedsCanonicalization(), scratch0(), ToDoubleRegister(), ToInteger32(), ToRegister(), and v8::internal::LStoreKeyed< T >::value().

Here is the call graph for this function:

◆ DoStoreKeyedFixedDoubleArray() [2/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedDoubleArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedDoubleArray() [3/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedDoubleArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedDoubleArray() [4/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedDoubleArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedDoubleArray() [5/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedDoubleArray ( LStoreKeyed * instr )

private

◆ DoStoreKeyedFixedDoubleArray() [6/6]

void v8::internal::LCodeGen::DoStoreKeyedFixedDoubleArray ( LStoreKeyed * instr )

private

◆ double_scratch()

DoubleRegister v8::internal::LCodeGen::double_scratch ( )

inlineprivate

Definition at line 120 of file lithium-codegen-arm64.h.

120 { return crankshaft_fp_scratch; }

Referenced by DoDeferredNumberTagU(), DoDeferredTaggedToI(), and DoStoreKeyedFixedDoubleArray().

Here is the caller graph for this function:

◆ double_scratch0() [1/5]

LowDwVfpRegister v8::internal::LCodeGen::double_scratch0 ( )

inlineprivate

Definition at line 152 of file lithium-codegen-arm.h.

152 { return kScratchDoubleReg; }

kScratchDoubleReg

#define kScratchDoubleReg

Definition: assembler-arm.h:425

References kScratchDoubleReg.

Referenced by DoDeferredNumberTagIU(), DoDeferredTaggedToI(), DoLoadKeyedExternalArray(), DoStoreKeyedExternalArray(), DoStoreKeyedFixedDoubleArray(), and EmitNumberUntagD().

Here is the caller graph for this function:

◆ double_scratch0() [2/5]

DoubleRegister v8::internal::LCodeGen::double_scratch0 ( )

inlineprivate

Definition at line 152 of file lithium-codegen-mips.h.

152 { return kLithiumScratchDouble; }

kLithiumScratchDouble

#define kLithiumScratchDouble

Definition: assembler-mips.h:333

References kLithiumScratchDouble.

◆ double_scratch0() [3/5]

DoubleRegister v8::internal::LCodeGen::double_scratch0 ( )

inlineprivate

Definition at line 153 of file lithium-codegen-mips64.h.

153 { return kLithiumScratchDouble; }

References kLithiumScratchDouble.

◆ double_scratch0() [4/5]

XMMRegister v8::internal::LCodeGen::double_scratch0 ( ) const

inlineprivate

Definition at line 133 of file lithium-codegen-ia32.h.

133 { return xmm0; }

v8::internal::xmm0

const XMMRegister xmm0

Definition: assembler-ia32.h:203

References v8::internal::xmm0.

◆ double_scratch0() [5/5]

XMMRegister v8::internal::LCodeGen::double_scratch0 ( ) const

inlineprivate

Definition at line 127 of file lithium-codegen-x64.h.

127 { return xmm0; }

References v8::internal::xmm0.

◆ EmitBranch() [1/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	cc
	)

private

◆ EmitBranch() [2/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	cc
	)

private

◆ EmitBranch() [3/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	cc
	)

private

◆ EmitBranch() [4/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	condition
	)

private

Definition at line 2184 of file lithium-codegen-arm.cc.

                                                               {
   int left_block = instr->TrueDestination(chunk_);
   int right_block = instr->FalseDestination(chunk_);
  
   int next_block = GetNextEmittedBlock();
  
   if (right_block == left_block || condition == al) {
     EmitGoto(left_block);
   } else if (left_block == next_block) {
     __ b(NegateCondition(condition), chunk_->GetAssemblyLabel(right_block));
   } else if (right_block == next_block) {
     __ b(condition, chunk_->GetAssemblyLabel(left_block));
   } else {
     __ b(condition, chunk_->GetAssemblyLabel(left_block));
     __ b(chunk_->GetAssemblyLabel(right_block));
   }
 }

References __, v8::internal::al, EmitGoto(), and v8::internal::NegateCondition().

Here is the call graph for this function:

◆ EmitBranch() [5/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	condition
	)

private

◆ EmitBranch() [6/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	condition,
		Register	src1,
		const Operand &	src2
	)

private

Definition at line 2043 of file lithium-codegen-mips.cc.

                                                {
   int left_block = instr->TrueDestination(chunk_);
   int right_block = instr->FalseDestination(chunk_);
  
   int next_block = GetNextEmittedBlock();
   if (right_block == left_block || condition == al) {
     EmitGoto(left_block);
   } else if (left_block == next_block) {
     __ Branch(chunk_->GetAssemblyLabel(right_block),
               NegateCondition(condition), src1, src2);
   } else if (right_block == next_block) {
     __ Branch(chunk_->GetAssemblyLabel(left_block), condition, src1, src2);
   } else {
     __ Branch(chunk_->GetAssemblyLabel(left_block), condition, src1, src2);
     __ Branch(chunk_->GetAssemblyLabel(right_block));
   }
 }

References __, v8::internal::al, EmitGoto(), and v8::internal::NegateCondition().

Here is the call graph for this function:

◆ EmitBranch() [7/7]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranch	(	InstrType	instr,
		Condition	condition,
		Register	src1,
		const Operand &	src2
	)

private

◆ EmitBranchF() [1/2]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranchF	(	InstrType	instr,
		Condition	condition,
		FPURegister	src1,
		FPURegister	src2
	)

private

Definition at line 2066 of file lithium-codegen-mips.cc.

                                              {
   int right_block = instr->FalseDestination(chunk_);
   int left_block = instr->TrueDestination(chunk_);
  
   int next_block = GetNextEmittedBlock();
   if (right_block == left_block) {
     EmitGoto(left_block);
   } else if (left_block == next_block) {
     __ BranchF(chunk_->GetAssemblyLabel(right_block), NULL,
                NegateCondition(condition), src1, src2);
   } else if (right_block == next_block) {
     __ BranchF(chunk_->GetAssemblyLabel(left_block), NULL,
                condition, src1, src2);
   } else {
     __ BranchF(chunk_->GetAssemblyLabel(left_block), NULL,
                condition, src1, src2);
     __ Branch(chunk_->GetAssemblyLabel(right_block));
   }
 }

References __, EmitGoto(), v8::internal::NegateCondition(), and NULL.

Here is the call graph for this function:

◆ EmitBranchF() [2/2]

template<class InstrType >

void v8::internal::LCodeGen::EmitBranchF	(	InstrType	instr,
		Condition	condition,
		FPURegister	src1,
		FPURegister	src2
	)

private

◆ EmitBranchGeneric()

template<class InstrType >

void v8::internal::LCodeGen::EmitBranchGeneric	(	InstrType	instr,
		const BranchGenerator &	branch
	)

private

Definition at line 1374 of file lithium-codegen-arm64.cc.

                                                                 {
   int left_block = instr->TrueDestination(chunk_);
   int right_block = instr->FalseDestination(chunk_);
  
   int next_block = GetNextEmittedBlock();
  
   if (right_block == left_block) {
     EmitGoto(left_block);
   } else if (left_block == next_block) {
     branch.EmitInverted(chunk_->GetAssemblyLabel(right_block));
   } else {
     branch.Emit(chunk_->GetAssemblyLabel(left_block));
     if (right_block != next_block) {
       __ B(chunk_->GetAssemblyLabel(right_block));
     }
   }
 }

References __, v8::internal::B, and EmitGoto().

Referenced by EmitBranchIfHeapNumber(), EmitBranchIfNonZeroNumber(), EmitBranchIfRoot(), EmitCompareAndBranch(), and EmitTestAndBranch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EmitBranchIfHeapNumber()

template<class InstrType >

void v8::internal::LCodeGen::EmitBranchIfHeapNumber	(	InstrType	instr,
		const Register &	value
	)

private

Definition at line 1434 of file lithium-codegen-arm64.cc.

                                                              {
   BranchIfHeapNumber branch(this, value);
   EmitBranchGeneric(instr, branch);
 }

References EmitBranchGeneric().

Here is the call graph for this function:

◆ EmitBranchIfNonZeroNumber()

template<class InstrType >

void v8::internal::LCodeGen::EmitBranchIfNonZeroNumber	(	InstrType	instr,
		const FPRegister &	value,
		const FPRegister &	scratch
	)

private

Definition at line 1425 of file lithium-codegen-arm64.cc.

                                                                     {
   BranchIfNonZeroNumber branch(this, value, scratch);
   EmitBranchGeneric(instr, branch);
 }

References EmitBranchGeneric().

Here is the call graph for this function:

◆ EmitBranchIfRoot()

template<class InstrType >

void v8::internal::LCodeGen::EmitBranchIfRoot	(	InstrType	instr,
		const Register &	value,
		Heap::RootListIndex	index
	)

private

Definition at line 1442 of file lithium-codegen-arm64.cc.

                                                          {
   BranchIfRoot branch(this, value, index);
   EmitBranchGeneric(instr, branch);
 }

References EmitBranchGeneric().

Here is the call graph for this function:

◆ EmitClassOfTest() [1/6]

void v8::internal::LCodeGen::EmitClassOfTest	(	Label *	if_true,
		Label *	if_false,
		Handle< String >	class_name,
		Register	input,
		Register	temporary,
		Register	scratch
	)

private

◆ EmitClassOfTest() [2/6]

void v8::internal::LCodeGen::EmitClassOfTest	(	Label *	if_true,
		Label *	if_false,
		Handle< String >	class_name,
		Register	input,
		Register	temporary,
		Register	temporary2
	)

private

Definition at line 2680 of file lithium-codegen-arm.cc.

                                                {
   DCHECK(!input.is(temp));
   DCHECK(!input.is(temp2));
   DCHECK(!temp.is(temp2));
  
   __ JumpIfSmi(input, is_false);
  
   if (String::Equals(isolate()->factory()->Function_string(), class_name)) {
     // Assuming the following assertions, we can use the same compares to test
     // for both being a function type and being in the object type range.
     STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
     STATIC_ASSERT(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE ==
                   FIRST_SPEC_OBJECT_TYPE + 1);
     STATIC_ASSERT(LAST_NONCALLABLE_SPEC_OBJECT_TYPE ==
                   LAST_SPEC_OBJECT_TYPE - 1);
     STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
     __ CompareObjectType(input, temp, temp2, FIRST_SPEC_OBJECT_TYPE);
     __ b(lt, is_false);
     __ b(eq, is_true);
     __ cmp(temp2, Operand(LAST_SPEC_OBJECT_TYPE));
     __ b(eq, is_true);
   } else {
     // Faster code path to avoid two compares: subtract lower bound from the
     // actual type and do a signed compare with the width of the type range.
     __ ldr(temp, FieldMemOperand(input, HeapObject::kMapOffset));
     __ ldrb(temp2, FieldMemOperand(temp, Map::kInstanceTypeOffset));
     __ sub(temp2, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
     __ cmp(temp2, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE -
                           FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
     __ b(gt, is_false);
   }
  
   // Now we are in the FIRST-LAST_NONCALLABLE_SPEC_OBJECT_TYPE range.
   // Check if the constructor in the map is a function.
   __ ldr(temp, FieldMemOperand(temp, Map::kConstructorOffset));
  
   // Objects with a non-function constructor have class 'Object'.
   __ CompareObjectType(temp, temp2, temp2, JS_FUNCTION_TYPE);
   if (class_name->IsOneByteEqualTo(STATIC_CHAR_VECTOR("Object"))) {
     __ b(ne, is_true);
   } else {
     __ b(ne, is_false);
   }
  
   // temp now contains the constructor function. Grab the
   // instance class name from there.
   __ ldr(temp, FieldMemOperand(temp, JSFunction::kSharedFunctionInfoOffset));
   __ ldr(temp, FieldMemOperand(temp,
                                SharedFunctionInfo::kInstanceClassNameOffset));
   // The class name we are testing against is internalized since it's a literal.
   // The name in the constructor is internalized because of the way the context
   // is booted.  This routine isn't expected to work for random API-created
   // classes and it doesn't have to because you can't access it with natives
   // syntax.  Since both sides are internalized it is sufficient to use an
   // identity comparison.
   __ cmp(temp, Operand(class_name));
   // End with the answer in flags.
 }

References __, DCHECK, v8::internal::eq, v8::internal::String::Equals(), v8::internal::FieldMemOperand(), v8::internal::FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::FIRST_SPEC_OBJECT_TYPE, v8::internal::gt, v8::internal::Register::is(), v8::internal::JS_FUNCTION_TYPE, v8::internal::Map::kConstructorOffset, v8::internal::SharedFunctionInfo::kInstanceClassNameOffset, v8::internal::Map::kInstanceTypeOffset, v8::internal::HeapObject::kMapOffset, v8::internal::JSFunction::kSharedFunctionInfoOffset, v8::internal::LAST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::LAST_SPEC_OBJECT_TYPE, v8::internal::LAST_TYPE, v8::internal::lt, v8::internal::ne, v8::internal::NUM_OF_CALLABLE_SPEC_OBJECT_TYPES, v8::internal::STATIC_ASSERT(), and STATIC_CHAR_VECTOR.

Here is the call graph for this function:

◆ EmitClassOfTest() [3/6]

void v8::internal::LCodeGen::EmitClassOfTest	(	Label *	if_true,
		Label *	if_false,
		Handle< String >	class_name,
		Register	input,
		Register	temporary,
		Register	temporary2
	)

private

◆ EmitClassOfTest() [4/6]

void v8::internal::LCodeGen::EmitClassOfTest	(	Label *	if_true,
		Label *	if_false,
		Handle< String >	class_name,
		Register	input,
		Register	temporary,
		Register	temporary2
	)

private

◆ EmitClassOfTest() [5/6]

void v8::internal::LCodeGen::EmitClassOfTest	(	Label *	if_true,
		Label *	if_false,
		Handle< String >	class_name,
		Register	input,
		Register	temporary,
		Register	temporary2
	)

private

◆ EmitClassOfTest() [6/6]

void v8::internal::LCodeGen::EmitClassOfTest	(	Label *	if_true,
		Label *	if_false,
		Handle< String >	class_name,
		Register	input,
		Register	temporary,
		Register	temporary2
	)

private

◆ EmitCmpI() [1/2]

void v8::internal::LCodeGen::EmitCmpI	(	LOperand *	left,
		LOperand *	right
	)

private

◆ EmitCmpI() [2/2]

void v8::internal::LCodeGen::EmitCmpI	(	LOperand *	left,
		LOperand *	right
	)

private

◆ EmitCompareAndBranch()

template<class InstrType >

void v8::internal::LCodeGen::EmitCompareAndBranch	(	InstrType	instr,
		Condition	condition,
		const Register &	lhs,
		const Operand &	rhs
	)

private

Definition at line 1403 of file lithium-codegen-arm64.cc.

                                                         {
   DCHECK((condition != al) && (condition != nv));
   CompareAndBranch branch(this, condition, lhs, rhs);
   EmitBranchGeneric(instr, branch);
 }

References v8::internal::al, DCHECK, EmitBranchGeneric(), and v8::internal::nv.

Here is the call graph for this function:

◆ EmitDeepCopy() [1/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitDeepCopy() [2/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitDeepCopy() [3/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitDeepCopy() [4/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitDeepCopy() [5/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitDeepCopy() [6/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitDeepCopy() [7/7]

void v8::internal::LCodeGen::EmitDeepCopy	(	Handle< JSObject >	object,
		Register	result,
		Register	source,
		Register	scratch,
		int *	offset,
		AllocationSiteMode	mode
	)

private

◆ EmitFalseBranch() [1/6]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranch	(	InstrType	instr,
		Condition	cc
	)

private

◆ EmitFalseBranch() [2/6]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranch	(	InstrType	instr,
		Condition	cc
	)

private

◆ EmitFalseBranch() [3/6]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranch	(	InstrType	instr,
		Condition	cc
	)

private

◆ EmitFalseBranch() [4/6]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranch	(	InstrType	instr,
		Condition	condition
	)

private

Definition at line 2204 of file lithium-codegen-arm.cc.

                                                                    {
   int false_block = instr->FalseDestination(chunk_);
   __ b(condition, chunk_->GetAssemblyLabel(false_block));
 }

References __.

◆ EmitFalseBranch() [5/6]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranch	(	InstrType	instr,
		Condition	condition,
		Register	src1,
		const Operand &	src2
	)

private

Definition at line 2091 of file lithium-codegen-mips.cc.

                                                     {
   int false_block = instr->FalseDestination(chunk_);
   __ Branch(chunk_->GetAssemblyLabel(false_block), condition, src1, src2);
 }

References __.

◆ EmitFalseBranch() [6/6]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranch	(	InstrType	instr,
		Condition	condition,
		Register	src1,
		const Operand &	src2
	)

private

◆ EmitFalseBranchF() [1/2]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranchF	(	InstrType	instr,
		Condition	condition,
		FPURegister	src1,
		FPURegister	src2
	)

private

Definition at line 2101 of file lithium-codegen-mips.cc.

                                                   {
   int false_block = instr->FalseDestination(chunk_);
   __ BranchF(chunk_->GetAssemblyLabel(false_block), NULL,
              condition, src1, src2);
 }

References __, and NULL.

◆ EmitFalseBranchF() [2/2]

template<class InstrType >

void v8::internal::LCodeGen::EmitFalseBranchF	(	InstrType	instr,
		Condition	condition,
		FPURegister	src1,
		FPURegister	src2
	)

private

◆ EmitFlushX87ForDeopt()

void v8::internal::LCodeGen::EmitFlushX87ForDeopt ( )

private

◆ EmitGoto() [1/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

Definition at line 2351 of file lithium-codegen-arm.cc.

                                  {
   if (!IsNextEmittedBlock(block)) {
     __ jmp(chunk_->GetAssemblyLabel(LookupDestination(block)));
   }
 }

References __, IsNextEmittedBlock(), and LookupDestination().

Referenced by EmitBranch(), EmitBranchF(), and EmitBranchGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EmitGoto() [2/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

◆ EmitGoto() [3/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

◆ EmitGoto() [4/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

◆ EmitGoto() [5/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

◆ EmitGoto() [6/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

◆ EmitGoto() [7/7]

void v8::internal::LCodeGen::EmitGoto ( int block )

private

◆ EmitIntegerMathAbs() [1/6]

void v8::internal::LCodeGen::EmitIntegerMathAbs ( LMathAbs * instr )

private

Definition at line 3741 of file lithium-codegen-arm.cc.

                                                  {
   Register input = ToRegister(instr->value());
   Register result = ToRegister(instr->result());
   __ cmp(input, Operand::Zero());
   __ Move(result, input, pl);
   // We can make rsb conditional because the previous cmp instruction
   // will clear the V (overflow) flag and rsb won't set this flag
   // if input is positive.
   __ rsb(result, input, Operand::Zero(), SetCC, mi);
   // Deoptimize on overflow.
   DeoptimizeIf(vs, instr, "overflow");
 }

References __, DeoptimizeIf(), v8::internal::mi, v8::internal::pl, v8::internal::SetCC, ToRegister(), and v8::internal::vs.

Here is the call graph for this function:

◆ EmitIntegerMathAbs() [2/6]

void v8::internal::LCodeGen::EmitIntegerMathAbs ( LMathAbs * instr )

private

◆ EmitIntegerMathAbs() [3/6]

void v8::internal::LCodeGen::EmitIntegerMathAbs ( LMathAbs * instr )

private

◆ EmitIntegerMathAbs() [4/6]

void v8::internal::LCodeGen::EmitIntegerMathAbs ( LMathAbs * instr )

private

◆ EmitIntegerMathAbs() [5/6]

void v8::internal::LCodeGen::EmitIntegerMathAbs ( LMathAbs * instr )

private

◆ EmitIntegerMathAbs() [6/6]

void v8::internal::LCodeGen::EmitIntegerMathAbs ( LMathAbs * instr )

private

◆ EmitIsConstructCall() [1/6]

void v8::internal::LCodeGen::EmitIsConstructCall ( Register temp )

private

◆ EmitIsConstructCall() [2/6]

void v8::internal::LCodeGen::EmitIsConstructCall ( Register temp )

private

◆ EmitIsConstructCall() [3/6]

void v8::internal::LCodeGen::EmitIsConstructCall ( Register temp )

private

◆ EmitIsConstructCall() [4/6]

void v8::internal::LCodeGen::EmitIsConstructCall	(	Register	temp1,
		Register	temp2
	)

private

Definition at line 5607 of file lithium-codegen-arm.cc.

                                                                  {
   DCHECK(!temp1.is(temp2));
   // Get the frame pointer for the calling frame.
   __ ldr(temp1, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
  
   // Skip the arguments adaptor frame if it exists.
   __ ldr(temp2, MemOperand(temp1, StandardFrameConstants::kContextOffset));
   __ cmp(temp2, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
   __ ldr(temp1, MemOperand(temp1, StandardFrameConstants::kCallerFPOffset), eq);
  
   // Check the marker in the calling frame.
   __ ldr(temp1, MemOperand(temp1, StandardFrameConstants::kMarkerOffset));
   __ cmp(temp1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
 }

References __, v8::internal::compiler::ARGUMENTS_ADAPTOR, DCHECK, v8::internal::eq, v8::internal::fp, v8::internal::Smi::FromInt(), v8::internal::Register::is(), v8::internal::StandardFrameConstants::kCallerFPOffset, v8::internal::StandardFrameConstants::kContextOffset, and v8::internal::StandardFrameConstants::kMarkerOffset.

Here is the call graph for this function:

◆ EmitIsConstructCall() [5/6]

void v8::internal::LCodeGen::EmitIsConstructCall	(	Register	temp1,
		Register	temp2
	)

private

◆ EmitIsConstructCall() [6/6]

void v8::internal::LCodeGen::EmitIsConstructCall	(	Register	temp1,
		Register	temp2
	)

private

◆ EmitIsObject() [1/6]

Condition v8::internal::LCodeGen::EmitIsObject	(	Register	input,
		Label *	is_not_object,
		Label *	is_object
	)

private

◆ EmitIsObject() [2/6]

Condition v8::internal::LCodeGen::EmitIsObject	(	Register	input,
		Register	temp1,
		Label *	is_not_object,
		Label *	is_object
	)

private

Definition at line 2500 of file lithium-codegen-arm.cc.

                                                    {
   Register temp2 = scratch0();
   __ JumpIfSmi(input, is_not_object);
  
   __ LoadRoot(temp2, Heap::kNullValueRootIndex);
   __ cmp(input, temp2);
   __ b(eq, is_object);
  
   // Load map.
   __ ldr(temp1, FieldMemOperand(input, HeapObject::kMapOffset));
   // Undetectable objects behave like undefined.
   __ ldrb(temp2, FieldMemOperand(temp1, Map::kBitFieldOffset));
   __ tst(temp2, Operand(1 << Map::kIsUndetectable));
   __ b(ne, is_not_object);
  
   // Load instance type and check that it is in object type range.
   __ ldrb(temp2, FieldMemOperand(temp1, Map::kInstanceTypeOffset));
   __ cmp(temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
   __ b(lt, is_not_object);
   __ cmp(temp2, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
   return le;
 }

References __, v8::internal::eq, v8::internal::FieldMemOperand(), v8::internal::FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::Map::kBitFieldOffset, v8::internal::Map::kInstanceTypeOffset, v8::internal::Map::kIsUndetectable, v8::internal::HeapObject::kMapOffset, v8::internal::LAST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::le, v8::internal::lt, v8::internal::ne, and scratch0().

Here is the call graph for this function:

◆ EmitIsObject() [3/6]

Condition v8::internal::LCodeGen::EmitIsObject	(	Register	input,
		Register	temp1,
		Label *	is_not_object,
		Label *	is_object
	)

private

◆ EmitIsObject() [4/6]

Condition v8::internal::LCodeGen::EmitIsObject	(	Register	input,
		Register	temp1,
		Label *	is_not_object,
		Label *	is_object
	)

private

◆ EmitIsObject() [5/6]

Condition v8::internal::LCodeGen::EmitIsObject	(	Register	input,
		Register	temp1,
		Register	temp2,
		Label *	is_not_object,
		Label *	is_object
	)

private

Definition at line 2403 of file lithium-codegen-mips.cc.

                                                    {
   __ JumpIfSmi(input, is_not_object);
  
   __ LoadRoot(temp2, Heap::kNullValueRootIndex);
   __ Branch(is_object, eq, input, Operand(temp2));
  
   // Load map.
   __ lw(temp1, FieldMemOperand(input, HeapObject::kMapOffset));
   // Undetectable objects behave like undefined.
   __ lbu(temp2, FieldMemOperand(temp1, Map::kBitFieldOffset));
   __ And(temp2, temp2, Operand(1 << Map::kIsUndetectable));
   __ Branch(is_not_object, ne, temp2, Operand(zero_reg));
  
   // Load instance type and check that it is in object type range.
   __ lbu(temp2, FieldMemOperand(temp1, Map::kInstanceTypeOffset));
   __ Branch(is_not_object,
             lt, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
  
   return le;
 }

References __, v8::internal::eq, v8::internal::FieldMemOperand(), v8::internal::FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::Map::kBitFieldOffset, v8::internal::Map::kInstanceTypeOffset, v8::internal::Map::kIsUndetectable, v8::internal::HeapObject::kMapOffset, v8::internal::le, v8::internal::lt, and v8::internal::ne.

Here is the call graph for this function:

◆ EmitIsObject() [6/6]

Condition v8::internal::LCodeGen::EmitIsObject	(	Register	input,
		Register	temp1,
		Register	temp2,
		Label *	is_not_object,
		Label *	is_object
	)

private

◆ EmitIsString() [1/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed = `INLINE_SMI_CHECK`
	)

private

Definition at line 2539 of file lithium-codegen-arm.cc.

                                                                            {
   if (check_needed == INLINE_SMI_CHECK) {
     __ JumpIfSmi(input, is_not_string);
   }
   __ CompareObjectType(input, temp1, temp1, FIRST_NONSTRING_TYPE);
  
   return lt;
 }

References __, v8::internal::FIRST_NONSTRING_TYPE, v8::internal::INLINE_SMI_CHECK, and v8::internal::lt.

◆ EmitIsString() [2/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed
	)

private

◆ EmitIsString() [3/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed
	)

private

◆ EmitIsString() [4/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed
	)

private

◆ EmitIsString() [5/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed
	)

private

◆ EmitIsString() [6/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed
	)

private

◆ EmitIsString() [7/7]

Condition v8::internal::LCodeGen::EmitIsString	(	Register	input,
		Register	temp1,
		Label *	is_not_string,
		SmiCheck	check_needed
	)

private

◆ EmitLoadDoubleRegister() [1/3]

DoubleRegister v8::internal::LCodeGen::EmitLoadDoubleRegister	(	LOperand *	op,
		FloatRegister	flt_scratch,
		DoubleRegister	dbl_scratch
	)

Definition at line 464 of file lithium-codegen-mips.cc.

                                                                             {
   if (op->IsDoubleRegister()) {
     return ToDoubleRegister(op->index());
   } else if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk_->LookupConstant(const_op);
     Handle<Object> literal = constant->handle(isolate());
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsInteger32()) {
       DCHECK(literal->IsNumber());
       __ li(at, Operand(static_cast<int32_t>(literal->Number())));
       __ mtc1(at, flt_scratch);
       __ cvt_d_w(dbl_scratch, flt_scratch);
       return dbl_scratch;
     } else if (r.IsDouble()) {
       Abort(kUnsupportedDoubleImmediate);
     } else if (r.IsTagged()) {
       Abort(kUnsupportedTaggedImmediate);
     }
   } else if (op->IsStackSlot()) {
     MemOperand mem_op = ToMemOperand(op);
     __ ldc1(dbl_scratch, mem_op);
     return dbl_scratch;
   }
   UNREACHABLE();
   return dbl_scratch;
 }

References __, DCHECK, v8::internal::LOperand::index(), v8::internal::Representation::IsDouble(), v8::internal::Representation::IsInteger32(), v8::internal::Representation::IsTagged(), ToDoubleRegister(), ToMemOperand(), and UNREACHABLE.

Here is the call graph for this function:

◆ EmitLoadDoubleRegister() [2/3]

DoubleRegister v8::internal::LCodeGen::EmitLoadDoubleRegister	(	LOperand *	op,
		FloatRegister	flt_scratch,
		DoubleRegister	dbl_scratch
	)

◆ EmitLoadDoubleRegister() [3/3]

DwVfpRegister v8::internal::LCodeGen::EmitLoadDoubleRegister	(	LOperand *	op,
		SwVfpRegister	flt_scratch,
		DwVfpRegister	dbl_scratch
	)

Definition at line 467 of file lithium-codegen-arm.cc.

                                                                           {
   if (op->IsDoubleRegister()) {
     return ToDoubleRegister(op->index());
   } else if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk_->LookupConstant(const_op);
     Handle<Object> literal = constant->handle(isolate());
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsInteger32()) {
       DCHECK(literal->IsNumber());
       __ mov(ip, Operand(static_cast<int32_t>(literal->Number())));
       __ vmov(flt_scratch, ip);
       __ vcvt_f64_s32(dbl_scratch, flt_scratch);
       return dbl_scratch;
     } else if (r.IsDouble()) {
       Abort(kUnsupportedDoubleImmediate);
     } else if (r.IsTagged()) {
       Abort(kUnsupportedTaggedImmediate);
     }
   } else if (op->IsStackSlot()) {
     // TODO(regis): Why is vldr not taking a MemOperand?
     // __ vldr(dbl_scratch, ToMemOperand(op));
     MemOperand mem_op = ToMemOperand(op);
     __ vldr(dbl_scratch, mem_op.rn(), mem_op.offset());
     return dbl_scratch;
   }
   UNREACHABLE();
   return dbl_scratch;
 }

References __, DCHECK, v8::internal::LOperand::index(), v8::internal::ip, v8::internal::Representation::IsDouble(), v8::internal::Representation::IsInteger32(), v8::internal::Representation::IsTagged(), v8::internal::MemOperand::offset(), ToDoubleRegister(), ToMemOperand(), and UNREACHABLE.

Here is the call graph for this function:

◆ EmitLoadRegister() [1/3]

Register v8::internal::LCodeGen::EmitLoadRegister	(	LOperand *	op,
		Register	scratch
	)

Definition at line 434 of file lithium-codegen-arm.cc.

                                                                   {
   if (op->IsRegister()) {
     return ToRegister(op->index());
   } else if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk_->LookupConstant(const_op);
     Handle<Object> literal = constant->handle(isolate());
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsInteger32()) {
       DCHECK(literal->IsNumber());
       __ mov(scratch, Operand(static_cast<int32_t>(literal->Number())));
     } else if (r.IsDouble()) {
       Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);
     } else {
       DCHECK(r.IsSmiOrTagged());
       __ Move(scratch, literal);
     }
     return scratch;
   } else if (op->IsStackSlot()) {
     __ ldr(scratch, ToMemOperand(op));
     return scratch;
   }
   UNREACHABLE();
   return scratch;
 }

References __, DCHECK, v8::internal::LOperand::index(), v8::internal::Representation::IsDouble(), v8::internal::Representation::IsInteger32(), v8::internal::Representation::IsSmiOrTagged(), ToMemOperand(), ToRegister(), and UNREACHABLE.

Here is the call graph for this function:

◆ EmitLoadRegister() [2/3]

Register v8::internal::LCodeGen::EmitLoadRegister	(	LOperand *	op,
		Register	scratch
	)

◆ EmitLoadRegister() [3/3]

Register v8::internal::LCodeGen::EmitLoadRegister	(	LOperand *	op,
		Register	scratch
	)

◆ EmitNumberUntagD() [1/5]

void v8::internal::LCodeGen::EmitNumberUntagD	(	LNumberUntagD *	instr,
		Register	input,
		DoubleRegister	result,
		NumberUntagDMode	mode
	)

private

◆ EmitNumberUntagD() [2/5]

void v8::internal::LCodeGen::EmitNumberUntagD	(	LNumberUntagD *	instr,
		Register	input,
		DoubleRegister	result,
		NumberUntagDMode	mode
	)

private

◆ EmitNumberUntagD() [3/5]

void v8::internal::LCodeGen::EmitNumberUntagD	(	LNumberUntagD *	instr,
		Register	input,
		DwVfpRegister	result,
		NumberUntagDMode	mode
	)

private

Definition at line 4869 of file lithium-codegen-arm.cc.

                                                        {
   bool can_convert_undefined_to_nan =
       instr->hydrogen()->can_convert_undefined_to_nan();
   bool deoptimize_on_minus_zero = instr->hydrogen()->deoptimize_on_minus_zero();
  
   Register scratch = scratch0();
   SwVfpRegister flt_scratch = double_scratch0().low();
   DCHECK(!result_reg.is(double_scratch0()));
   Label convert, load_smi, done;
   if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
     // Smi check.
     __ UntagAndJumpIfSmi(scratch, input_reg, &load_smi);
     // Heap number map check.
     __ ldr(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
     __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
     __ cmp(scratch, Operand(ip));
     if (can_convert_undefined_to_nan) {
       __ b(ne, &convert);
     } else {
       DeoptimizeIf(ne, instr, "not a heap number");
     }
     // load heap number
     __ vldr(result_reg, input_reg, HeapNumber::kValueOffset - kHeapObjectTag);
     if (deoptimize_on_minus_zero) {
       __ VmovLow(scratch, result_reg);
       __ cmp(scratch, Operand::Zero());
       __ b(ne, &done);
       __ VmovHigh(scratch, result_reg);
       __ cmp(scratch, Operand(HeapNumber::kSignMask));
       DeoptimizeIf(eq, instr, "minus zero");
     }
     __ jmp(&done);
     if (can_convert_undefined_to_nan) {
       __ bind(&convert);
       // Convert undefined (and hole) to NaN.
       __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
       __ cmp(input_reg, Operand(ip));
       DeoptimizeIf(ne, instr, "not a heap number/undefined");
       __ LoadRoot(scratch, Heap::kNanValueRootIndex);
       __ vldr(result_reg, scratch, HeapNumber::kValueOffset - kHeapObjectTag);
       __ jmp(&done);
     }
   } else {
     __ SmiUntag(scratch, input_reg);
     DCHECK(mode == NUMBER_CANDIDATE_IS_SMI);
   }
   // Smi to double register conversion
   __ bind(&load_smi);
   // scratch: untagged value of input_reg
   __ vmov(flt_scratch, scratch);
   __ vcvt_f64_s32(result_reg, flt_scratch);
   __ bind(&done);
 }

References __, DCHECK, DeoptimizeIf(), double_scratch0(), v8::internal::eq, v8::internal::FieldMemOperand(), v8::internal::ip, v8::internal::DwVfpRegister::is(), v8::internal::kHeapObjectTag, v8::internal::HeapObject::kMapOffset, v8::internal::HeapNumber::kSignMask, v8::internal::HeapNumber::kValueOffset, v8::internal::LowDwVfpRegister::low(), mode(), v8::internal::ne, v8::internal::NUMBER_CANDIDATE_IS_ANY_TAGGED, v8::internal::NUMBER_CANDIDATE_IS_SMI, and scratch0().

Here is the call graph for this function:

◆ EmitNumberUntagD() [4/5]

void v8::internal::LCodeGen::EmitNumberUntagD	(	LNumberUntagD *	instr,
		Register	input,
		Register	temp,
		XMMRegister	result,
		NumberUntagDMode	mode
	)

private

◆ EmitNumberUntagD() [5/5]

void v8::internal::LCodeGen::EmitNumberUntagD	(	LNumberUntagD *	instr,
		Register	input,
		XMMRegister	result,
		NumberUntagDMode	mode
	)

private

◆ EmitNumberUntagDNoSSE2()

void v8::internal::LCodeGen::EmitNumberUntagDNoSSE2	(	LNumberUntagD *	instr,
		Register	input,
		Register	temp,
		X87Register	res_reg,
		NumberUntagDMode	mode
	)

private

◆ EmitPushTaggedOperand() [1/3]

void v8::internal::LCodeGen::EmitPushTaggedOperand ( LOperand * operand )

private

◆ EmitPushTaggedOperand() [2/3]

void v8::internal::LCodeGen::EmitPushTaggedOperand ( LOperand * operand )

private

◆ EmitPushTaggedOperand() [3/3]

void v8::internal::LCodeGen::EmitPushTaggedOperand ( LOperand * operand )

private

◆ EmitReturn() [1/2]

void v8::internal::LCodeGen::EmitReturn	(	LReturn *	instr,
		bool	dynamic_frame_alignment
	)

private

◆ EmitReturn() [2/2]

void v8::internal::LCodeGen::EmitReturn	(	LReturn *	instr,
		bool	dynamic_frame_alignment
	)

private

◆ EmitSignedIntegerDivisionByConstant() [1/2]

void v8::internal::LCodeGen::EmitSignedIntegerDivisionByConstant	(	Register	result,
		Register	dividend,
		int32_t	divisor,
		Register	remainder,
		Register	scratch,
		LEnvironment *	environment
	)

private

◆ EmitSignedIntegerDivisionByConstant() [2/2]

void v8::internal::LCodeGen::EmitSignedIntegerDivisionByConstant	(	Register	result,
		Register	dividend,
		int32_t	divisor,
		Register	remainder,
		Register	scratch,
		LEnvironment *	environment
	)

private

◆ EmitSmiMathAbs()

void v8::internal::LCodeGen::EmitSmiMathAbs ( LMathAbs * instr )

private

◆ EmitTestAndBranch()

template<class InstrType >

void v8::internal::LCodeGen::EmitTestAndBranch	(	InstrType	instr,
		Condition	condition,
		const Register &	value,
		uint64_t	mask
	)

private

Definition at line 1414 of file lithium-codegen-arm64.cc.

                                                 {
   DCHECK((condition != al) && (condition != nv));
   TestAndBranch branch(this, condition, value, mask);
   EmitBranchGeneric(instr, branch);
 }

References v8::internal::al, DCHECK, EmitBranchGeneric(), and v8::internal::nv.

Here is the call graph for this function:

◆ EmitTypeofIs() [1/6]

Condition v8::internal::LCodeGen::EmitTypeofIs	(	Label *	true_label,
		Label *	false_label,
		Register	input,
		Handle< String >	type_name
	)

private

Definition at line 5525 of file lithium-codegen-arm.cc.

                                                            {
   Condition final_branch_condition = kNoCondition;
   Register scratch = scratch0();
   Factory* factory = isolate()->factory();
   if (String::Equals(type_name, factory->number_string())) {
     __ JumpIfSmi(input, true_label);
     __ ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
     __ CompareRoot(scratch, Heap::kHeapNumberMapRootIndex);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->string_string())) {
     __ JumpIfSmi(input, false_label);
     __ CompareObjectType(input, scratch, no_reg, FIRST_NONSTRING_TYPE);
     __ b(ge, false_label);
     __ ldrb(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
     __ tst(scratch, Operand(1 << Map::kIsUndetectable));
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->symbol_string())) {
     __ JumpIfSmi(input, false_label);
     __ CompareObjectType(input, scratch, no_reg, SYMBOL_TYPE);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->boolean_string())) {
     __ CompareRoot(input, Heap::kTrueValueRootIndex);
     __ b(eq, true_label);
     __ CompareRoot(input, Heap::kFalseValueRootIndex);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->undefined_string())) {
     __ CompareRoot(input, Heap::kUndefinedValueRootIndex);
     __ b(eq, true_label);
     __ JumpIfSmi(input, false_label);
     // Check for undetectable objects => true.
     __ ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
     __ ldrb(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
     __ tst(scratch, Operand(1 << Map::kIsUndetectable));
     final_branch_condition = ne;
  
   } else if (String::Equals(type_name, factory->function_string())) {
     STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
     Register type_reg = scratch;
     __ JumpIfSmi(input, false_label);
     __ CompareObjectType(input, scratch, type_reg, JS_FUNCTION_TYPE);
     __ b(eq, true_label);
     __ cmp(type_reg, Operand(JS_FUNCTION_PROXY_TYPE));
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->object_string())) {
     Register map = scratch;
     __ JumpIfSmi(input, false_label);
     __ CompareRoot(input, Heap::kNullValueRootIndex);
     __ b(eq, true_label);
     __ CheckObjectTypeRange(input,
                             map,
                             FIRST_NONCALLABLE_SPEC_OBJECT_TYPE,
                             LAST_NONCALLABLE_SPEC_OBJECT_TYPE,
                             false_label);
     // Check for undetectable objects => false.
     __ ldrb(scratch, FieldMemOperand(map, Map::kBitFieldOffset));
     __ tst(scratch, Operand(1 << Map::kIsUndetectable));
     final_branch_condition = eq;
  
   } else {
     __ b(false_label);
   }
  
   return final_branch_condition;
 }

References __, v8::internal::eq, v8::internal::String::Equals(), v8::internal::FieldMemOperand(), v8::internal::FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::FIRST_NONSTRING_TYPE, v8::internal::ge, v8::internal::JS_FUNCTION_PROXY_TYPE, v8::internal::JS_FUNCTION_TYPE, v8::internal::Map::kBitFieldOffset, v8::internal::Map::kIsUndetectable, v8::internal::HeapObject::kMapOffset, v8::internal::kNoCondition, v8::internal::LAST_NONCALLABLE_SPEC_OBJECT_TYPE, map, v8::internal::ne, v8::internal::no_reg, v8::internal::NUM_OF_CALLABLE_SPEC_OBJECT_TYPES, scratch0(), v8::internal::STATIC_ASSERT(), and v8::internal::SYMBOL_TYPE.

Here is the call graph for this function:

◆ EmitTypeofIs() [2/6]

Condition v8::internal::LCodeGen::EmitTypeofIs	(	Label *	true_label,
		Label *	false_label,
		Register	input,
		Handle< String >	type_name,
		Register *	cmp1,
		Operand *	cmp2
	)

private

Definition at line 5523 of file lithium-codegen-mips.cc.

                                                 {
   // This function utilizes the delay slot heavily. This is used to load
   // values that are always usable without depending on the type of the input
   // register.
   Condition final_branch_condition = kNoCondition;
   Register scratch = scratch0();
   Factory* factory = isolate()->factory();
   if (String::Equals(type_name, factory->number_string())) {
     __ JumpIfSmi(input, true_label);
     __ lw(input, FieldMemOperand(input, HeapObject::kMapOffset));
     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
     *cmp1 = input;
     *cmp2 = Operand(at);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->string_string())) {
     __ JumpIfSmi(input, false_label);
     __ GetObjectType(input, input, scratch);
     __ Branch(USE_DELAY_SLOT, false_label,
               ge, scratch, Operand(FIRST_NONSTRING_TYPE));
     // input is an object so we can load the BitFieldOffset even if we take the
     // other branch.
     __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
     __ And(at, at, 1 << Map::kIsUndetectable);
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->symbol_string())) {
     __ JumpIfSmi(input, false_label);
     __ GetObjectType(input, input, scratch);
     *cmp1 = scratch;
     *cmp2 = Operand(SYMBOL_TYPE);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->boolean_string())) {
     __ LoadRoot(at, Heap::kTrueValueRootIndex);
     __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
     __ LoadRoot(at, Heap::kFalseValueRootIndex);
     *cmp1 = at;
     *cmp2 = Operand(input);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->undefined_string())) {
     __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
     __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
     // The first instruction of JumpIfSmi is an And - it is safe in the delay
     // slot.
     __ JumpIfSmi(input, false_label);
     // Check for undetectable objects => true.
     __ lw(input, FieldMemOperand(input, HeapObject::kMapOffset));
     __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
     __ And(at, at, 1 << Map::kIsUndetectable);
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);
     final_branch_condition = ne;
  
   } else if (String::Equals(type_name, factory->function_string())) {
     STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
     __ JumpIfSmi(input, false_label);
     __ GetObjectType(input, scratch, input);
     __ Branch(true_label, eq, input, Operand(JS_FUNCTION_TYPE));
     *cmp1 = input;
     *cmp2 = Operand(JS_FUNCTION_PROXY_TYPE);
     final_branch_condition = eq;
  
   } else if (String::Equals(type_name, factory->object_string())) {
     __ JumpIfSmi(input, false_label);
     __ LoadRoot(at, Heap::kNullValueRootIndex);
     __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
     Register map = input;
     __ GetObjectType(input, map, scratch);
     __ Branch(false_label,
               lt, scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
     __ Branch(USE_DELAY_SLOT, false_label,
               gt, scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
     // map is still valid, so the BitField can be loaded in delay slot.
     // Check for undetectable objects => false.
     __ lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
     __ And(at, at, 1 << Map::kIsUndetectable);
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);
     final_branch_condition = eq;
  
   } else {
     *cmp1 = at;
     *cmp2 = Operand(zero_reg);  // Set to valid regs, to avoid caller assertion.
     __ Branch(false_label);
   }
  
   return final_branch_condition;
 }

References __, v8::internal::eq, v8::internal::String::Equals(), v8::internal::FieldMemOperand(), v8::internal::FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::FIRST_NONSTRING_TYPE, v8::internal::ge, v8::internal::gt, v8::internal::JS_FUNCTION_PROXY_TYPE, v8::internal::JS_FUNCTION_TYPE, v8::internal::Map::kBitFieldOffset, v8::internal::Map::kIsUndetectable, v8::internal::HeapObject::kMapOffset, v8::internal::kNoCondition, v8::internal::LAST_NONCALLABLE_SPEC_OBJECT_TYPE, v8::internal::lt, map, v8::internal::ne, v8::internal::NUM_OF_CALLABLE_SPEC_OBJECT_TYPES, scratch0(), v8::internal::STATIC_ASSERT(), v8::internal::SYMBOL_TYPE, and v8::internal::USE_DELAY_SLOT.

Here is the call graph for this function:

◆ EmitTypeofIs() [3/6]

Condition v8::internal::LCodeGen::EmitTypeofIs	(	Label *	true_label,
		Label *	false_label,
		Register	input,
		Handle< String >	type_name,
		Register *	cmp1,
		Operand *	cmp2
	)

private

◆ EmitTypeofIs() [4/6]

Condition v8::internal::LCodeGen::EmitTypeofIs	(	LTypeofIsAndBranch *	instr,
		Register	input
	)

private

◆ EmitTypeofIs() [5/6]

Condition v8::internal::LCodeGen::EmitTypeofIs	(	LTypeofIsAndBranch *	instr,
		Register	input
	)

private

◆ EmitTypeofIs() [6/6]

Condition v8::internal::LCodeGen::EmitTypeofIs	(	LTypeofIsAndBranch *	instr,
		Register	input
	)

private

◆ EmitVectorLoadICRegisters() [1/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

Definition at line 2995 of file lithium-codegen-arm.cc.

                                                  {
   DCHECK(FLAG_vector_ics);
   Register vector = ToRegister(instr->temp_vector());
   DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
   __ Move(vector, instr->hydrogen()->feedback_vector());
   // No need to allocate this register.
   DCHECK(VectorLoadICDescriptor::SlotRegister().is(r0));
   __ mov(VectorLoadICDescriptor::SlotRegister(),
          Operand(Smi::FromInt(instr->hydrogen()->slot())));
 }

References __, DCHECK, v8::internal::Smi::FromInt(), v8::internal::Register::is(), v8::internal::r0, v8::internal::VectorLoadICTrampolineDescriptor::SlotRegister(), ToRegister(), and v8::internal::VectorLoadICDescriptor::VectorRegister().

Here is the call graph for this function:

◆ EmitVectorLoadICRegisters() [2/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

◆ EmitVectorLoadICRegisters() [3/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

◆ EmitVectorLoadICRegisters() [4/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

◆ EmitVectorLoadICRegisters() [5/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

◆ EmitVectorLoadICRegisters() [6/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

◆ EmitVectorLoadICRegisters() [7/7]

template<class T >

void v8::internal::LCodeGen::EmitVectorLoadICRegisters ( T * instr )

private

◆ EnsureRelocSpaceForDeoptimization() [1/2]

void v8::internal::LCodeGen::EnsureRelocSpaceForDeoptimization ( )

◆ EnsureRelocSpaceForDeoptimization() [2/2]

void v8::internal::LCodeGen::EnsureRelocSpaceForDeoptimization ( )

◆ EnsureSpaceForLazyDeopt() [1/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

Definition at line 5623 of file lithium-codegen-arm.cc.

                                                        {
   if (!info()->IsStub()) {
     // Ensure that we have enough space after the previous lazy-bailout
     // instruction for patching the code here.
     int current_pc = masm()->pc_offset();
     if (current_pc < last_lazy_deopt_pc_ + space_needed) {
       // Block literal pool emission for duration of padding.
       Assembler::BlockConstPoolScope block_const_pool(masm());
       int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
       DCHECK_EQ(0, padding_size % Assembler::kInstrSize);
       while (padding_size > 0) {
         __ nop();
         padding_size -= Assembler::kInstrSize;
       }
     }
   }
   last_lazy_deopt_pc_ = masm()->pc_offset();
 }

References __, DCHECK_EQ, and v8::internal::Assembler::kInstrSize.

Referenced by GenerateBodyInstructionPre().

Here is the caller graph for this function:

◆ EnsureSpaceForLazyDeopt() [2/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

◆ EnsureSpaceForLazyDeopt() [3/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

◆ EnsureSpaceForLazyDeopt() [4/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

◆ EnsureSpaceForLazyDeopt() [5/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

◆ EnsureSpaceForLazyDeopt() [6/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

◆ EnsureSpaceForLazyDeopt() [7/7]

void v8::internal::LCodeGen::EnsureSpaceForLazyDeopt ( int space_needed )

private

◆ FinishCode() [1/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

Definition at line 60 of file lithium-codegen-arm.cc.

                                            {
   DCHECK(is_done());
   code->set_stack_slots(GetStackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   if (code->is_optimized_code()) RegisterWeakObjectsInOptimizedCode(code);
   PopulateDeoptimizationData(code);
 }

References DCHECK, GetStackSlotCount(), PopulateDeoptimizationData(), and safepoints_.

Referenced by v8::internal::LChunk::Codegen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FinishCode() [2/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

◆ FinishCode() [3/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

◆ FinishCode() [4/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

◆ FinishCode() [5/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

◆ FinishCode() [6/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

◆ FinishCode() [7/7]

void v8::internal::LCodeGen::FinishCode ( Handle< Code > code )

◆ FlushX87StackIfNecessary()

void v8::internal::LCodeGen::FlushX87StackIfNecessary ( LInstruction * instr )

inlineprivate

Definition at line 355 of file lithium-codegen-x87.h.

                                                      {
     x87_stack_.FlushIfNecessary(instr, this);
   }

References v8::internal::LCodeGen::X87Stack::FlushIfNecessary(), and x87_stack_.

Here is the call graph for this function:

◆ GenerateBodyInstructionPost() [1/3]

void v8::internal::LCodeGen::GenerateBodyInstructionPost ( LInstruction * instr )

private

◆ GenerateBodyInstructionPost() [2/3]

void v8::internal::LCodeGen::GenerateBodyInstructionPost ( LInstruction * instr )

private

◆ GenerateBodyInstructionPost() [3/3]

void v8::internal::LCodeGen::GenerateBodyInstructionPost ( LInstruction * instr )

private

◆ GenerateBodyInstructionPre() [1/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

Definition at line 255 of file lithium-codegen-arm.cc.

                                                              {
   if (instr->IsCall()) {
     EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
   }
   if (!instr->IsLazyBailout() && !instr->IsGap()) {
     safepoints_.BumpLastLazySafepointIndex();
   }
 }

References EnsureSpaceForLazyDeopt(), v8::internal::LInstruction::IsCall(), v8::internal::LInstruction::IsGap(), v8::internal::Deoptimizer::patch_size(), and safepoints_.

Here is the call graph for this function:

◆ GenerateBodyInstructionPre() [2/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

◆ GenerateBodyInstructionPre() [3/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

◆ GenerateBodyInstructionPre() [4/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

◆ GenerateBodyInstructionPre() [5/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

◆ GenerateBodyInstructionPre() [6/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

◆ GenerateBodyInstructionPre() [7/7]

void v8::internal::LCodeGen::GenerateBodyInstructionPre ( LInstruction * instr )

private

◆ GenerateCode() [1/7]

bool v8::internal::LCodeGen::GenerateCode ( )

Definition at line 45 of file lithium-codegen-arm.cc.

                             {
   LPhase phase("Z_Code generation", chunk());
   DCHECK(is_unused());
   status_ = GENERATING;
  
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // NONE indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in GeneratePrologue).
   FrameScope frame_scope(masm_, StackFrame::NONE);
  
   return GeneratePrologue() && GenerateBody() && GenerateDeferredCode() &&
          GenerateJumpTable() && GenerateSafepointTable();
 }

References chunk(), DCHECK, GenerateDeferredCode(), GenerateJumpTable(), GeneratePrologue(), GenerateSafepointTable(), and NONE.

Referenced by v8::internal::LChunk::Codegen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateCode() [2/7]

bool v8::internal::LCodeGen::GenerateCode ( )

◆ GenerateCode() [3/7]

bool v8::internal::LCodeGen::GenerateCode ( )

◆ GenerateCode() [4/7]

bool v8::internal::LCodeGen::GenerateCode ( )

◆ GenerateCode() [5/7]

bool v8::internal::LCodeGen::GenerateCode ( )

◆ GenerateCode() [6/7]

bool v8::internal::LCodeGen::GenerateCode ( )

◆ GenerateCode() [7/7]

bool v8::internal::LCodeGen::GenerateCode ( )

◆ GenerateDeferredCode() [1/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

Definition at line 265 of file lithium-codegen-arm.cc.

                                     {
   DCHECK(is_generating());
   if (deferred_.length() > 0) {
     for (int i = 0; !is_aborted() && i < deferred_.length(); i++) {
       LDeferredCode* code = deferred_[i];
  
       HValue* value =
           instructions_->at(code->instruction_index())->hydrogen_value();
       RecordAndWritePosition(
           chunk()->graph()->SourcePositionToScriptPosition(value->position()));
  
       Comment(";;; <@%d,#%d> "
               "-------------------- Deferred %s --------------------",
               code->instruction_index(),
               code->instr()->hydrogen_value()->id(),
               code->instr()->Mnemonic());
       __ bind(code->entry());
       if (NeedsDeferredFrame()) {
         Comment(";;; Build frame");
         DCHECK(!frame_is_built_);
         DCHECK(info()->IsStub());
         frame_is_built_ = true;
         __ PushFixedFrame();
         __ mov(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
         __ push(scratch0());
         __ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
         Comment(";;; Deferred code");
       }
       code->Generate();
       if (NeedsDeferredFrame()) {
         Comment(";;; Destroy frame");
         DCHECK(frame_is_built_);
         __ pop(ip);
         __ PopFixedFrame();
         frame_is_built_ = false;
       }
       __ jmp(code->exit());
     }
   }
  
   // Force constant pool emission at the end of the deferred code to make
   // sure that no constant pools are emitted after.
   masm()->CheckConstPool(true, false);
  
   return !is_aborted();
 }

References __, chunk(), DCHECK, deferred_, v8::internal::LDeferredCode::entry(), v8::internal::LDeferredCode::exit(), v8::internal::fp, frame_is_built_, v8::internal::Smi::FromInt(), v8::internal::LDeferredCode::Generate(), graph(), v8::internal::LInstruction::hydrogen_value(), v8::internal::HValue::id(), v8::internal::LDeferredCode::instr(), v8::internal::LDeferredCode::instruction_index(), v8::internal::ip, v8::internal::StandardFrameConstants::kFixedFrameSizeFromFp, v8::internal::LInstruction::Mnemonic(), NeedsDeferredFrame(), v8::internal::HValue::position(), RecordAndWritePosition(), scratch0(), v8::internal::sp, and v8::internal::STUB.

Referenced by GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateDeferredCode() [2/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

◆ GenerateDeferredCode() [3/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

◆ GenerateDeferredCode() [4/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

◆ GenerateDeferredCode() [5/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

◆ GenerateDeferredCode() [6/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

◆ GenerateDeferredCode() [7/7]

bool v8::internal::LCodeGen::GenerateDeferredCode ( )

private

◆ GenerateJumpTable() [1/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

Definition at line 313 of file lithium-codegen-arm.cc.

                                  {
   // Check that the jump table is accessible from everywhere in the function
   // code, i.e. that offsets to the table can be encoded in the 24bit signed
   // immediate of a branch instruction.
   // To simplify we consider the code size from the first instruction to the
   // end of the jump table. We also don't consider the pc load delta.
   // Each entry in the jump table generates one instruction and inlines one
   // 32bit data after it.
   if (!is_int24((masm()->pc_offset() / Assembler::kInstrSize) +
                 jump_table_.length() * 7)) {
     Abort(kGeneratedCodeIsTooLarge);
   }
  
   if (jump_table_.length() > 0) {
     Label needs_frame, call_deopt_entry;
  
     Comment(";;; -------------------- Jump table --------------------");
     Address base = jump_table_[0].address;
  
     Register entry_offset = scratch0();
  
     int length = jump_table_.length();
     for (int i = 0; i < length; i++) {
       Deoptimizer::JumpTableEntry* table_entry = &jump_table_[i];
       __ bind(&table_entry->label);
  
       DCHECK_EQ(jump_table_[0].bailout_type, table_entry->bailout_type);
       Address entry = table_entry->address;
       DeoptComment(table_entry->reason);
  
       // Second-level deopt table entries are contiguous and small, so instead
       // of loading the full, absolute address of each one, load an immediate
       // offset which will be added to the base address later.
       __ mov(entry_offset, Operand(entry - base));
  
       if (table_entry->needs_frame) {
         DCHECK(!info()->saves_caller_doubles());
         if (needs_frame.is_bound()) {
           __ b(&needs_frame);
         } else {
           __ bind(&needs_frame);
           Comment(";;; call deopt with frame");
           __ PushFixedFrame();
           // This variant of deopt can only be used with stubs. Since we don't
           // have a function pointer to install in the stack frame that we're
           // building, install a special marker there instead.
           DCHECK(info()->IsStub());
           __ mov(ip, Operand(Smi::FromInt(StackFrame::STUB)));
           __ push(ip);
           __ add(fp, sp,
                  Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
           __ bind(&call_deopt_entry);
           // Add the base address to the offset previously loaded in
           // entry_offset.
           __ add(entry_offset, entry_offset,
                  Operand(ExternalReference::ForDeoptEntry(base)));
           __ blx(entry_offset);
         }
  
         masm()->CheckConstPool(false, false);
       } else {
         // The last entry can fall through into `call_deopt_entry`, avoiding a
         // branch.
         bool need_branch = ((i + 1) != length) || call_deopt_entry.is_bound();
  
         if (need_branch) __ b(&call_deopt_entry);
  
         masm()->CheckConstPool(false, !need_branch);
       }
     }
  
     if (!call_deopt_entry.is_bound()) {
       Comment(";;; call deopt");
       __ bind(&call_deopt_entry);
  
       if (info()->saves_caller_doubles()) {
         DCHECK(info()->IsStub());
         RestoreCallerDoubles();
       }
  
       // Add the base address to the offset previously loaded in entry_offset.
       __ add(entry_offset, entry_offset,
              Operand(ExternalReference::ForDeoptEntry(base)));
       __ blx(entry_offset);
     }
   }
  
   // Force constant pool emission at the end of the deopt jump table to make
   // sure that no constant pools are emitted after.
   masm()->CheckConstPool(true, false);
  
   // The deoptimization jump table is the last part of the instruction
   // sequence. Mark the generated code as done unless we bailed out.
   if (!is_aborted()) status_ = DONE;
   return !is_aborted();
 }

References __, v8::internal::Deoptimizer::JumpTableEntry::address, v8::internal::Deoptimizer::JumpTableEntry::bailout_type, DCHECK, DCHECK_EQ, v8::internal::DONE, v8::internal::fp, v8::internal::Smi::FromInt(), v8::internal::ip, jump_table_, v8::internal::StandardFrameConstants::kFixedFrameSizeFromFp, v8::internal::Assembler::kInstrSize, v8::internal::Deoptimizer::JumpTableEntry::label, v8::internal::Deoptimizer::JumpTableEntry::needs_frame, v8::internal::Deoptimizer::JumpTableEntry::reason, RestoreCallerDoubles(), scratch0(), v8::internal::sp, and v8::internal::STUB.

Referenced by GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateJumpTable() [2/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

◆ GenerateJumpTable() [3/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

◆ GenerateJumpTable() [4/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

◆ GenerateJumpTable() [5/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

◆ GenerateJumpTable() [6/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

◆ GenerateJumpTable() [7/7]

bool v8::internal::LCodeGen::GenerateJumpTable ( )

private

◆ GenerateOsrPrologue() [1/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

Definition at line 240 of file lithium-codegen-arm.cc.

                                    {
   // Generate the OSR entry prologue at the first unknown OSR value, or if there
   // are none, at the OSR entrypoint instruction.
   if (osr_pc_offset_ >= 0) return;
  
   osr_pc_offset_ = masm()->pc_offset();
  
   // Adjust the frame size, subsuming the unoptimized frame into the
   // optimized frame.
   int slots = GetStackSlotCount() - graph()->osr()->UnoptimizedFrameSlots();
   DCHECK(slots >= 0);
   __ sub(sp, sp, Operand(slots * kPointerSize));
 }

References __, DCHECK, GetStackSlotCount(), graph(), v8::internal::kPointerSize, osr_pc_offset_, and v8::internal::sp.

Here is the call graph for this function:

◆ GenerateOsrPrologue() [2/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

◆ GenerateOsrPrologue() [3/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

◆ GenerateOsrPrologue() [4/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

◆ GenerateOsrPrologue() [5/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

◆ GenerateOsrPrologue() [6/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

◆ GenerateOsrPrologue() [7/7]

void v8::internal::LCodeGen::GenerateOsrPrologue ( )

private

◆ GeneratePrologue() [1/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

Definition at line 101 of file lithium-codegen-arm.cc.

                                 {
   DCHECK(is_generating());
  
   if (info()->IsOptimizing()) {
     ProfileEntryHookStub::MaybeCallEntryHook(masm_);
  
 #ifdef DEBUG
     if (strlen(FLAG_stop_at) > 0 &&
         info_->function()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {
       __ stop("stop_at");
     }
 #endif
  
     // r1: Callee's JS function.
     // cp: Callee's context.
     // pp: Callee's constant pool pointer (if FLAG_enable_ool_constant_pool)
     // fp: Caller's frame pointer.
     // lr: Caller's pc.
  
     // Sloppy mode functions and builtins need to replace the receiver with the
     // global proxy when called as functions (without an explicit receiver
     // object).
     if (info_->this_has_uses() &&
         info_->strict_mode() == SLOPPY &&
         !info_->is_native()) {
       Label ok;
       int receiver_offset = info_->scope()->num_parameters() * kPointerSize;
       __ ldr(r2, MemOperand(sp, receiver_offset));
       __ CompareRoot(r2, Heap::kUndefinedValueRootIndex);
       __ b(ne, &ok);
  
       __ ldr(r2, GlobalObjectOperand());
       __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalProxyOffset));
  
       __ str(r2, MemOperand(sp, receiver_offset));
  
       __ bind(&ok);
     }
   }
  
   info()->set_prologue_offset(masm_->pc_offset());
   if (NeedsEagerFrame()) {
     if (info()->IsStub()) {
       __ StubPrologue();
     } else {
       __ Prologue(info()->IsCodePreAgingActive());
     }
     frame_is_built_ = true;
     info_->AddNoFrameRange(0, masm_->pc_offset());
   }
  
   // Reserve space for the stack slots needed by the code.
   int slots = GetStackSlotCount();
   if (slots > 0) {
     if (FLAG_debug_code) {
       __ sub(sp,  sp, Operand(slots * kPointerSize));
       __ push(r0);
       __ push(r1);
       __ add(r0, sp, Operand(slots *  kPointerSize));
       __ mov(r1, Operand(kSlotsZapValue));
       Label loop;
       __ bind(&loop);
       __ sub(r0, r0, Operand(kPointerSize));
       __ str(r1, MemOperand(r0, 2 * kPointerSize));
       __ cmp(r0, sp);
       __ b(ne, &loop);
       __ pop(r1);
       __ pop(r0);
     } else {
       __ sub(sp,  sp, Operand(slots * kPointerSize));
     }
   }
  
   if (info()->saves_caller_doubles()) {
     SaveCallerDoubles();
   }
  
   // Possibly allocate a local context.
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots > 0) {
     Comment(";;; Allocate local context");
     bool need_write_barrier = true;
     // Argument to NewContext is the function, which is in r1.
     if (heap_slots <= FastNewContextStub::kMaximumSlots) {
       FastNewContextStub stub(isolate(), heap_slots);
       __ CallStub(&stub);
       // Result of FastNewContextStub is always in new space.
       need_write_barrier = false;
     } else {
       __ push(r1);
       __ CallRuntime(Runtime::kNewFunctionContext, 1);
     }
     RecordSafepoint(Safepoint::kNoLazyDeopt);
     // Context is returned in both r0 and cp.  It replaces the context
     // passed to us.  It's saved in the stack and kept live in cp.
     __ mov(cp, r0);
     __ str(r0, MemOperand(fp, StandardFrameConstants::kContextOffset));
     // Copy any necessary parameters into the context.
     int num_parameters = scope()->num_parameters();
     for (int i = 0; i < num_parameters; i++) {
       Variable* var = scope()->parameter(i);
       if (var->IsContextSlot()) {
         int parameter_offset = StandardFrameConstants::kCallerSPOffset +
             (num_parameters - 1 - i) * kPointerSize;
         // Load parameter from stack.
         __ ldr(r0, MemOperand(fp, parameter_offset));
         // Store it in the context.
         MemOperand target = ContextOperand(cp, var->index());
         __ str(r0, target);
         // Update the write barrier. This clobbers r3 and r0.
         if (need_write_barrier) {
           __ RecordWriteContextSlot(
               cp,
               target.offset(),
               r0,
               r3,
               GetLinkRegisterState(),
               kSaveFPRegs);
         } else if (FLAG_debug_code) {
           Label done;
           __ JumpIfInNewSpace(cp, r0, &done);
           __ Abort(kExpectedNewSpaceObject);
           __ bind(&done);
         }
       }
     }
     Comment(";;; End allocate local context");
   }
  
   // Trace the call.
   if (FLAG_trace && info()->IsOptimizing()) {
     // We have not executed any compiled code yet, so cp still holds the
     // incoming context.
     __ CallRuntime(Runtime::kTraceEnter, 0);
   }
   return !is_aborted();
 }

References __, CallRuntime(), v8::internal::ContextOperand(), v8::internal::cp, v8::internal::CStrVector(), DCHECK, v8::internal::FieldMemOperand(), v8::internal::fp, frame_is_built_, GetLinkRegisterState(), GetStackSlotCount(), v8::internal::GlobalObjectOperand(), v8::internal::Variable::index(), v8::internal::Variable::IsContextSlot(), v8::internal::StandardFrameConstants::kCallerSPOffset, v8::internal::StandardFrameConstants::kContextOffset, v8::internal::GlobalObject::kGlobalProxyOffset, v8::internal::kPointerSize, v8::internal::kSaveFPRegs, v8::internal::kSlotsZapValue, v8::internal::ProfileEntryHookStub::MaybeCallEntryHook(), v8::internal::Context::MIN_CONTEXT_SLOTS, v8::internal::ne, NeedsEagerFrame(), v8::internal::Scope::num_parameters(), v8::internal::MemOperand::offset(), v8::internal::Scope::parameter(), v8::internal::r0, v8::internal::r1, v8::internal::r2, v8::internal::r3, RecordSafepoint(), SaveCallerDoubles(), scope(), v8::internal::SLOPPY, and v8::internal::sp.

Referenced by GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GeneratePrologue() [2/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

◆ GeneratePrologue() [3/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

◆ GeneratePrologue() [4/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

◆ GeneratePrologue() [5/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

◆ GeneratePrologue() [6/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

◆ GeneratePrologue() [7/7]

bool v8::internal::LCodeGen::GeneratePrologue ( )

private

◆ GenerateSafepointTable() [1/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

Definition at line 411 of file lithium-codegen-arm.cc.

                                       {
   DCHECK(is_done());
   safepoints_.Emit(masm(), GetStackSlotCount());
   return !is_aborted();
 }

References DCHECK, GetStackSlotCount(), and safepoints_.

Referenced by GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateSafepointTable() [2/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

◆ GenerateSafepointTable() [3/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

◆ GenerateSafepointTable() [4/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

◆ GenerateSafepointTable() [5/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

◆ GenerateSafepointTable() [6/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

◆ GenerateSafepointTable() [7/7]

bool v8::internal::LCodeGen::GenerateSafepointTable ( )

private

◆ GetLinkRegisterState() [1/2]

LinkRegisterStatus v8::internal::LCodeGen::GetLinkRegisterState ( ) const

inline

Definition at line 62 of file lithium-codegen-arm.h.

                                                   {
     return frame_is_built_ ? kLRHasBeenSaved : kLRHasNotBeenSaved;
   }

References frame_is_built_, v8::internal::kLRHasBeenSaved, and v8::internal::kLRHasNotBeenSaved.

Referenced by DoStoreKeyedFixedArray(), and GeneratePrologue().

Here is the caller graph for this function:

◆ GetLinkRegisterState() [2/2]

LinkRegisterStatus v8::internal::LCodeGen::GetLinkRegisterState ( ) const

inline

Definition at line 71 of file lithium-codegen-arm64.h.

                                                   {
     return frame_is_built_ ? kLRHasBeenSaved : kLRHasNotBeenSaved;
   }

References frame_is_built_, v8::internal::kLRHasBeenSaved, and v8::internal::kLRHasNotBeenSaved.

◆ GetNextInstruction() [1/3]

LInstruction* v8::internal::LCodeGen::GetNextInstruction ( )

private

◆ GetNextInstruction() [2/3]

LInstruction* v8::internal::LCodeGen::GetNextInstruction ( )

private

◆ GetNextInstruction() [3/3]

LInstruction* v8::internal::LCodeGen::GetNextInstruction ( )

private

◆ GetRAState() [1/2]

RAStatus v8::internal::LCodeGen::GetRAState ( ) const

inline

Definition at line 61 of file lithium-codegen-mips.h.

                               {
     return frame_is_built_ ? kRAHasBeenSaved : kRAHasNotBeenSaved;
   }

References frame_is_built_, v8::internal::kRAHasBeenSaved, and v8::internal::kRAHasNotBeenSaved.

◆ GetRAState() [2/2]

RAStatus v8::internal::LCodeGen::GetRAState ( ) const

inline

Definition at line 61 of file lithium-codegen-mips64.h.

                               {
     return frame_is_built_ ? kRAHasBeenSaved : kRAHasNotBeenSaved;
   }

References frame_is_built_, v8::internal::kRAHasBeenSaved, and v8::internal::kRAHasNotBeenSaved.

◆ GetStackSlotCount() [1/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 163 of file lithium-codegen-arm.h.

163 { return chunk()->spill_slot_count(); }

References chunk().

Referenced by FinishCode(), GenerateOsrPrologue(), GeneratePrologue(), GenerateSafepointTable(), NeedsEagerFrame(), and ToMemOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStackSlotCount() [2/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 261 of file lithium-codegen-arm64.h.

261 { return chunk()->spill_slot_count(); }

References chunk().

Here is the call graph for this function:

◆ GetStackSlotCount() [3/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 142 of file lithium-codegen-ia32.h.

142 { return chunk()->spill_slot_count(); }

References chunk().

Here is the call graph for this function:

◆ GetStackSlotCount() [4/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 163 of file lithium-codegen-mips.h.

163 { return chunk()->spill_slot_count(); }

References chunk().

Here is the call graph for this function:

◆ GetStackSlotCount() [5/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 164 of file lithium-codegen-mips64.h.

164 { return chunk()->spill_slot_count(); }

References chunk().

Here is the call graph for this function:

◆ GetStackSlotCount() [6/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 136 of file lithium-codegen-x64.h.

136 { return chunk()->spill_slot_count(); }

References chunk().

Here is the call graph for this function:

◆ GetStackSlotCount() [7/7]

int v8::internal::LCodeGen::GetStackSlotCount ( ) const

inlineprivate

Definition at line 174 of file lithium-codegen-x87.h.

174 { return chunk()->spill_slot_count(); }

References chunk().

Here is the call graph for this function:

◆ graph()

HGraph* v8::internal::LCodeGen::graph ( ) const

inlineprivate

Definition at line 125 of file lithium-codegen-x64.h.

125 { return chunk()->graph(); }

References chunk().

Referenced by GenerateDeferredCode(), and GenerateOsrPrologue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HighOperand() [1/2]

Operand v8::internal::LCodeGen::HighOperand ( LOperand * op )

◆ HighOperand() [2/2]

Operand v8::internal::LCodeGen::HighOperand ( LOperand * op )

◆ IsDehoistedKeyConstant()

bool v8::internal::LCodeGen::IsDehoistedKeyConstant ( LConstantOperand * op ) const

◆ IsInteger32() [1/5]

bool v8::internal::LCodeGen::IsInteger32 ( LConstantOperand * op ) const

Definition at line 507 of file lithium-codegen-arm.cc.

                                                      {
   return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();
 }

◆ IsInteger32() [2/5]

bool v8::internal::LCodeGen::IsInteger32 ( LConstantOperand * op ) const

◆ IsInteger32() [3/5]

bool v8::internal::LCodeGen::IsInteger32 ( LConstantOperand * op ) const

◆ IsInteger32() [4/5]

bool v8::internal::LCodeGen::IsInteger32 ( LConstantOperand * op ) const

◆ IsInteger32() [5/5]

bool v8::internal::LCodeGen::IsInteger32 ( LConstantOperand * op ) const

◆ IsInteger32Constant() [1/2]

bool v8::internal::LCodeGen::IsInteger32Constant ( LConstantOperand * op ) const

Definition at line 1323 of file lithium-codegen-arm64.cc.

                                                              {
   return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();
 }

◆ IsInteger32Constant() [2/2]

bool v8::internal::LCodeGen::IsInteger32Constant ( LConstantOperand * op ) const

◆ IsNextEmittedBlock() [1/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 48 of file lithium-codegen-arm.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Referenced by EmitGoto().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsNextEmittedBlock() [2/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 57 of file lithium-codegen-arm64.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Here is the call graph for this function:

◆ IsNextEmittedBlock() [3/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 51 of file lithium-codegen-ia32.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Here is the call graph for this function:

◆ IsNextEmittedBlock() [4/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 47 of file lithium-codegen-mips.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Here is the call graph for this function:

◆ IsNextEmittedBlock() [5/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 47 of file lithium-codegen-mips64.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Here is the call graph for this function:

◆ IsNextEmittedBlock() [6/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 48 of file lithium-codegen-x64.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Here is the call graph for this function:

◆ IsNextEmittedBlock() [7/7]

bool v8::internal::LCodeGen::IsNextEmittedBlock ( int block_id ) const

inline

Definition at line 53 of file lithium-codegen-x87.h.

                                               {
     return LookupDestination(block_id) == GetNextEmittedBlock();
   }

References LookupDestination().

Here is the call graph for this function:

◆ IsSmi() [1/6]

bool v8::internal::LCodeGen::IsSmi ( LConstantOperand * op ) const

Definition at line 512 of file lithium-codegen-arm.cc.

                                                {
   return chunk_->LookupLiteralRepresentation(op).IsSmi();
 }

◆ IsSmi() [2/6]

bool v8::internal::LCodeGen::IsSmi ( LConstantOperand * op ) const

◆ IsSmi() [3/6]

bool v8::internal::LCodeGen::IsSmi ( LConstantOperand * op ) const

◆ IsSmi() [4/6]

bool v8::internal::LCodeGen::IsSmi ( LConstantOperand * op ) const

◆ IsSmi() [5/6]

bool v8::internal::LCodeGen::IsSmi ( LConstantOperand * op ) const

◆ IsSmi() [6/6]

bool v8::internal::LCodeGen::IsSmi ( LConstantOperand * op ) const

◆ IsSmiConstant()

bool v8::internal::LCodeGen::IsSmiConstant ( LConstantOperand * op ) const

◆ JSShiftAmountFromLConstant()

int v8::internal::LCodeGen::JSShiftAmountFromLConstant ( LOperand * constant )

inline

Definition at line 98 of file lithium-codegen-arm64.h.

                                                      {
     return ToInteger32(LConstantOperand::cast(constant)) & 0x1f;
   }

References ToInteger32().

Referenced by ToShiftedRightOperand32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadContextFromDeferred() [1/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

Definition at line 781 of file lithium-codegen-arm.cc.

                                                         {
   if (context->IsRegister()) {
     __ Move(cp, ToRegister(context));
   } else if (context->IsStackSlot()) {
     __ ldr(cp, ToMemOperand(context));
   } else if (context->IsConstantOperand()) {
     HConstant* constant =
         chunk_->LookupConstant(LConstantOperand::cast(context));
     __ Move(cp, Handle<Object>::cast(constant->handle(isolate())));
   } else {
     UNREACHABLE();
   }
 }

References __, v8::internal::cp, ToMemOperand(), ToRegister(), and UNREACHABLE.

Referenced by CallRuntimeFromDeferred(), DoDeferredInstanceOfKnownGlobal(), and DoDeferredStackCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadContextFromDeferred() [2/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

◆ LoadContextFromDeferred() [3/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

◆ LoadContextFromDeferred() [4/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

◆ LoadContextFromDeferred() [5/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

◆ LoadContextFromDeferred() [6/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

◆ LoadContextFromDeferred() [7/7]

void v8::internal::LCodeGen::LoadContextFromDeferred ( LOperand * context )

private

◆ LookupDestination() [1/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 44 of file lithium-codegen-arm.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Referenced by EmitGoto(), and IsNextEmittedBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LookupDestination() [2/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 53 of file lithium-codegen-arm64.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Here is the call graph for this function:

◆ LookupDestination() [3/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 47 of file lithium-codegen-ia32.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Here is the call graph for this function:

◆ LookupDestination() [4/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 43 of file lithium-codegen-mips.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Here is the call graph for this function:

◆ LookupDestination() [5/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 43 of file lithium-codegen-mips64.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Here is the call graph for this function:

◆ LookupDestination() [6/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 44 of file lithium-codegen-x64.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Here is the call graph for this function:

◆ LookupDestination() [7/7]

int v8::internal::LCodeGen::LookupDestination ( int block_id ) const

inline

Definition at line 49 of file lithium-codegen-x87.h.

                                             {
     return chunk()->LookupDestination(block_id);
   }

References chunk().

Here is the call graph for this function:

◆ NeedsDeferredFrame() [1/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 58 of file lithium-codegen-arm.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Referenced by v8::internal::LDeferredCode::done(), and GenerateDeferredCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NeedsDeferredFrame() [2/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 67 of file lithium-codegen-arm64.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Here is the call graph for this function:

◆ NeedsDeferredFrame() [3/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 61 of file lithium-codegen-ia32.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Here is the call graph for this function:

◆ NeedsDeferredFrame() [4/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 57 of file lithium-codegen-mips.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Here is the call graph for this function:

◆ NeedsDeferredFrame() [5/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 57 of file lithium-codegen-mips64.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Here is the call graph for this function:

◆ NeedsDeferredFrame() [6/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 58 of file lithium-codegen-x64.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Here is the call graph for this function:

◆ NeedsDeferredFrame() [7/7]

bool v8::internal::LCodeGen::NeedsDeferredFrame ( ) const

inline

Definition at line 63 of file lithium-codegen-x87.h.

                                   {
     return !NeedsEagerFrame() && info()->is_deferred_calling();
   }

References NeedsEagerFrame().

Here is the call graph for this function:

◆ NeedsEagerFrame() [1/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 52 of file lithium-codegen-arm.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Referenced by v8::internal::LChunk::Codegen(), GeneratePrologue(), NeedsDeferredFrame(), RestoreCallerDoubles(), SaveCallerDoubles(), ToHighMemOperand(), and ToMemOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NeedsEagerFrame() [2/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 61 of file lithium-codegen-arm64.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Here is the call graph for this function:

◆ NeedsEagerFrame() [3/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 55 of file lithium-codegen-ia32.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Here is the call graph for this function:

◆ NeedsEagerFrame() [4/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 51 of file lithium-codegen-mips.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Here is the call graph for this function:

◆ NeedsEagerFrame() [5/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 51 of file lithium-codegen-mips64.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Here is the call graph for this function:

◆ NeedsEagerFrame() [6/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 52 of file lithium-codegen-x64.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Here is the call graph for this function:

◆ NeedsEagerFrame() [7/7]

bool v8::internal::LCodeGen::NeedsEagerFrame ( ) const

inline

Definition at line 57 of file lithium-codegen-x87.h.

                                {
     return GetStackSlotCount() > 0 ||
         info()->is_non_deferred_calling() ||
         !info()->IsStub() ||
         info()->requires_frame();
   }

References GetStackSlotCount().

Here is the call graph for this function:

◆ PopulateDeoptimizationData() [1/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

Definition at line 930 of file lithium-codegen-arm.cc.

                                                            {
   int length = deoptimizations_.length();
   if (length == 0) return;
   Handle<DeoptimizationInputData> data =
       DeoptimizationInputData::New(isolate(), length, TENURED);
  
   Handle<ByteArray> translations =
       translations_.CreateByteArray(isolate()->factory());
   data->SetTranslationByteArray(*translations);
   data->SetInlinedFunctionCount(Smi::FromInt(inlined_function_count_));
   data->SetOptimizationId(Smi::FromInt(info_->optimization_id()));
   if (info_->IsOptimizing()) {
     // Reference to shared function info does not change between phases.
     AllowDeferredHandleDereference allow_handle_dereference;
     data->SetSharedFunctionInfo(*info_->shared_info());
   } else {
     data->SetSharedFunctionInfo(Smi::FromInt(0));
   }
  
   Handle<FixedArray> literals =
       factory()->NewFixedArray(deoptimization_literals_.length(), TENURED);
   { AllowDeferredHandleDereference copy_handles;
     for (int i = 0; i < deoptimization_literals_.length(); i++) {
       literals->set(i, *deoptimization_literals_[i]);
     }
     data->SetLiteralArray(*literals);
   }
  
   data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id().ToInt()));
   data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_));
  
   // Populate the deoptimization entries.
   for (int i = 0; i < length; i++) {
     LEnvironment* env = deoptimizations_[i];
     data->SetAstId(i, env->ast_id());
     data->SetTranslationIndex(i, Smi::FromInt(env->translation_index()));
     data->SetArgumentsStackHeight(i,
                                   Smi::FromInt(env->arguments_stack_height()));
     data->SetPc(i, Smi::FromInt(env->pc_offset()));
   }
   code->set_deoptimization_data(*data);
 }

References deoptimization_literals_, deoptimizations_, v8::internal::Smi::FromInt(), inlined_function_count_, LEnvironment, literals(), v8::internal::DeoptimizationInputData::New(), osr_pc_offset_, v8::internal::TENURED, and translations_.

Referenced by FinishCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopulateDeoptimizationData() [2/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

◆ PopulateDeoptimizationData() [3/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

◆ PopulateDeoptimizationData() [4/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

◆ PopulateDeoptimizationData() [5/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

◆ PopulateDeoptimizationData() [6/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

◆ PopulateDeoptimizationData() [7/7]

void v8::internal::LCodeGen::PopulateDeoptimizationData ( Handle< Code > code )

private

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [1/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

Definition at line 984 of file lithium-codegen-arm.cc.

                                                                   {
   DCHECK(deoptimization_literals_.length() == 0);
  
   const ZoneList<Handle<JSFunction> >* inlined_closures =
       chunk()->inlined_closures();
  
   for (int i = 0, length = inlined_closures->length();
        i < length;
        i++) {
     DefineDeoptimizationLiteral(inlined_closures->at(i));
   }
  
   inlined_function_count_ = deoptimization_literals_.length();
 }

References v8::internal::List< T, AllocationPolicy >::at(), chunk(), DCHECK, DefineDeoptimizationLiteral(), deoptimization_literals_, and inlined_function_count_.

Referenced by LCodeGen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [2/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [3/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [4/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [5/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [6/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

◆ PopulateDeoptimizationLiteralsWithInlinedFunctions() [7/7]

void v8::internal::LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions ( )

private

◆ PrepareKeyedArrayOperand()

MemOperand v8::internal::LCodeGen::PrepareKeyedArrayOperand	(	Register	base,
		Register	elements,
		Register	key,
		bool	key_is_tagged,
		ElementsKind	elements_kind,
		Representation	representation,
		int	base_offset
	)

private

Definition at line 3519 of file lithium-codegen-arm64.cc.

                                                                {
   STATIC_ASSERT(static_cast<unsigned>(kSmiValueSize) == kWRegSizeInBits);
   STATIC_ASSERT(kSmiTag == 0);
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
  
   // Even though the HLoad/StoreKeyed instructions force the input
   // representation for the key to be an integer, the input gets replaced during
   // bounds check elimination with the index argument to the bounds check, which
   // can be tagged, so that case must be handled here, too.
   if (key_is_tagged) {
     __ Add(base, elements, Operand::UntagSmiAndScale(key, element_size_shift));
     if (representation.IsInteger32()) {
       DCHECK(elements_kind == FAST_SMI_ELEMENTS);
       // Read or write only the smi payload in the case of fast smi arrays.
       return UntagSmiMemOperand(base, base_offset);
     } else {
       return MemOperand(base, base_offset);
     }
   } else {
     // Sign extend key because it could be a 32-bit negative value or contain
     // garbage in the top 32-bits. The address computation happens in 64-bit.
     DCHECK((element_size_shift >= 0) && (element_size_shift <= 4));
     if (representation.IsInteger32()) {
       DCHECK(elements_kind == FAST_SMI_ELEMENTS);
       // Read or write only the smi payload in the case of fast smi arrays.
       __ Add(base, elements, Operand(key, SXTW, element_size_shift));
       return UntagSmiMemOperand(base, base_offset);
     } else {
       __ Add(base, elements, base_offset);
       return MemOperand(base, key, SXTW, element_size_shift);
     }
   }
 }

References __, DCHECK, v8::internal::ElementsKindToShiftSize(), v8::internal::FAST_SMI_ELEMENTS, v8::internal::Representation::IsInteger32(), v8::internal::kSmiTag, v8::internal::kSmiValueSize, v8::internal::kWRegSizeInBits, v8::internal::STATIC_ASSERT(), v8::internal::SXTW, v8::internal::Operand::UntagSmiAndScale(), and v8::internal::UntagSmiMemOperand().

Here is the call graph for this function:

◆ PrepareKeyedExternalArrayOperand()

MemOperand v8::internal::LCodeGen::PrepareKeyedExternalArrayOperand	(	Register	key,
		Register	base,
		Register	scratch,
		bool	key_is_smi,
		bool	key_is_constant,
		int	constant_key,
		ElementsKind	elements_kind,
		int	base_offset
	)

private

Definition at line 3399 of file lithium-codegen-arm64.cc.

                      {
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
  
   if (key_is_constant) {
     int key_offset = constant_key << element_size_shift;
     return MemOperand(base, key_offset + base_offset);
   }
  
   if (key_is_smi) {
     __ Add(scratch, base, Operand::UntagSmiAndScale(key, element_size_shift));
     return MemOperand(scratch, base_offset);
   }
  
   if (base_offset == 0) {
     return MemOperand(base, key, SXTW, element_size_shift);
   }
  
   DCHECK(!AreAliased(scratch, key));
   __ Add(scratch, base, base_offset);
   return MemOperand(scratch, key, SXTW, element_size_shift);
 }

References __, v8::internal::AreAliased(), DCHECK, v8::internal::ElementsKindToShiftSize(), v8::internal::SXTW, and v8::internal::Operand::UntagSmiAndScale().

Here is the call graph for this function:

◆ PrepareKeyedOperand() [1/3]

MemOperand v8::internal::LCodeGen::PrepareKeyedOperand	(	Register	key,
		Register	base,
		bool	key_is_constant,
		int	constant_key,
		int	element_size,
		int	shift_size,
		int	base_offset
	)

Definition at line 3391 of file lithium-codegen-arm.cc.

                                                           {
   if (key_is_constant) {
     return MemOperand(base, (constant_key << element_size) + base_offset);
   }
  
   if (base_offset == 0) {
     if (shift_size >= 0) {
       return MemOperand(base, key, LSL, shift_size);
     } else {
       DCHECK_EQ(-1, shift_size);
       return MemOperand(base, key, LSR, 1);
     }
   }
  
   if (shift_size >= 0) {
     __ add(scratch0(), base, Operand(key, LSL, shift_size));
     return MemOperand(scratch0(), base_offset);
   } else {
     DCHECK_EQ(-1, shift_size);
     __ add(scratch0(), base, Operand(key, ASR, 1));
     return MemOperand(scratch0(), base_offset);
   }
 }

References __, v8::internal::ASR, DCHECK_EQ, v8::internal::LSL, v8::internal::LSR, and scratch0().

Referenced by DoLoadKeyedExternalArray(), and DoStoreKeyedExternalArray().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareKeyedOperand() [2/3]

MemOperand v8::internal::LCodeGen::PrepareKeyedOperand	(	Register	key,
		Register	base,
		bool	key_is_constant,
		int	constant_key,
		int	element_size,
		int	shift_size,
		int	base_offset
	)

◆ PrepareKeyedOperand() [3/3]

MemOperand v8::internal::LCodeGen::PrepareKeyedOperand	(	Register	key,
		Register	base,
		bool	key_is_constant,
		int	constant_key,
		int	element_size,
		int	shift_size,
		int	base_offset
	)

◆ RecordAndWritePosition() [1/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

Definition at line 1057 of file lithium-codegen-arm.cc.

                                                   {
   if (position == RelocInfo::kNoPosition) return;
   masm()->positions_recorder()->RecordPosition(position);
   masm()->positions_recorder()->WriteRecordedPositions();
 }

References v8::internal::RelocInfo::kNoPosition.

Referenced by GenerateDeferredCode().

Here is the caller graph for this function:

◆ RecordAndWritePosition() [2/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

◆ RecordAndWritePosition() [3/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

◆ RecordAndWritePosition() [4/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

◆ RecordAndWritePosition() [5/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

◆ RecordAndWritePosition() [6/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

◆ RecordAndWritePosition() [7/7]

void v8::internal::LCodeGen::RecordAndWritePosition ( int position )

private

◆ RecordSafepoint() [1/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

Definition at line 1037 of file lithium-codegen-arm.cc.

                                                               {
   RecordSafepoint(pointers, Safepoint::kSimple, 0, deopt_mode);
 }

References RecordSafepoint().

Here is the call graph for this function:

◆ RecordSafepoint() [2/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [3/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [4/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [5/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [6/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [7/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [8/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

Definition at line 1012 of file lithium-codegen-arm.cc.

                                    {
   DCHECK(expected_safepoint_kind_ == kind);
  
   const ZoneList<LOperand*>* operands = pointers->GetNormalizedOperands();
   Safepoint safepoint = safepoints_.DefineSafepoint(masm(),
       kind, arguments, deopt_mode);
   for (int i = 0; i < operands->length(); i++) {
     LOperand* pointer = operands->at(i);
     if (pointer->IsStackSlot()) {
       safepoint.DefinePointerSlot(pointer->index(), zone());
     } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {
       safepoint.DefinePointerRegister(ToRegister(pointer), zone());
     }
   }
   if (FLAG_enable_ool_constant_pool && (kind & Safepoint::kWithRegisters)) {
     // Register pp always contains a pointer to the constant pool.
     safepoint.DefinePointerRegister(pp, zone());
   }
 }

References v8::internal::List< T, AllocationPolicy >::at(), DCHECK, expected_safepoint_kind_, v8::internal::LOperand::index(), v8::internal::pp, safepoints_, and ToRegister().

Referenced by GeneratePrologue(), RecordSafepoint(), RecordSafepointWithLazyDeopt(), and RecordSafepointWithRegisters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RecordSafepoint() [9/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [10/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [11/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [12/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [13/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [14/21]

void v8::internal::LCodeGen::RecordSafepoint	(	LPointerMap *	pointers,
		Safepoint::Kind	kind,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepoint() [15/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

Definition at line 1043 of file lithium-codegen-arm.cc.

                                                             {
   LPointerMap empty_pointers(zone());
   RecordSafepoint(&empty_pointers, deopt_mode);
 }

References RecordSafepoint().

Here is the call graph for this function:

◆ RecordSafepoint() [16/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

◆ RecordSafepoint() [17/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

◆ RecordSafepoint() [18/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

◆ RecordSafepoint() [19/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

◆ RecordSafepoint() [20/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

◆ RecordSafepoint() [21/21]

void v8::internal::LCodeGen::RecordSafepoint ( Safepoint::DeoptMode mode )

private

◆ RecordSafepointWithLazyDeopt() [1/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

Definition at line 1000 of file lithium-codegen-arm.cc.

                                                        {
   if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {
     RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);
   } else {
     DCHECK(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 0, Safepoint::kLazyDeopt);
   }
 }

References DCHECK, v8::internal::LInstruction::pointer_map(), RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS, RECORD_SIMPLE_SAFEPOINT, RecordSafepoint(), and RecordSafepointWithRegisters().

Referenced by CallCodeGeneric(), CallKnownFunction(), CallRuntime(), and DoDeferredStackCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RecordSafepointWithLazyDeopt() [2/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ RecordSafepointWithLazyDeopt() [3/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ RecordSafepointWithLazyDeopt() [4/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ RecordSafepointWithLazyDeopt() [5/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ RecordSafepointWithLazyDeopt() [6/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode
	)

private

◆ RecordSafepointWithLazyDeopt() [7/7]

void v8::internal::LCodeGen::RecordSafepointWithLazyDeopt	(	LInstruction *	instr,
		SafepointMode	safepoint_mode,
		int	argc
	)

private

◆ RecordSafepointWithRegisters() [1/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

Definition at line 1049 of file lithium-codegen-arm.cc.

                                                                            {
   RecordSafepoint(
       pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
 }

References RecordSafepoint().

Referenced by CallRuntimeFromDeferred(), DoDeferredInstanceMigration(), DoDeferredLoadMutableDouble(), DoDeferredNumberTagD(), DoDeferredNumberTagIU(), DoDeferredNumberTagU(), and RecordSafepointWithLazyDeopt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RecordSafepointWithRegisters() [2/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepointWithRegisters() [3/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepointWithRegisters() [4/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepointWithRegisters() [5/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepointWithRegisters() [6/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RecordSafepointWithRegisters() [7/7]

void v8::internal::LCodeGen::RecordSafepointWithRegisters	(	LPointerMap *	pointers,
		int	arguments,
		Safepoint::DeoptMode	mode
	)

private

◆ RegisterEnvironmentForDeoptimization() [1/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

Definition at line 807 of file lithium-codegen-arm.cc.

                                                                              {
   environment->set_has_been_used();
   if (!environment->HasBeenRegistered()) {
     // Physical stack frame layout:
     // -x ............. -4  0 ..................................... y
     // [incoming arguments] [spill slots] [pushed outgoing arguments]
  
     // Layout of the environment:
     // 0 ..................................................... size-1
     // [parameters] [locals] [expression stack including arguments]
  
     // Layout of the translation:
     // 0 ........................................................ size - 1 + 4
     // [expression stack including arguments] [locals] [4 words] [parameters]
     // |>------------  translation_size ------------<|
  
     int frame_count = 0;
     int jsframe_count = 0;
     for (LEnvironment* e = environment; e != NULL; e = e->outer()) {
       ++frame_count;
       if (e->frame_type() == JS_FUNCTION) {
         ++jsframe_count;
       }
     }
     Translation translation(&translations_, frame_count, jsframe_count, zone());
     WriteTranslation(environment, &translation);
     int deoptimization_index = deoptimizations_.length();
     int pc_offset = masm()->pc_offset();
     environment->Register(deoptimization_index,
                           translation.index(),
                           (mode == Safepoint::kLazyDeopt) ? pc_offset : -1);
     deoptimizations_.Add(environment, zone());
   }
 }

References v8::internal::List< T, AllocationPolicy >::Add(), deoptimizations_, v8::internal::JS_FUNCTION, LEnvironment, mode(), NULL, translations_, and WriteTranslation().

Referenced by DeoptimizeBranch(), and DeoptimizeIf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RegisterEnvironmentForDeoptimization() [2/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

◆ RegisterEnvironmentForDeoptimization() [3/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

◆ RegisterEnvironmentForDeoptimization() [4/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

◆ RegisterEnvironmentForDeoptimization() [5/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

◆ RegisterEnvironmentForDeoptimization() [6/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

◆ RegisterEnvironmentForDeoptimization() [7/7]

void v8::internal::LCodeGen::RegisterEnvironmentForDeoptimization	(	LEnvironment *	environment,
		Safepoint::DeoptMode	mode
	)

private

◆ RestoreCallerDoubles() [1/6]

void v8::internal::LCodeGen::RestoreCallerDoubles ( )

private

Definition at line 85 of file lithium-codegen-arm.cc.

                                     {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Restore clobbered callee double registers");
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator save_iterator(doubles);
   int count = 0;
   while (!save_iterator.Done()) {
     __ vldr(DwVfpRegister::FromAllocationIndex(save_iterator.Current()),
              MemOperand(sp, count * kDoubleSize));
     save_iterator.Advance();
     count++;
   }
 }

References __, chunk(), DCHECK, v8::internal::DwVfpRegister::FromAllocationIndex(), v8::internal::kDoubleSize, NeedsEagerFrame(), and v8::internal::sp.

Referenced by GenerateJumpTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RestoreCallerDoubles() [2/6]

void v8::internal::LCodeGen::RestoreCallerDoubles ( )

private

◆ RestoreCallerDoubles() [3/6]

void v8::internal::LCodeGen::RestoreCallerDoubles ( )

private

◆ RestoreCallerDoubles() [4/6]

void v8::internal::LCodeGen::RestoreCallerDoubles ( )

private

◆ RestoreCallerDoubles() [5/6]

void v8::internal::LCodeGen::RestoreCallerDoubles ( )

private

◆ RestoreCallerDoubles() [6/6]

void v8::internal::LCodeGen::RestoreCallerDoubles ( )

private

◆ SaveCallerDoubles() [1/6]

void v8::internal::LCodeGen::SaveCallerDoubles ( )

private

Definition at line 69 of file lithium-codegen-arm.cc.

                                  {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Save clobbered callee double registers");
   int count = 0;
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator save_iterator(doubles);
   while (!save_iterator.Done()) {
     __ vstr(DwVfpRegister::FromAllocationIndex(save_iterator.Current()),
             MemOperand(sp, count * kDoubleSize));
     save_iterator.Advance();
     count++;
   }
 }

References __, chunk(), DCHECK, v8::internal::DwVfpRegister::FromAllocationIndex(), v8::internal::kDoubleSize, NeedsEagerFrame(), and v8::internal::sp.

Referenced by GeneratePrologue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveCallerDoubles() [2/6]

void v8::internal::LCodeGen::SaveCallerDoubles ( )

private

◆ SaveCallerDoubles() [3/6]

void v8::internal::LCodeGen::SaveCallerDoubles ( )

private

◆ SaveCallerDoubles() [4/6]

void v8::internal::LCodeGen::SaveCallerDoubles ( )

private

◆ SaveCallerDoubles() [5/6]

void v8::internal::LCodeGen::SaveCallerDoubles ( )

private

◆ SaveCallerDoubles() [6/6]

void v8::internal::LCodeGen::SaveCallerDoubles ( )

private

◆ scope() [1/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inlineprivate

Definition at line 149 of file lithium-codegen-arm.h.

149 { return scope_; }

References scope_.

Referenced by CallCodeGeneric(), DoDeferredAllocate(), DoDeferredInstanceMigration(), DoDeferredInstanceOfKnownGlobal(), DoDeferredLoadMutableDouble(), DoDeferredMathAbsTagged(), DoDeferredMathAbsTaggedHeapNumber(), DoDeferredNumberTagD(), DoDeferredNumberTagIU(), DoDeferredNumberTagU(), DoDeferredStackCheck(), DoDeferredStringCharCodeAt(), DoDeferredStringCharFromCode(), and GeneratePrologue().

Here is the caller graph for this function:

◆ scope() [2/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inline

Definition at line 51 of file lithium-codegen-arm64.h.

51 { return scope_; }

References scope_.

◆ scope() [3/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inlineprivate

Definition at line 131 of file lithium-codegen-ia32.h.

131 { return scope_; }

References scope_.

◆ scope() [4/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inlineprivate

Definition at line 148 of file lithium-codegen-mips.h.

148 { return scope_; }

References scope_.

◆ scope() [5/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inlineprivate

Definition at line 149 of file lithium-codegen-mips64.h.

149 { return scope_; }

References scope_.

◆ scope() [6/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inlineprivate

Definition at line 124 of file lithium-codegen-x64.h.

124 { return scope_; }

References scope_.

◆ scope() [7/7]

Scope* v8::internal::LCodeGen::scope ( ) const

inlineprivate

Definition at line 165 of file lithium-codegen-x87.h.

165 { return scope_; }

References scope_.

◆ scratch0() [1/3]

Register v8::internal::LCodeGen::scratch0 ( )

inlineprivate

Definition at line 151 of file lithium-codegen-arm.h.

151 { return r9; }

v8::internal::r9

const Register r9

Definition: assembler-arm.h:170

References v8::internal::r9.

Referenced by BuildSeqStringOperand(), DeoptimizeIf(), DoDeferredInstanceMigration(), DoDeferredMathAbsTaggedHeapNumber(), DoDeferredNumberTagIU(), DoDeferredStringCharCodeAt(), DoDeferredTaggedToI(), DoLoadKeyedExternalArray(), DoLoadKeyedFixedArray(), DoLoadKeyedFixedDoubleArray(), DoStoreKeyedExternalArray(), DoStoreKeyedFixedArray(), DoStoreKeyedFixedDoubleArray(), EmitIsObject(), EmitNumberUntagD(), EmitTypeofIs(), GenerateDeferredCode(), GenerateJumpTable(), and PrepareKeyedOperand().

Here is the caller graph for this function:

◆ scratch0() [2/3]

Register v8::internal::LCodeGen::scratch0 ( )

inlineprivate

Definition at line 150 of file lithium-codegen-mips.h.

150 { return kLithiumScratchReg; }

kLithiumScratchReg

#define kLithiumScratchReg

Definition: assembler-mips.h:331

References kLithiumScratchReg.

◆ scratch0() [3/3]

Register v8::internal::LCodeGen::scratch0 ( )

inlineprivate

Definition at line 151 of file lithium-codegen-mips64.h.

151 { return kLithiumScratchReg; }

References kLithiumScratchReg.

◆ scratch1() [1/2]

Register v8::internal::LCodeGen::scratch1 ( )

inlineprivate

Definition at line 151 of file lithium-codegen-mips.h.

151 { return kLithiumScratchReg2; }

kLithiumScratchReg2

#define kLithiumScratchReg2

Definition: assembler-mips.h:332

References kLithiumScratchReg2.

Referenced by DoDeferredNumberTagU(), and DoDeferredTaggedToI().

Here is the caller graph for this function:

◆ scratch1() [2/2]

Register v8::internal::LCodeGen::scratch1 ( )

inlineprivate

Definition at line 152 of file lithium-codegen-mips64.h.

152 { return kLithiumScratchReg2; }

References kLithiumScratchReg2.

◆ strict_mode() [1/6]

StrictMode v8::internal::LCodeGen::strict_mode ( ) const

inlineprivate

Definition at line 147 of file lithium-codegen-arm.h.

147 { return info()->strict_mode(); }

◆ strict_mode() [2/6]

StrictMode v8::internal::LCodeGen::strict_mode ( ) const

inlineprivate

Definition at line 129 of file lithium-codegen-ia32.h.

129 { return info()->strict_mode(); }

◆ strict_mode() [3/6]

StrictMode v8::internal::LCodeGen::strict_mode ( ) const

inlineprivate

Definition at line 146 of file lithium-codegen-mips.h.

146 { return info()->strict_mode(); }

◆ strict_mode() [4/6]

StrictMode v8::internal::LCodeGen::strict_mode ( ) const

inlineprivate

Definition at line 147 of file lithium-codegen-mips64.h.

147 { return info()->strict_mode(); }

◆ strict_mode() [5/6]

StrictMode v8::internal::LCodeGen::strict_mode ( ) const

inlineprivate

Definition at line 121 of file lithium-codegen-x64.h.

121 { return info()->strict_mode(); }

◆ strict_mode() [6/6]

StrictMode v8::internal::LCodeGen::strict_mode ( ) const

inlineprivate

Definition at line 163 of file lithium-codegen-x87.h.

163 { return info()->strict_mode(); }

◆ ToDouble() [1/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

Definition at line 538 of file lithium-codegen-arm.cc.

                                                     {
   HConstant* constant = chunk_->LookupConstant(op);
   DCHECK(constant->HasDoubleValue());
   return constant->DoubleValue();
 }

References DCHECK.

◆ ToDouble() [2/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

◆ ToDouble() [3/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

◆ ToDouble() [4/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

◆ ToDouble() [5/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

◆ ToDouble() [6/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

◆ ToDouble() [7/7]

double v8::internal::LCodeGen::ToDouble ( LConstantOperand * op ) const

◆ ToDoubleRegister() [1/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( int index ) const

private

Definition at line 423 of file lithium-codegen-arm.cc.

                                                         {
   return DwVfpRegister::FromAllocationIndex(index);
 }

References v8::internal::DwVfpRegister::FromAllocationIndex().

Here is the call graph for this function:

◆ ToDoubleRegister() [2/11]

XMMRegister v8::internal::LCodeGen::ToDoubleRegister ( int index ) const

private

◆ ToDoubleRegister() [3/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( int index ) const

private

◆ ToDoubleRegister() [4/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( int index ) const

private

◆ ToDoubleRegister() [5/11]

XMMRegister v8::internal::LCodeGen::ToDoubleRegister ( int index ) const

private

◆ ToDoubleRegister() [6/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( LOperand * op ) const

Definition at line 461 of file lithium-codegen-arm.cc.

                                                            {
   DCHECK(op->IsDoubleRegister());
   return ToDoubleRegister(op->index());
 }

References DCHECK, and v8::internal::LOperand::index().

Referenced by AddToTranslation(), DoDeferredTaggedToI(), DoLoadKeyedExternalArray(), DoLoadKeyedFixedDoubleArray(), DoStoreKeyedExternalArray(), DoStoreKeyedFixedDoubleArray(), and EmitLoadDoubleRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToDoubleRegister() [7/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( LOperand * op ) const

◆ ToDoubleRegister() [8/11]

XMMRegister v8::internal::LCodeGen::ToDoubleRegister ( LOperand * op ) const

◆ ToDoubleRegister() [9/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( LOperand * op ) const

◆ ToDoubleRegister() [10/11]

DoubleRegister v8::internal::LCodeGen::ToDoubleRegister ( LOperand * op ) const

◆ ToDoubleRegister() [11/11]

XMMRegister v8::internal::LCodeGen::ToDoubleRegister ( LOperand * op ) const

◆ ToExternalReference() [1/3]

ExternalReference v8::internal::LCodeGen::ToExternalReference ( LConstantOperand * op ) const

private

◆ ToExternalReference() [2/3]

ExternalReference v8::internal::LCodeGen::ToExternalReference ( LConstantOperand * op ) const

◆ ToExternalReference() [3/3]

ExternalReference v8::internal::LCodeGen::ToExternalReference ( LConstantOperand * op ) const

private

◆ ToHandle() [1/7]

Handle< Object > v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

Definition at line 500 of file lithium-codegen-arm.cc.

                                                             {
   HConstant* constant = chunk_->LookupConstant(op);
   DCHECK(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
   return constant->handle(isolate());
 }

References DCHECK.

◆ ToHandle() [2/7]

Handle<Object> v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

◆ ToHandle() [3/7]

Handle<Object> v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

◆ ToHandle() [4/7]

Handle<Object> v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

◆ ToHandle() [5/7]

Handle<Object> v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

◆ ToHandle() [6/7]

Handle<Object> v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

◆ ToHandle() [7/7]

Handle<Object> v8::internal::LCodeGen::ToHandle ( LConstantOperand * op ) const

◆ ToHighMemOperand() [1/3]

MemOperand v8::internal::LCodeGen::ToHighMemOperand ( LOperand * op ) const

Definition at line 593 of file lithium-codegen-arm.cc.

                                                         {
   DCHECK(op->IsDoubleStackSlot());
   if (NeedsEagerFrame()) {
     return MemOperand(fp, StackSlotOffset(op->index()) + kPointerSize);
   } else {
     // Retrieve parameter without eager stack-frame relative to the
     // stack-pointer.
     return MemOperand(
         sp, ArgumentsOffsetWithoutFrame(op->index()) + kPointerSize);
   }
 }

References v8::internal::ArgumentsOffsetWithoutFrame(), DCHECK, v8::internal::fp, v8::internal::LOperand::index(), v8::internal::kPointerSize, NeedsEagerFrame(), v8::internal::sp, and v8::internal::StackSlotOffset().

Here is the call graph for this function:

◆ ToHighMemOperand() [2/3]

MemOperand v8::internal::LCodeGen::ToHighMemOperand ( LOperand * op ) const

◆ ToHighMemOperand() [3/3]

MemOperand v8::internal::LCodeGen::ToHighMemOperand ( LOperand * op ) const

◆ ToImmediate() [1/2]

Immediate v8::internal::LCodeGen::ToImmediate	(	LOperand *	op,
		const Representation &	r
	)		const

inline

Definition at line 72 of file lithium-codegen-ia32.h.

                                                                      {
     return Immediate(ToRepresentation(LConstantOperand::cast(op), r));
   }

References ToRepresentation().

Here is the call graph for this function:

◆ ToImmediate() [2/2]

Immediate v8::internal::LCodeGen::ToImmediate	(	LOperand *	op,
		const Representation &	r
	)		const

inline

Definition at line 74 of file lithium-codegen-x87.h.

                                                                      {
     return Immediate(ToRepresentation(LConstantOperand::cast(op), r));
   }

References ToRepresentation().

Here is the call graph for this function:

◆ ToInteger32() [1/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

Definition at line 517 of file lithium-codegen-arm.cc.

                                                         {
   return ToRepresentation(op, Representation::Integer32());
 }

References v8::internal::Representation::Integer32(), and ToRepresentation().

Referenced by BuildSeqStringOperand(), DoDeferredAllocate(), DoDeferredStringCharCodeAt(), DoLoadKeyedExternalArray(), DoLoadKeyedFixedArray(), DoLoadKeyedFixedDoubleArray(), DoStoreKeyedExternalArray(), DoStoreKeyedFixedArray(), DoStoreKeyedFixedDoubleArray(), JSShiftAmountFromLConstant(), and ToRegister32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToInteger32() [2/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

◆ ToInteger32() [3/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

private

◆ ToInteger32() [4/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

◆ ToInteger32() [5/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

◆ ToInteger32() [6/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

◆ ToInteger32() [7/7]

int32_t v8::internal::LCodeGen::ToInteger32 ( LConstantOperand * op ) const

private

◆ TokenToCondition() [1/7]

Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

Definition at line 2363 of file lithium-codegen-arm.cc.

                                                                     {
   Condition cond = kNoCondition;
   switch (op) {
     case Token::EQ:
     case Token::EQ_STRICT:
       cond = eq;
       break;
     case Token::NE:
     case Token::NE_STRICT:
       cond = ne;
       break;
     case Token::LT:
       cond = is_unsigned ? lo : lt;
       break;
     case Token::GT:
       cond = is_unsigned ? hi : gt;
       break;
     case Token::LTE:
       cond = is_unsigned ? ls : le;
       break;
     case Token::GTE:
       cond = is_unsigned ? hs : ge;
       break;
     case Token::IN:
     case Token::INSTANCEOF:
     default:
       UNREACHABLE();
   }
   return cond;
 }

References v8::internal::eq, v8::internal::EQ, v8::internal::ge, v8::internal::gt, v8::internal::hi, v8::internal::hs, IN, v8::internal::kNoCondition, v8::internal::le, v8::internal::lo, v8::internal::ls, v8::internal::lt, v8::internal::ne, and UNREACHABLE.

◆ TokenToCondition() [2/7]

static Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

◆ TokenToCondition() [3/7]

static Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

◆ TokenToCondition() [4/7]

static Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

◆ TokenToCondition() [5/7]

static Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

◆ TokenToCondition() [6/7]

static Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

◆ TokenToCondition() [7/7]

static Condition v8::internal::LCodeGen::TokenToCondition	(	Token::Value	op,
		bool	is_unsigned
	)

staticprivate

◆ ToMemOperand() [1/4]

MemOperand v8::internal::LCodeGen::ToMemOperand ( LOperand * op ) const

Definition at line 579 of file lithium-codegen-arm.cc.

                                                     {
   DCHECK(!op->IsRegister());
   DCHECK(!op->IsDoubleRegister());
   DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
   if (NeedsEagerFrame()) {
     return MemOperand(fp, StackSlotOffset(op->index()));
   } else {
     // Retrieve parameter without eager stack-frame relative to the
     // stack-pointer.
     return MemOperand(sp, ArgumentsOffsetWithoutFrame(op->index()));
   }
 }

References v8::internal::ArgumentsOffsetWithoutFrame(), DCHECK, v8::internal::fp, v8::internal::LOperand::index(), NeedsEagerFrame(), v8::internal::sp, and v8::internal::StackSlotOffset().

Referenced by EmitLoadDoubleRegister(), EmitLoadRegister(), and LoadContextFromDeferred().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToMemOperand() [2/4]

MemOperand v8::internal::LCodeGen::ToMemOperand ( LOperand * op ) const

◆ ToMemOperand() [3/4]

MemOperand v8::internal::LCodeGen::ToMemOperand ( LOperand * op ) const

◆ ToMemOperand() [4/4]

MemOperand v8::internal::LCodeGen::ToMemOperand	(	LOperand *	op,
		StackMode	stack_mode = `kCanUseStackPointer`
	)		const

Definition at line 1257 of file lithium-codegen-arm64.cc.

                                                                           {
   DCHECK(op != NULL);
   DCHECK(!op->IsRegister());
   DCHECK(!op->IsDoubleRegister());
   DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
   if (NeedsEagerFrame()) {
     int fp_offset = StackSlotOffset(op->index());
     if (op->index() >= 0) {
       // Loads and stores have a bigger reach in positive offset than negative.
       // When the load or the store can't be done in one instruction via fp
       // (too big negative offset), we try to access via jssp (positive offset).
       // We can reference a stack slot from jssp only if jssp references the end
       // of the stack slots. It's not the case when:
       //  - stack_mode != kCanUseStackPointer: this is the case when a deferred
       //     code saved the registers.
       //  - after_push_argument_: arguments has been pushed for a call.
       //  - inlined_arguments_: inlined arguments have been pushed once. All the
       //     remainder of the function cannot trust jssp any longer.
       //  - saves_caller_doubles: some double registers have been pushed, jssp
       //     references the end of the double registers and not the end of the
       //     stack slots.
       // Also, if the offset from fp is small enough to make a load/store in
       // one instruction, we use a fp access.
       if ((stack_mode == kCanUseStackPointer) && !after_push_argument_ &&
           !inlined_arguments_ && !is_int9(fp_offset) &&
           !info()->saves_caller_doubles()) {
         int jssp_offset =
             (GetStackSlotCount() - op->index() - 1) * kPointerSize;
         return MemOperand(masm()->StackPointer(), jssp_offset);
       }
     }
     return MemOperand(fp, fp_offset);
   } else {
     // Retrieve parameter without eager stack-frame relative to the
     // stack-pointer.
     return MemOperand(masm()->StackPointer(),
                       ArgumentsOffsetWithoutFrame(op->index()));
   }
 }

References after_push_argument_, v8::internal::ArgumentsOffsetWithoutFrame(), DCHECK, v8::internal::fp, GetStackSlotCount(), v8::internal::LOperand::index(), inlined_arguments_, kCanUseStackPointer, v8::internal::kPointerSize, NeedsEagerFrame(), NULL, and v8::internal::StackSlotOffset().

Here is the call graph for this function:

◆ ToOperand() [1/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op )

Definition at line 545 of file lithium-codegen-arm.cc.

                                         {
   if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsSmi()) {
       DCHECK(constant->HasSmiValue());
       return Operand(Smi::FromInt(constant->Integer32Value()));
     } else if (r.IsInteger32()) {
       DCHECK(constant->HasInteger32Value());
       return Operand(constant->Integer32Value());
     } else if (r.IsDouble()) {
       Abort(kToOperandUnsupportedDoubleImmediate);
     }
     DCHECK(r.IsTagged());
     return Operand(constant->handle(isolate()));
   } else if (op->IsRegister()) {
     return Operand(ToRegister(op));
   } else if (op->IsDoubleRegister()) {
     Abort(kToOperandIsDoubleRegisterUnimplemented);
     return Operand::Zero();
   }
   // Stack slots not implemented, use ToMemOperand instead.
   UNREACHABLE();
   return Operand::Zero();
 }

References chunk(), DCHECK, v8::internal::Smi::FromInt(), v8::internal::Representation::IsDouble(), v8::internal::Representation::IsInteger32(), v8::internal::Representation::IsSmi(), v8::internal::Representation::IsTagged(), ToRegister(), and UNREACHABLE.

Here is the call graph for this function:

◆ ToOperand() [2/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op )

◆ ToOperand() [3/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op )

◆ ToOperand() [4/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op )

◆ ToOperand() [5/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op ) const

◆ ToOperand() [6/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op ) const

◆ ToOperand() [7/7]

Operand v8::internal::LCodeGen::ToOperand ( LOperand * op ) const

◆ ToOperand32()

Operand v8::internal::LCodeGen::ToOperand32 ( LOperand * op )

Definition at line 1230 of file lithium-codegen-arm64.cc.

                                           {
   DCHECK(op != NULL);
   if (op->IsRegister()) {
     return Operand(ToRegister32(op));
   } else if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsInteger32()) {
       return Operand(constant->Integer32Value());
     } else {
       // Other constants not implemented.
       Abort(kToOperand32UnsupportedImmediate);
     }
   }
   // Other cases are not implemented.
   UNREACHABLE();
   return Operand(0);
 }

References chunk(), DCHECK, v8::internal::Representation::IsInteger32(), NULL, ToRegister32(), and UNREACHABLE.

Referenced by ToShiftedRightOperand32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToRegister() [1/13]

Register v8::internal::LCodeGen::ToRegister ( int index ) const

private

Definition at line 418 of file lithium-codegen-arm.cc.

                                              {
   return Register::FromAllocationIndex(index);
 }

References v8::internal::Register::FromAllocationIndex().

Here is the call graph for this function:

◆ ToRegister() [2/13]

Register v8::internal::LCodeGen::ToRegister ( int index ) const

private

◆ ToRegister() [3/13]

Register v8::internal::LCodeGen::ToRegister ( int index ) const

private

◆ ToRegister() [4/13]

Register v8::internal::LCodeGen::ToRegister ( int index ) const

private

◆ ToRegister() [5/13]

Register v8::internal::LCodeGen::ToRegister ( int index ) const

private

◆ ToRegister() [6/13]

Register v8::internal::LCodeGen::ToRegister ( int index ) const

private

◆ ToRegister() [7/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

Definition at line 428 of file lithium-codegen-arm.cc.

                                                 {
   DCHECK(op->IsRegister());
   return ToRegister(op->index());
 }

References DCHECK, and v8::internal::LOperand::index().

Referenced by AddToTranslation(), BuildSeqStringOperand(), DoDeferredAllocate(), DoDeferredInstanceOfKnownGlobal(), DoDeferredMathAbsTagged(), DoDeferredMathAbsTaggedHeapNumber(), DoDeferredNumberTagD(), DoDeferredNumberTagIU(), DoDeferredNumberTagU(), DoDeferredStringCharCodeAt(), DoDeferredStringCharFromCode(), DoDeferredTaggedToI(), DoLoadKeyedExternalArray(), DoLoadKeyedFixedArray(), DoLoadKeyedFixedDoubleArray(), DoStoreKeyedExternalArray(), DoStoreKeyedFixedArray(), DoStoreKeyedFixedDoubleArray(), EmitIntegerMathAbs(), EmitLoadRegister(), EmitVectorLoadICRegisters(), LoadContextFromDeferred(), RecordSafepoint(), ToOperand(), and ToRegister32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToRegister() [8/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

◆ ToRegister() [9/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

◆ ToRegister() [10/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

◆ ToRegister() [11/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

◆ ToRegister() [12/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

◆ ToRegister() [13/13]

Register v8::internal::LCodeGen::ToRegister ( LOperand * op ) const

◆ ToRegister32()

Register v8::internal::LCodeGen::ToRegister32 ( LOperand * op ) const

Definition at line 1177 of file lithium-codegen-arm64.cc.

                                                   {
   DCHECK(op != NULL);
   if (op->IsConstantOperand()) {
     // If this is a constant operand, the result must be the zero register.
     DCHECK(ToInteger32(LConstantOperand::cast(op)) == 0);
     return wzr;
   } else {
     return ToRegister(op).W();
   }
 }

References DCHECK, NULL, ToInteger32(), ToRegister(), and v8::internal::CPURegister::W().

Referenced by BuildSeqStringOperand(), DoDeferredNumberTagU(), DoDeferredTaggedToI(), ToOperand32(), and ToShiftedRightOperand32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToRepresentation() [1/5]

int32_t v8::internal::LCodeGen::ToRepresentation	(	LConstantOperand *	op,
		const Representation &	r
	)		const

Definition at line 522 of file lithium-codegen-arm.cc.

                                                                   {
   HConstant* constant = chunk_->LookupConstant(op);
   int32_t value = constant->Integer32Value();
   if (r.IsInteger32()) return value;
   DCHECK(r.IsSmiOrTagged());
   return reinterpret_cast<int32_t>(Smi::FromInt(value));
 }

References DCHECK, v8::internal::Smi::FromInt(), v8::internal::Representation::IsInteger32(), and v8::internal::Representation::IsSmiOrTagged().

Referenced by ToImmediate(), and ToInteger32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToRepresentation() [2/5]

int32_t v8::internal::LCodeGen::ToRepresentation	(	LConstantOperand *	op,
		const Representation &	r
	)		const

private

◆ ToRepresentation() [3/5]

int32_t v8::internal::LCodeGen::ToRepresentation	(	LConstantOperand *	op,
		const Representation &	r
	)		const

◆ ToRepresentation() [4/5]

int32_t v8::internal::LCodeGen::ToRepresentation	(	LConstantOperand *	op,
		const Representation &	r
	)		const

◆ ToRepresentation() [5/5]

int32_t v8::internal::LCodeGen::ToRepresentation	(	LConstantOperand *	op,
		const Representation &	r
	)		const

private

◆ ToRepresentation_donotuse()

int32_t v8::internal::LCodeGen::ToRepresentation_donotuse	(	LConstantOperand *	op,
		const Representation &	r
	)		const

Definition at line 464 of file lithium-codegen-mips64.cc.

                                                                   {
   HConstant* constant = chunk_->LookupConstant(op);
   int32_t value = constant->Integer32Value();
   if (r.IsInteger32()) return value;
   DCHECK(r.IsSmiOrTagged());
   return reinterpret_cast<int64_t>(Smi::FromInt(value));
 }

References DCHECK, v8::internal::Smi::FromInt(), v8::internal::Representation::IsInteger32(), and v8::internal::Representation::IsSmiOrTagged().

Here is the call graph for this function:

◆ ToShiftedRightOperand32()

template<class LI >

Operand v8::internal::LCodeGen::ToShiftedRightOperand32	(	LOperand *	right,
		LI *	shift_info
	)

Definition at line 1306 of file lithium-codegen-arm64.cc.

                                                                          {
   if (shift_info->shift() == NO_SHIFT) {
     return ToOperand32(right);
   } else {
     return Operand(
         ToRegister32(right),
         shift_info->shift(),
         JSShiftAmountFromLConstant(shift_info->shift_amount()));
   }
 }

References JSShiftAmountFromLConstant(), v8::internal::NO_SHIFT, ToOperand32(), and ToRegister32().

Here is the call graph for this function:

◆ ToSmi() [1/5]

Smi * v8::internal::LCodeGen::ToSmi ( LConstantOperand * op ) const

Definition at line 532 of file lithium-codegen-arm.cc.

                                                {
   HConstant* constant = chunk_->LookupConstant(op);
   return Smi::FromInt(constant->Integer32Value());
 }

References v8::internal::Smi::FromInt().

Here is the call graph for this function:

◆ ToSmi() [2/5]

Smi* v8::internal::LCodeGen::ToSmi ( LConstantOperand * op ) const

◆ ToSmi() [3/5]

Smi* v8::internal::LCodeGen::ToSmi ( LConstantOperand * op ) const

◆ ToSmi() [4/5]

Smi* v8::internal::LCodeGen::ToSmi ( LConstantOperand * op ) const

◆ ToSmi() [5/5]

Smi* v8::internal::LCodeGen::ToSmi ( LConstantOperand * op ) const

◆ ToX87Register() [1/2]

X87Register v8::internal::LCodeGen::ToX87Register ( int index ) const

private

◆ ToX87Register() [2/2]

X87Register v8::internal::LCodeGen::ToX87Register ( LOperand * op ) const

◆ WriteTranslation() [1/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

Definition at line 606 of file lithium-codegen-arm.cc.

                                                           {
   if (environment == NULL) return;
  
   // The translation includes one command per value in the environment.
   int translation_size = environment->translation_size();
   // The output frame height does not include the parameters.
   int height = translation_size - environment->parameter_count();
  
   WriteTranslation(environment->outer(), translation);
   bool has_closure_id = !info()->closure().is_null() &&
       !info()->closure().is_identical_to(environment->closure());
   int closure_id = has_closure_id
       ? DefineDeoptimizationLiteral(environment->closure())
       : Translation::kSelfLiteralId;
  
   switch (environment->frame_type()) {
     case JS_FUNCTION:
       translation->BeginJSFrame(environment->ast_id(), closure_id, height);
       break;
     case JS_CONSTRUCT:
       translation->BeginConstructStubFrame(closure_id, translation_size);
       break;
     case JS_GETTER:
       DCHECK(translation_size == 1);
       DCHECK(height == 0);
       translation->BeginGetterStubFrame(closure_id);
       break;
     case JS_SETTER:
       DCHECK(translation_size == 2);
       DCHECK(height == 0);
       translation->BeginSetterStubFrame(closure_id);
       break;
     case STUB:
       translation->BeginCompiledStubFrame();
       break;
     case ARGUMENTS_ADAPTOR:
       translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);
       break;
   }
  
   int object_index = 0;
   int dematerialized_index = 0;
   for (int i = 0; i < translation_size; ++i) {
     LOperand* value = environment->values()->at(i);
     AddToTranslation(environment,
                      translation,
                      value,
                      environment->HasTaggedValueAt(i),
                      environment->HasUint32ValueAt(i),
                      &object_index,
                      &dematerialized_index);
   }
 }

References AddToTranslation(), v8::internal::ARGUMENTS_ADAPTOR, DCHECK, DefineDeoptimizationLiteral(), v8::internal::JS_CONSTRUCT, v8::internal::JS_FUNCTION, v8::internal::JS_GETTER, v8::internal::JS_SETTER, NULL, and v8::internal::STUB.

Referenced by RegisterEnvironmentForDeoptimization().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WriteTranslation() [2/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

private

◆ WriteTranslation() [3/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

◆ WriteTranslation() [4/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

◆ WriteTranslation() [5/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

◆ WriteTranslation() [6/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

◆ WriteTranslation() [7/7]

void v8::internal::LCodeGen::WriteTranslation	(	LEnvironment *	environment,
		Translation *	translation
	)

◆ X87CommitWrite()

void v8::internal::LCodeGen::X87CommitWrite ( X87Register reg )

inline

Definition at line 97 of file lithium-codegen-x87.h.

97 { x87_stack_.CommitWrite(reg); }

v8::internal::LCodeGen::X87Stack::CommitWrite

void CommitWrite(X87Register reg)

References v8::internal::LCodeGen::X87Stack::CommitWrite(), and x87_stack_.

Here is the call graph for this function:

◆ X87Fld()

void v8::internal::LCodeGen::X87Fld	(	Operand	src,
		X87OperandType	opts
	)

private

◆ X87Free()

void v8::internal::LCodeGen::X87Free ( X87Register reg )

inline

Definition at line 102 of file lithium-codegen-x87.h.

                                 {
     x87_stack_.Free(reg);
   }

References v8::internal::LCodeGen::X87Stack::Free(), and x87_stack_.

Here is the call graph for this function:

◆ X87Fxch()

void v8::internal::LCodeGen::X87Fxch	(	X87Register	reg,
		int	other_slot = `0`
	)

inline

Definition at line 99 of file lithium-codegen-x87.h.

                                                     {
     x87_stack_.Fxch(reg, other_slot);
   }

References v8::internal::LCodeGen::X87Stack::Fxch(), and x87_stack_.

Here is the call graph for this function:

◆ X87LoadForUsage() [1/2]

void v8::internal::LCodeGen::X87LoadForUsage ( X87Register reg )

◆ X87LoadForUsage() [2/2]

void v8::internal::LCodeGen::X87LoadForUsage	(	X87Register	reg1,
		X87Register	reg2
	)

◆ X87Mov() [1/3]

void v8::internal::LCodeGen::X87Mov	(	Operand	src,
		X87Register	reg,
		X87OperandType	operand = `kX87DoubleOperand`
	)

◆ X87Mov() [2/3]

void v8::internal::LCodeGen::X87Mov	(	X87Register	reg,
		Operand	src,
		X87OperandType	operand = `kX87DoubleOperand`
	)

◆ X87Mov() [3/3]

void v8::internal::LCodeGen::X87Mov	(	X87Register	reg,
		X87Register	src,
		X87OperandType	operand = `kX87DoubleOperand`
	)

◆ X87PrepareBinaryOp()

void v8::internal::LCodeGen::X87PrepareBinaryOp	(	X87Register	left,
		X87Register	right,
		X87Register	result
	)

◆ X87PrepareToWrite()

void v8::internal::LCodeGen::X87PrepareToWrite ( X87Register reg )

inline

Definition at line 96 of file lithium-codegen-x87.h.

96 { x87_stack_.PrepareToWrite(reg); }

v8::internal::LCodeGen::X87Stack::PrepareToWrite

void PrepareToWrite(X87Register reg)

References v8::internal::LCodeGen::X87Stack::PrepareToWrite(), and x87_stack_.

Here is the call graph for this function:

◆ X87StackEmpty()

bool v8::internal::LCodeGen::X87StackEmpty ( )

inline

Definition at line 107 of file lithium-codegen-x87.h.

                        {
     return x87_stack_.depth() == 0;
   }

References v8::internal::LCodeGen::X87Stack::depth(), and x87_stack_.

Here is the call graph for this function:

Friends And Related Function Documentation

◆ LDeferredCode

LDeferredCode

friend

Definition at line 373 of file lithium-codegen-arm.h.

◆ LEnvironment

LEnvironment

friend

Definition at line 374 of file lithium-codegen-arm.h.

Referenced by DeoptimizeBranch(), DeoptimizeIf(), DoDeferredInstanceOfKnownGlobal(), DoDeferredStackCheck(), PopulateDeoptimizationData(), and RegisterEnvironmentForDeoptimization().

◆ LGapResolver

LGapResolver

friend

Definition at line 324 of file lithium-codegen-ia32.h.

◆ SafepointGenerator

SafepointGenerator

friend

Definition at line 375 of file lithium-codegen-arm.h.

Referenced by CallKnownFunction().

◆ X87Stack

friend class X87Stack

friend

Definition at line 474 of file lithium-codegen-x87.h.

Member Data Documentation

◆ after_push_argument_

bool v8::internal::LCodeGen::after_push_argument_

private

Definition at line 369 of file lithium-codegen-arm64.h.

Referenced by ToMemOperand(), and ~LCodeGen().

◆ deferred_

ZoneList< LDeferredCode * > v8::internal::LCodeGen::deferred_

private

Definition at line 340 of file lithium-codegen-arm.h.

Referenced by AddDeferredCode(), and GenerateDeferredCode().

◆ deoptimization_literals_

ZoneList< Handle< Object > > v8::internal::LCodeGen::deoptimization_literals_

private

Definition at line 336 of file lithium-codegen-arm.h.

Referenced by DefineDeoptimizationLiteral(), PopulateDeoptimizationData(), and PopulateDeoptimizationLiteralsWithInlinedFunctions().

◆ deoptimizations_

ZoneList< LEnvironment * > v8::internal::LCodeGen::deoptimizations_

private

Definition at line 334 of file lithium-codegen-arm.h.

Referenced by PopulateDeoptimizationData(), and RegisterEnvironmentForDeoptimization().

◆ dynamic_frame_alignment_

bool v8::internal::LCodeGen::dynamic_frame_alignment_

private

Definition at line 341 of file lithium-codegen-ia32.h.

◆ expected_safepoint_kind_

Safepoint::Kind v8::internal::LCodeGen::expected_safepoint_kind_

private

Definition at line 351 of file lithium-codegen-arm.h.

Referenced by RecordSafepoint().

◆ frame_is_built_

bool v8::internal::LCodeGen::frame_is_built_

private

Definition at line 342 of file lithium-codegen-arm.h.

Referenced by DeoptimizeBranch(), DeoptimizeIf(), GenerateDeferredCode(), GeneratePrologue(), GetLinkRegisterState(), and GetRAState().

◆ inlined_arguments_

bool v8::internal::LCodeGen::inlined_arguments_

private

Definition at line 373 of file lithium-codegen-arm64.h.

Referenced by ToMemOperand(), and ~LCodeGen().

◆ inlined_function_count_

int v8::internal::LCodeGen::inlined_function_count_

private

Definition at line 337 of file lithium-codegen-arm.h.

Referenced by PopulateDeoptimizationData(), and PopulateDeoptimizationLiteralsWithInlinedFunctions().

◆ jump_table_ [1/2]

ZoneList< Deoptimizer::JumpTableEntry > v8::internal::LCodeGen::jump_table_

private

Definition at line 335 of file lithium-codegen-arm.h.

Referenced by DeoptimizeBranch(), DeoptimizeIf(), and GenerateJumpTable().

◆ jump_table_ [2/2]

ZoneList<Deoptimizer::JumpTableEntry*> v8::internal::LCodeGen::jump_table_

private

Definition at line 348 of file lithium-codegen-arm64.h.

◆ old_position_

int v8::internal::LCodeGen::old_position_

private

Definition at line 375 of file lithium-codegen-arm64.h.

◆ osr_pc_offset_

int v8::internal::LCodeGen::osr_pc_offset_

private

Definition at line 341 of file lithium-codegen-arm.h.

Referenced by GenerateOsrPrologue(), and PopulateDeoptimizationData().

◆ resolver_

LGapResolver v8::internal::LCodeGen::resolver_

private

Definition at line 349 of file lithium-codegen-arm.h.

Referenced by DoParallelMove().

◆ safepoints_

SafepointTableBuilder v8::internal::LCodeGen::safepoints_

private

Definition at line 346 of file lithium-codegen-arm.h.

Referenced by DoDeferredInstanceOfKnownGlobal(), DoDeferredStackCheck(), FinishCode(), GenerateBodyInstructionPre(), GenerateSafepointTable(), and RecordSafepoint().

◆ scope_

Scope *const v8::internal::LCodeGen::scope_

private

Definition at line 338 of file lithium-codegen-arm.h.

Referenced by scope().

◆ support_aligned_spilled_doubles_

bool v8::internal::LCodeGen::support_aligned_spilled_doubles_

private

Definition at line 342 of file lithium-codegen-ia32.h.

◆ translations_

TranslationBuffer v8::internal::LCodeGen::translations_

private

Definition at line 339 of file lithium-codegen-arm.h.

Referenced by PopulateDeoptimizationData(), and RegisterEnvironmentForDeoptimization().

◆ x87_stack_

X87Stack v8::internal::LCodeGen::x87_stack_

private

Definition at line 437 of file lithium-codegen-x87.h.

Referenced by FlushX87StackIfNecessary(), X87CommitWrite(), X87Free(), X87Fxch(), X87PrepareToWrite(), and X87StackEmpty().

◆ x87_stack_map_

X87StackMap v8::internal::LCodeGen::x87_stack_map_

private

Definition at line 440 of file lithium-codegen-x87.h.

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

/mnt/V8SourceCode/src/arm/lithium-codegen-arm.h
/mnt/V8SourceCode/src/x87/lithium-codegen-x87.h
/mnt/V8SourceCode/src/arm64/lithium-codegen-arm64.h
/mnt/V8SourceCode/src/ia32/lithium-codegen-ia32.h
/mnt/V8SourceCode/src/mips/lithium-codegen-mips.h
/mnt/V8SourceCode/src/mips64/lithium-codegen-mips64.h
/mnt/V8SourceCode/src/x64/lithium-codegen-x64.h
/mnt/V8SourceCode/src/arm/lithium-codegen-arm.cc
/mnt/V8SourceCode/src/arm64/lithium-codegen-arm64.cc
/mnt/V8SourceCode/src/mips/lithium-codegen-mips.cc
/mnt/V8SourceCode/src/mips64/lithium-codegen-mips64.cc

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ X87StackMap

Member Enumeration Documentation

◆ A1State [1/2]

◆ A1State [2/2]

◆ EDIState [1/2]

◆ EDIState [2/2]

◆ IntegerSignedness [1/7]

◆ IntegerSignedness [2/7]

◆ IntegerSignedness [3/7]

◆ IntegerSignedness [4/7]

◆ IntegerSignedness [5/7]

◆ IntegerSignedness [6/7]

◆ IntegerSignedness [7/7]

◆ R1State

◆ RDIState

◆ SafepointMode [1/7]

◆ SafepointMode [2/7]

◆ SafepointMode [3/7]

◆ SafepointMode [4/7]

◆ SafepointMode [5/7]

◆ SafepointMode [6/7]

◆ SafepointMode [7/7]

◆ StackMode

◆ X87OperandType

Constructor & Destructor Documentation

◆ LCodeGen() [1/7]

◆ LCodeGen() [2/7]

◆ ~LCodeGen()

◆ LCodeGen() [3/7]

◆ LCodeGen() [4/7]

◆ LCodeGen() [5/7]

◆ LCodeGen() [6/7]

◆ LCodeGen() [7/7]

Member Function Documentation

◆ AddDeferredCode() [1/7]

◆ AddDeferredCode() [2/7]

◆ AddDeferredCode() [3/7]

◆ AddDeferredCode() [4/7]

◆ AddDeferredCode() [5/7]

◆ AddDeferredCode() [6/7]

◆ AddDeferredCode() [7/7]

◆ AddToTranslation() [1/7]

◆ AddToTranslation() [2/7]

◆ AddToTranslation() [3/7]

◆ AddToTranslation() [4/7]

◆ AddToTranslation() [5/7]

◆ AddToTranslation() [6/7]

◆ AddToTranslation() [7/7]

◆ BuildFastArrayOperand() [1/3]

◆ BuildFastArrayOperand() [2/3]

◆ BuildFastArrayOperand() [3/3]

◆ BuildSeqStringOperand() [1/7]

◆ BuildSeqStringOperand() [2/7]

◆ BuildSeqStringOperand() [3/7]

◆ BuildSeqStringOperand() [4/7]

◆ BuildSeqStringOperand() [5/7]

◆ BuildSeqStringOperand() [6/7]

◆ BuildSeqStringOperand() [7/7]

◆ CallCode() [1/7]

◆ CallCode() [2/7]

◆ CallCode() [3/7]

◆ CallCode() [4/7]

◆ CallCode() [5/7]

◆ CallCode() [6/7]

◆ CallCode() [7/7]

◆ CallCodeGeneric() [1/7]

◆ CallCodeGeneric() [2/7]

◆ CallCodeGeneric() [3/7]

◆ CallCodeGeneric() [4/7]

◆ CallCodeGeneric() [5/7]