Inheritance diagram for v8::internal::AccessorAssembler:

Classes
struct	LoadICParameters

struct	StoreICParameters

Public Types
enum	StubCacheTable : int

using	Node = compiler::Node

template<class T >
using	TNode = compiler::TNode< T >

template<class T >
using	SloppyTNode = compiler::SloppyTNode< T >

Public Types inherited from v8::internal::CodeStubAssembler
enum	AllocationFlag : uint8_t { kNone = 0, kDoubleAlignment = 1, kPretenured = 1 << 1, kAllowLargeObjectAllocation = 1 << 2 }

enum	SlackTrackingMode { kWithSlackTracking, kNoSlackTracking }

enum	ParameterMode { SMI_PARAMETERS, INTPTR_PARAMETERS }

enum	HoleConversionMode { kDontConvert, kConvertToUndefined }

enum	DestroySource { kNo, kYes }

enum	ExtractFixedArrayFlag { kFixedArrays = 1, kFixedDoubleArrays = 2, kDontCopyCOW = 4, kNewSpaceAllocationOnly = 8, kAllFixedArrays = kFixedArrays \| kFixedDoubleArrays, kAllFixedArraysDontCopyCOW = kAllFixedArrays \| kDontCopyCOW }

enum	BigIntHandling { kConvertToNumber, kThrow }

enum	ToIntegerTruncationMode { kNoTruncation, kTruncateMinusZero }

enum	LookupMode { kFindExisting, kFindInsertionIndex }

enum	GetOwnPropertyMode { kCallJSGetter, kReturnAccessorPair }

enum	IndexAdvanceMode { kPre, kPost }

enum	ForEachDirection { kForward, kReverse }

enum	HasPropertyLookupMode { kHasProperty, kForInHasProperty }

using	Node = compiler::Node

template<class T >
using	TNode = compiler::TNode< T >

template<class T >
using	SloppyTNode = compiler::SloppyTNode< T >

template<typename T >
using	LazyNode = std::function< TNode< T >()>

typedef base::Flags< AllocationFlag >	AllocationFlags

typedef std::function< void(Label , Label )>	BranchGenerator

typedef std::function< Node *()>	NodeGenerator

typedef base::Flags< ExtractFixedArrayFlag >	ExtractFixedArrayFlags

typedef std::function< void(Node receiver, Node holder, Node map, Node instance_type, Node key, Label next_holder, Label *if_bailout)>	LookupInHolder

typedef std::function< void(Node *index)>	FastLoopBody

typedef std::function< void(Node fixed_array, Node offset)>	FastFixedArrayForEachBody

typedef std::function< void(TNode< IntPtrT > descriptor_key_index)>	ForEachDescriptorBodyFunction

typedef std::function< void(TNode< Name > key, TNode< Object > value)>	ForEachKeyValueFunction

Public Types inherited from v8::internal::compiler::CodeAssembler
using	Label = CodeAssemblerLabel

using	Variable = CodeAssemblerVariable

template<class T >
using	TVariable = TypedCodeAssemblerVariable< T >

using	VariableList = CodeAssemblerVariableList

Public Member Functions
	AccessorAssembler (compiler::CodeAssemblerState *state)

void	GenerateLoadIC ()

void	GenerateLoadIC_Megamorphic ()

void	GenerateLoadIC_Noninlined ()

void	GenerateLoadIC_Uninitialized ()

void	GenerateLoadICTrampoline ()

void	GenerateLoadICTrampoline_Megamorphic ()

void	GenerateKeyedLoadIC ()

void	GenerateKeyedLoadIC_Megamorphic ()

void	GenerateKeyedLoadIC_PolymorphicName ()

void	GenerateKeyedLoadICTrampoline ()

void	GenerateKeyedLoadICTrampoline_Megamorphic ()

void	GenerateStoreIC ()

void	GenerateStoreICTrampoline ()

void	GenerateStoreGlobalIC ()

void	GenerateStoreGlobalICTrampoline ()

void	GenerateCloneObjectIC ()

void	GenerateCloneObjectIC_Slow ()

void	GenerateLoadGlobalIC (TypeofMode typeof_mode)

void	GenerateLoadGlobalICTrampoline (TypeofMode typeof_mode)

void	GenerateKeyedStoreIC ()

void	GenerateKeyedStoreICTrampoline ()

void	GenerateStoreInArrayLiteralIC ()

void	TryProbeStubCache (StubCache stub_cache, Node receiver, Node name, Label if_handler, TVariable< MaybeObject > var_handler, Label if_miss)

Node *	StubCachePrimaryOffsetForTesting (Node name, Node map)

Node *	StubCacheSecondaryOffsetForTesting (Node name, Node map)

void	LoadGlobalIC (TNode< FeedbackVector > vector, Node slot, const LazyNode< Context > &lazy_context, const LazyNode< Name > &lazy_name, TypeofMode typeof_mode, ExitPoint exit_point, ParameterMode slot_mode=SMI_PARAMETERS)

void	LoadIC_BytecodeHandler (const LoadICParameters p, ExitPoint exit_point)

TNode< MaybeObject >	LoadHandlerDataField (SloppyTNode< DataHandler > handler, int data_index)

Public Member Functions inherited from v8::internal::CodeStubAssembler
	CodeStubAssembler (compiler::CodeAssemblerState *state)

ParameterMode	OptimalParameterMode () const

MachineRepresentation	ParameterRepresentation (ParameterMode mode) const

MachineRepresentation	OptimalParameterRepresentation () const

TNode< IntPtrT >	ParameterToIntPtr (Node *value, ParameterMode mode)

Node *	IntPtrToParameter (SloppyTNode< IntPtrT > value, ParameterMode mode)

Node *	Int32ToParameter (SloppyTNode< Int32T > value, ParameterMode mode)

TNode< Smi >	ParameterToTagged (Node *value, ParameterMode mode)

Node *	TaggedToParameter (SloppyTNode< Smi > value, ParameterMode mode)

TNode< Smi >	TaggedToSmi (TNode< Object > value, Label *fail)

TNode< Number >	TaggedToNumber (TNode< Object > value, Label *fail)

TNode< HeapObject >	TaggedToHeapObject (TNode< Object > value, Label *fail)

TNode< JSArray >	HeapObjectToJSArray (TNode< HeapObject > heap_object, Label *fail)

TNode< JSArray >	TaggedToFastJSArray (TNode< Context > context, TNode< Object > value, Label *fail)

TNode< JSDataView >	HeapObjectToJSDataView (TNode< HeapObject > heap_object, Label *fail)

TNode< JSReceiver >	HeapObjectToCallable (TNode< HeapObject > heap_object, Label *fail)

TNode< String >	HeapObjectToString (TNode< HeapObject > heap_object, Label *fail)

TNode< JSReceiver >	HeapObjectToConstructor (TNode< HeapObject > heap_object, Label *fail)

Node *	MatchesParameterMode (Node *value, ParameterMode mode)

	PARAMETER_BINOP (IntPtrOrSmiLessThanOrEqual, IntPtrLessThanOrEqual, SmiLessThanOrEqual) PARAMETER_BINOP(IntPtrOrSmiGreaterThanOrEqual

SmiGreaterThanOrEqual	PARAMETER_BINOP (UintPtrOrSmiGreaterThanOrEqual, UintPtrGreaterThanOrEqual, SmiAboveOrEqual) TNode< Object > NoContextConstant()

Node *	IntPtrOrSmiConstant (int value, ParameterMode mode)

TNode< Smi >	LanguageModeConstant (LanguageMode mode)

bool	IsIntPtrOrSmiConstantZero (Node *test, ParameterMode mode)

bool	TryGetIntPtrOrSmiConstantValue (Node maybe_constant, int value, ParameterMode mode)

TNode< IntPtrT >	IntPtrRoundUpToPowerOfTwo32 (TNode< IntPtrT > value)

TNode< IntPtrT >	IntPtrMax (SloppyTNode< IntPtrT > left, SloppyTNode< IntPtrT > right)

TNode< IntPtrT >	IntPtrMin (SloppyTNode< IntPtrT > left, SloppyTNode< IntPtrT > right)

TNode< Float64T >	Float64Ceil (SloppyTNode< Float64T > x)

TNode< Float64T >	Float64Floor (SloppyTNode< Float64T > x)

TNode< Float64T >	Float64Round (SloppyTNode< Float64T > x)

TNode< Float64T >	Float64RoundToEven (SloppyTNode< Float64T > x)

TNode< Float64T >	Float64Trunc (SloppyTNode< Float64T > x)

TNode< Number >	NumberMax (SloppyTNode< Number > left, SloppyTNode< Number > right)

TNode< Number >	NumberMin (SloppyTNode< Number > left, SloppyTNode< Number > right)

TNode< IntPtrT >	ConvertToRelativeIndex (TNode< Context > context, TNode< Object > index, TNode< IntPtrT > length)

TNode< BoolT >	IsValidPositiveSmi (TNode< IntPtrT > value)

TNode< Smi >	SmiTag (SloppyTNode< IntPtrT > value)

TNode< IntPtrT >	SmiUntag (SloppyTNode< Smi > value)

TNode< Float64T >	SmiToFloat64 (SloppyTNode< Smi > value)

TNode< Smi >	SmiFromIntPtr (SloppyTNode< IntPtrT > value)

TNode< Smi >	SmiFromInt32 (SloppyTNode< Int32T > value)

TNode< IntPtrT >	SmiToIntPtr (SloppyTNode< Smi > value)

TNode< Int32T >	SmiToInt32 (SloppyTNode< Smi > value)

TNode< Smi >	SmiInc (TNode< Smi > value)

TNode< IntPtrT >	TryIntPtrAdd (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_overflow)

TNode< Smi >	TrySmiAdd (TNode< Smi > a, TNode< Smi > b, Label *if_overflow)

TNode< Smi >	TrySmiSub (TNode< Smi > a, TNode< Smi > b, Label *if_overflow)

TNode< Smi >	SmiShl (TNode< Smi > a, int shift)

TNode< Smi >	SmiShr (TNode< Smi > a, int shift)

Node *	WordOrSmiShl (Node *a, int shift, ParameterMode mode)

Node *	WordOrSmiShr (Node *a, int shift, ParameterMode mode)

	SMI_COMPARISON_OP (SmiAboveOrEqual, UintPtrGreaterThanOrEqual, Uint32GreaterThanOrEqual) SMI_COMPARISON_OP(SmiLessThanOrEqual

Int32LessThanOrEqual	SMI_COMPARISON_OP (SmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual, Int32GreaterThanOrEqual) TNode< Smi > SmiMax(TNode< Smi > a

TNode< Smi >	SmiMin (TNode< Smi > a, TNode< Smi > b)

TNode< Number >	SmiMod (TNode< Smi > a, TNode< Smi > b)

TNode< Number >	SmiMul (TNode< Smi > a, TNode< Smi > b)

TNode< Smi >	TrySmiDiv (TNode< Smi > dividend, TNode< Smi > divisor, Label *bailout)

TNode< Smi >	SmiLexicographicCompare (TNode< Smi > x, TNode< Smi > y)

TNode< Number >	NumberInc (SloppyTNode< Number > value)

TNode< Number >	NumberDec (SloppyTNode< Number > value)

TNode< Number >	NumberAdd (SloppyTNode< Number > a, SloppyTNode< Number > b)

TNode< Number >	NumberSub (SloppyTNode< Number > a, SloppyTNode< Number > b)

void	GotoIfNotNumber (Node value, Label is_not_number)

void	GotoIfNumber (Node value, Label is_number)

TNode< Number >	SmiToNumber (TNode< Smi > v)

TNode< Number >	BitwiseOp (Node left32, Node right32, Operation bitwise_op)

TNode< HeapObject >	AllocateInNewSpace (TNode< IntPtrT > size, AllocationFlags flags=kNone)

TNode< HeapObject >	AllocateInNewSpace (int size, AllocationFlags flags=kNone)

TNode< HeapObject >	Allocate (TNode< IntPtrT > size, AllocationFlags flags=kNone)

TNode< HeapObject >	Allocate (int size, AllocationFlags flags=kNone)

TNode< HeapObject >	InnerAllocate (TNode< HeapObject > previous, int offset)

TNode< HeapObject >	InnerAllocate (TNode< HeapObject > previous, TNode< IntPtrT > offset)

TNode< BoolT >	IsRegularHeapObjectSize (TNode< IntPtrT > size)

void	Assert (const BranchGenerator &branch, const char message=nullptr, const char file=nullptr, int line=0, Node extra_node1=nullptr, const char extra_node1_name="", Node extra_node2=nullptr, const char extra_node2_name="", Node extra_node3=nullptr, const char extra_node3_name="", Node extra_node4=nullptr, const char extra_node4_name="", Node extra_node5=nullptr, const char extra_node5_name="")

void	Assert (const NodeGenerator &condition_body, const char message=nullptr, const char file=nullptr, int line=0, Node extra_node1=nullptr, const char extra_node1_name="", Node extra_node2=nullptr, const char extra_node2_name="", Node extra_node3=nullptr, const char extra_node3_name="", Node extra_node4=nullptr, const char extra_node4_name="", Node extra_node5=nullptr, const char extra_node5_name="")

void	Check (const BranchGenerator &branch, const char message=nullptr, const char file=nullptr, int line=0, Node extra_node1=nullptr, const char extra_node1_name="", Node extra_node2=nullptr, const char extra_node2_name="", Node extra_node3=nullptr, const char extra_node3_name="", Node extra_node4=nullptr, const char extra_node4_name="", Node extra_node5=nullptr, const char extra_node5_name="")

void	Check (const NodeGenerator &condition_body, const char message=nullptr, const char file=nullptr, int line=0, Node extra_node1=nullptr, const char extra_node1_name="", Node extra_node2=nullptr, const char extra_node2_name="", Node extra_node3=nullptr, const char extra_node3_name="", Node extra_node4=nullptr, const char extra_node4_name="", Node extra_node5=nullptr, const char extra_node5_name="")

void	FailAssert (const char message=nullptr, const char file=nullptr, int line=0, Node extra_node1=nullptr, const char extra_node1_name="", Node extra_node2=nullptr, const char extra_node2_name="", Node extra_node3=nullptr, const char extra_node3_name="", Node extra_node4=nullptr, const char extra_node4_name="", Node extra_node5=nullptr, const char extra_node5_name="")

void	FastCheck (TNode< BoolT > condition)

template<class... TArgs>
TNode< Object >	Call (TNode< Context > context, TNode< Object > callable, TNode< JSReceiver > receiver, TArgs... args)

template<class... TArgs>
TNode< Object >	Call (TNode< Context > context, TNode< Object > callable, TNode< Object > receiver, TArgs... args)

template<class... TArgs>
TNode< JSReceiver >	Construct (TNode< Context > context, TNode< JSReceiver > new_target, TArgs... args)

template<class A , class F , class G >
TNode< A >	Select (SloppyTNode< BoolT > condition, const F &true_body, const G &false_body)

template<class A >
TNode< A >	SelectConstant (TNode< BoolT > condition, TNode< A > true_value, TNode< A > false_value)

TNode< Int32T >	SelectInt32Constant (SloppyTNode< BoolT > condition, int true_value, int false_value)

TNode< IntPtrT >	SelectIntPtrConstant (SloppyTNode< BoolT > condition, int true_value, int false_value)

TNode< Oddball >	SelectBooleanConstant (SloppyTNode< BoolT > condition)

TNode< Smi >	SelectSmiConstant (SloppyTNode< BoolT > condition, Smi true_value, Smi false_value)

TNode< Smi >	SelectSmiConstant (SloppyTNode< BoolT > condition, int true_value, Smi false_value)

TNode< Smi >	SelectSmiConstant (SloppyTNode< BoolT > condition, Smi true_value, int false_value)

TNode< Smi >	SelectSmiConstant (SloppyTNode< BoolT > condition, int true_value, int false_value)

TNode< Int32T >	TruncateIntPtrToInt32 (SloppyTNode< IntPtrT > value)

TNode< BoolT >	TaggedIsSmi (SloppyTNode< Object > a)

TNode< BoolT >	TaggedIsSmi (TNode< MaybeObject > a)

TNode< BoolT >	TaggedIsNotSmi (SloppyTNode< Object > a)

TNode< BoolT >	TaggedIsPositiveSmi (SloppyTNode< Object > a)

TNode< BoolT >	WordIsWordAligned (SloppyTNode< WordT > word)

TNode< BoolT >	WordIsPowerOfTwo (SloppyTNode< IntPtrT > value)

void	Bind (Label *label)

template<class... T>
void	Bind (compiler::CodeAssemblerParameterizedLabel< T... > label, TNode< T > ... phis)

void	BranchIfSmiEqual (TNode< Smi > a, TNode< Smi > b, Label if_true, Label if_false)

void	BranchIfSmiLessThan (TNode< Smi > a, TNode< Smi > b, Label if_true, Label if_false)

void	BranchIfSmiLessThanOrEqual (TNode< Smi > a, TNode< Smi > b, Label if_true, Label if_false)

void	BranchIfFloat64IsNaN (Node value, Label if_true, Label *if_false)

void	BranchIfToBooleanIsTrue (Node value, Label if_true, Label *if_false)

void	BranchIfJSReceiver (Node object, Label if_true, Label *if_false)

void	GotoIfForceSlowPath (Label *if_true)

void	GotoIfDebugExecutionModeChecksSideEffects (Label *if_true)

Node *	LoadFromFrame (int offset, MachineType rep=MachineType::AnyTagged())

Node *	LoadFromParentFrame (int offset, MachineType rep=MachineType::AnyTagged())

TNode< JSFunction >	LoadTargetFromFrame ()

Node *	LoadBufferObject (Node *buffer, int offset, MachineType rep=MachineType::AnyTagged())

Node *	LoadObjectField (SloppyTNode< HeapObject > object, int offset, MachineType rep)

template<class T , typename std::enable_if< std::is_convertible< TNode< T >, TNode< Object >>::value, int >::type = 0>
TNode< T >	LoadObjectField (TNode< HeapObject > object, int offset)

template<class T , typename std::enable_if< std::is_convertible< TNode< T >, TNode< UntaggedT >>::value, int >::type = 0>
TNode< T >	LoadObjectField (TNode< HeapObject > object, int offset)

TNode< Object >	LoadObjectField (SloppyTNode< HeapObject > object, int offset)

Node *	LoadObjectField (SloppyTNode< HeapObject > object, SloppyTNode< IntPtrT > offset, MachineType rep)

TNode< Object >	LoadObjectField (SloppyTNode< HeapObject > object, SloppyTNode< IntPtrT > offset)

template<class T , typename std::enable_if< std::is_convertible< TNode< T >, TNode< UntaggedT >>::value, int >::type = 0>
TNode< T >	LoadObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset)

TNode< IntPtrT >	LoadAndUntagObjectField (SloppyTNode< HeapObject > object, int offset)

TNode< Int32T >	LoadAndUntagToWord32ObjectField (Node *object, int offset)

TNode< IntPtrT >	LoadAndUntagSmi (Node *base, int index)

TNode< Int32T >	LoadAndUntagToWord32Root (RootIndex root_index)

TNode< MaybeObject >	LoadMaybeWeakObjectField (SloppyTNode< HeapObject > object, int offset)

Node *	StoreAndTagSmi (Node base, int offset, Node value)

TNode< Float64T >	LoadHeapNumberValue (SloppyTNode< HeapNumber > object)

TNode< Map >	LoadMap (SloppyTNode< HeapObject > object)

TNode< Int32T >	LoadInstanceType (SloppyTNode< HeapObject > object)

TNode< BoolT >	HasInstanceType (SloppyTNode< HeapObject > object, InstanceType type)

TNode< BoolT >	DoesntHaveInstanceType (SloppyTNode< HeapObject > object, InstanceType type)

TNode< BoolT >	TaggedDoesntHaveInstanceType (SloppyTNode< HeapObject > any_tagged, InstanceType type)

TNode< HeapObject >	LoadSlowProperties (SloppyTNode< JSObject > object)

TNode< HeapObject >	LoadFastProperties (SloppyTNode< JSObject > object)

TNode< FixedArrayBase >	LoadElements (SloppyTNode< JSObject > object)

TNode< Object >	LoadJSArgumentsObjectWithLength (SloppyTNode< JSArgumentsObjectWithLength > array)

TNode< Number >	LoadJSArrayLength (SloppyTNode< JSArray > array)

TNode< Smi >	LoadFastJSArrayLength (SloppyTNode< JSArray > array)

TNode< Smi >	LoadFixedArrayBaseLength (SloppyTNode< FixedArrayBase > array)

TNode< IntPtrT >	LoadAndUntagFixedArrayBaseLength (SloppyTNode< FixedArrayBase > array)

TNode< Smi >	LoadWeakFixedArrayLength (TNode< WeakFixedArray > array)

TNode< IntPtrT >	LoadAndUntagWeakFixedArrayLength (SloppyTNode< WeakFixedArray > array)

TNode< Int32T >	LoadNumberOfDescriptors (TNode< DescriptorArray > array)

TNode< Int32T >	LoadMapBitField (SloppyTNode< Map > map)

TNode< Int32T >	LoadMapBitField2 (SloppyTNode< Map > map)

TNode< Uint32T >	LoadMapBitField3 (SloppyTNode< Map > map)

TNode< Int32T >	LoadMapInstanceType (SloppyTNode< Map > map)

TNode< Int32T >	LoadMapElementsKind (SloppyTNode< Map > map)

TNode< Int32T >	LoadElementsKind (SloppyTNode< HeapObject > object)

TNode< DescriptorArray >	LoadMapDescriptors (SloppyTNode< Map > map)

TNode< HeapObject >	LoadMapPrototype (SloppyTNode< Map > map)

TNode< PrototypeInfo >	LoadMapPrototypeInfo (SloppyTNode< Map > map, Label *if_has_no_proto_info)

TNode< IntPtrT >	LoadMapInstanceSizeInWords (SloppyTNode< Map > map)

TNode< IntPtrT >	LoadMapInobjectPropertiesStartInWords (SloppyTNode< Map > map)

TNode< IntPtrT >	LoadMapConstructorFunctionIndex (SloppyTNode< Map > map)

TNode< Object >	LoadMapConstructor (SloppyTNode< Map > map)

Node *	LoadMapEnumLength (SloppyTNode< Map > map)

TNode< Object >	LoadMapBackPointer (SloppyTNode< Map > map)

TNode< Uint32T >	EnsureOnlyHasSimpleProperties (TNode< Map > map, TNode< Int32T > instance_type, Label *bailout)

TNode< IntPtrT >	LoadJSReceiverIdentityHash (SloppyTNode< Object > receiver, Label *if_no_hash=nullptr)

void	InitializePropertyArrayLength (Node property_array, Node length, ParameterMode mode)

TNode< BoolT >	IsDictionaryMap (SloppyTNode< Map > map)

TNode< Uint32T >	LoadNameHashField (SloppyTNode< Name > name)

TNode< Uint32T >	LoadNameHash (SloppyTNode< Name > name, Label *if_hash_not_computed=nullptr)

TNode< Smi >	LoadStringLengthAsSmi (SloppyTNode< String > string)

TNode< IntPtrT >	LoadStringLengthAsWord (SloppyTNode< String > string)

TNode< Uint32T >	LoadStringLengthAsWord32 (SloppyTNode< String > string)

Node *	PointerToSeqStringData (Node *seq_string)

Node *	LoadJSValueValue (Node *object)

void	DispatchMaybeObject (TNode< MaybeObject > maybe_object, Label if_smi, Label if_cleared, Label if_weak, Label if_strong, TVariable< Object > *extracted)

TNode< BoolT >	IsStrong (TNode< MaybeObject > value)

TNode< BoolT >	IsStrong (TNode< Object > value)

TNode< HeapObject >	GetHeapObjectIfStrong (TNode< MaybeObject > value, Label *if_not_strong)

TNode< BoolT >	IsWeakOrCleared (TNode< MaybeObject > value)

TNode< BoolT >	IsCleared (TNode< MaybeObject > value)

TNode< BoolT >	IsNotCleared (TNode< MaybeObject > value)

TNode< HeapObject >	GetHeapObjectAssumeWeak (TNode< MaybeObject > value)

TNode< HeapObject >	GetHeapObjectAssumeWeak (TNode< MaybeObject > value, Label *if_cleared)

TNode< BoolT >	IsWeakReferenceTo (TNode< MaybeObject > object, TNode< Object > value)

TNode< BoolT >	IsNotWeakReferenceTo (TNode< MaybeObject > object, TNode< Object > value)

TNode< BoolT >	IsStrongReferenceTo (TNode< MaybeObject > object, TNode< Object > value)

TNode< MaybeObject >	MakeWeak (TNode< HeapObject > value)

void	FixedArrayBoundsCheck (TNode< FixedArrayBase > array, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

template<typename Array >
TNode< IntPtrT >	LoadArrayLength (TNode< Array > array)

template<typename Array >
TNode< MaybeObject >	LoadArrayElement (TNode< Array > array, int array_header_size, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, TNode< IntPtrT > index, LoadSensitivity needs_poisoning)

TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, TNode< IntPtrT > index, int additional_offset=0, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, int index, int additional_offset=0, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, TNode< Smi > index)

TNode< Object >	LoadPropertyArrayElement (TNode< PropertyArray > object, SloppyTNode< IntPtrT > index)

TNode< IntPtrT >	LoadPropertyArrayLength (TNode< PropertyArray > object)

template<typename Array >
TNode< Int32T >	LoadAndUntagToWord32ArrayElement (TNode< Array > array, int array_header_size, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

TNode< Int32T >	LoadAndUntagToWord32FixedArrayElement (TNode< FixedArray > object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

TNode< Int32T >	LoadAndUntagToWord32FixedArrayElement (TNode< FixedArray > object, int index, int additional_offset=0)

TNode< MaybeObject >	LoadWeakFixedArrayElement (TNode< WeakFixedArray > object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

TNode< MaybeObject >	LoadWeakFixedArrayElement (TNode< WeakFixedArray > object, int index, int additional_offset=0, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

TNode< Float64T >	LoadFixedDoubleArrayElement (SloppyTNode< FixedDoubleArray > object, Node index, MachineType machine_type, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, Label if_hole=nullptr)

Node *	LoadFixedDoubleArrayElement (TNode< FixedDoubleArray > object, TNode< Smi > index, Label *if_hole=nullptr)

Node *	LoadFixedDoubleArrayElement (TNode< FixedDoubleArray > object, TNode< IntPtrT > index, Label *if_hole=nullptr)

TNode< Object >	LoadFixedArrayBaseElementAsTagged (TNode< FixedArrayBase > elements, TNode< IntPtrT > index, TNode< Int32T > elements_kind, Label if_accessor, Label if_hole)

TNode< MaybeObject >	LoadFeedbackVectorSlot (Node object, Node index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

TNode< IntPtrT >	LoadFeedbackVectorLength (TNode< FeedbackVector >)

TNode< Float64T >	LoadDoubleWithHoleCheck (TNode< FixedDoubleArray > array, TNode< Smi > index, Label *if_hole=nullptr)

TNode< Float64T >	LoadDoubleWithHoleCheck (TNode< FixedDoubleArray > array, TNode< IntPtrT > index, Label *if_hole=nullptr)

TNode< Float64T >	LoadDoubleWithHoleCheck (SloppyTNode< Object > base, SloppyTNode< IntPtrT > offset, Label *if_hole, MachineType machine_type=MachineType::Float64())

TNode< RawPtrT >	LoadFixedTypedArrayBackingStore (TNode< FixedTypedArrayBase > typed_array)

Node *	LoadFixedTypedArrayElementAsTagged (Node data_pointer, Node index_node, ElementsKind elements_kind, ParameterMode parameter_mode=INTPTR_PARAMETERS)

TNode< Numeric >	LoadFixedTypedArrayElementAsTagged (TNode< WordT > data_pointer, TNode< Smi > index, TNode< Int32T > elements_kind)

Node *	LoadFixedBigInt64ArrayElementAsTagged (Node data_pointer, Node offset)

Node *	LoadFixedBigUint64ArrayElementAsTagged (Node data_pointer, Node offset)

TNode< BigInt >	BigIntFromInt64 (TNode< IntPtrT > value)

TNode< BigInt >	BigIntFromUint64 (TNode< UintPtrT > value)

TNode< BigInt >	BigIntFromInt32Pair (TNode< IntPtrT > low, TNode< IntPtrT > high)

TNode< BigInt >	BigIntFromUint32Pair (TNode< UintPtrT > low, TNode< UintPtrT > high)

void	StoreFixedTypedArrayElementFromTagged (TNode< Context > context, TNode< FixedTypedArrayBase > elements, TNode< Object > index_node, TNode< Object > value, ElementsKind elements_kind, ParameterMode parameter_mode)

TNode< Object >	LoadContextElement (SloppyTNode< Context > context, int slot_index)

TNode< Object >	LoadContextElement (SloppyTNode< Context > context, SloppyTNode< IntPtrT > slot_index)

TNode< Object >	LoadContextElement (TNode< Context > context, TNode< Smi > slot_index)

void	StoreContextElement (SloppyTNode< Context > context, int slot_index, SloppyTNode< Object > value)

void	StoreContextElement (SloppyTNode< Context > context, SloppyTNode< IntPtrT > slot_index, SloppyTNode< Object > value)

void	StoreContextElementNoWriteBarrier (SloppyTNode< Context > context, int slot_index, SloppyTNode< Object > value)

TNode< Context >	LoadNativeContext (SloppyTNode< Context > context)

TNode< Context >	LoadModuleContext (SloppyTNode< Context > context)

void	GotoIfContextElementEqual (Node value, Node native_context, int slot_index, Label *if_equal)

TNode< Map >	LoadJSArrayElementsMap (ElementsKind kind, SloppyTNode< Context > native_context)

TNode< Map >	LoadJSArrayElementsMap (SloppyTNode< Int32T > kind, SloppyTNode< Context > native_context)

TNode< BoolT >	IsGeneratorFunction (TNode< JSFunction > function)

TNode< BoolT >	HasPrototypeProperty (TNode< JSFunction > function, TNode< Map > map)

void	GotoIfPrototypeRequiresRuntimeLookup (TNode< JSFunction > function, TNode< Map > map, Label *runtime)

Node *	LoadJSFunctionPrototype (Node function, Label if_bailout)

TNode< BytecodeArray >	LoadSharedFunctionInfoBytecodeArray (SloppyTNode< SharedFunctionInfo > shared)

TNode< Object >	LoadJSFunctionPrototypeOrInitialMap (TNode< JSFunction > function)

void	StoreObjectByteNoWriteBarrier (TNode< HeapObject > object, int offset, TNode< Word32T > value)

void	StoreHeapNumberValue (SloppyTNode< HeapNumber > object, SloppyTNode< Float64T > value)

void	StoreMutableHeapNumberValue (SloppyTNode< MutableHeapNumber > object, SloppyTNode< Float64T > value)

Node *	StoreObjectField (Node object, int offset, Node value)

Node *	StoreObjectField (Node object, Node offset, Node *value)

Node *	StoreObjectFieldNoWriteBarrier (Node object, int offset, Node value, MachineRepresentation rep=MachineRepresentation::kTagged)

Node *	StoreObjectFieldNoWriteBarrier (Node object, Node offset, Node *value, MachineRepresentation rep=MachineRepresentation::kTagged)

template<class T = Object>
TNode< T >	StoreObjectFieldNoWriteBarrier (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< T > value)

Node *	StoreMap (Node object, Node map)

Node *	StoreMapNoWriteBarrier (Node *object, RootIndex map_root_index)

Node *	StoreMapNoWriteBarrier (Node object, Node map)

Node *	StoreObjectFieldRoot (Node *object, int offset, RootIndex root)

void	StoreFixedArrayElement (TNode< FixedArray > object, int index, SloppyTNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)

void	StoreFixedArrayElement (TNode< FixedArray > object, int index, TNode< Smi > value)

Node *	StoreJSArrayLength (TNode< JSArray > array, TNode< Smi > length)

Node *	StoreElements (TNode< Object > object, TNode< FixedArrayBase > elements)

void	StoreFixedArrayOrPropertyArrayElement (Node array, Node index, Node *value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

void	StoreFixedArrayElement (TNode< FixedArray > array, Node *index, SloppyTNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

void	StorePropertyArrayElement (TNode< PropertyArray > array, Node *index, SloppyTNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

void	StoreFixedArrayElementSmi (TNode< FixedArray > array, TNode< Smi > index, TNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)

void	StoreFixedArrayElement (TNode< FixedArray > array, TNode< IntPtrT > index, TNode< Smi > value)

void	StoreFixedDoubleArrayElement (TNode< FixedDoubleArray > object, Node *index, TNode< Float64T > value, ParameterMode parameter_mode=INTPTR_PARAMETERS)

void	StoreFixedDoubleArrayElementSmi (TNode< FixedDoubleArray > object, TNode< Smi > index, TNode< Float64T > value)

void	StoreFixedDoubleArrayHole (TNode< FixedDoubleArray > array, Node *index, ParameterMode mode=INTPTR_PARAMETERS)

void	StoreFixedDoubleArrayHoleSmi (TNode< FixedDoubleArray > array, TNode< Smi > index)

Node *	StoreFeedbackVectorSlot (Node object, Node index, Node *value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

void	EnsureArrayLengthWritable (TNode< Map > map, Label *bailout)

TNode< Int32T >	EnsureArrayPushable (TNode< Map > map, Label *bailout)

void	TryStoreArrayElement (ElementsKind kind, ParameterMode mode, Label bailout, Node elements, Node index, Node value)

TNode< Smi >	BuildAppendJSArray (ElementsKind kind, SloppyTNode< JSArray > array, CodeStubArguments args, TVariable< IntPtrT > arg_index, Label *bailout)

void	BuildAppendJSArray (ElementsKind kind, Node array, Node value, Label *bailout)

void	StoreFieldsNoWriteBarrier (Node start_address, Node end_address, Node *value)

Node *	AllocateCellWithValue (Node *value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)

Node *	AllocateSmiCell (int value=0)

Node *	LoadCellValue (Node *cell)

Node *	StoreCellValue (Node cell, Node value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)

TNode< HeapNumber >	AllocateHeapNumber ()

TNode< HeapNumber >	AllocateHeapNumberWithValue (SloppyTNode< Float64T > value)

TNode< HeapNumber >	AllocateHeapNumberWithValue (double value)

TNode< MutableHeapNumber >	AllocateMutableHeapNumberWithValue (SloppyTNode< Float64T > value)

TNode< BigInt >	AllocateBigInt (TNode< IntPtrT > length)

TNode< BigInt >	AllocateRawBigInt (TNode< IntPtrT > length)

void	StoreBigIntBitfield (TNode< BigInt > bigint, TNode< WordT > bitfield)

void	StoreBigIntDigit (TNode< BigInt > bigint, int digit_index, TNode< UintPtrT > digit)

TNode< WordT >	LoadBigIntBitfield (TNode< BigInt > bigint)

TNode< UintPtrT >	LoadBigIntDigit (TNode< BigInt > bigint, int digit_index)

TNode< String >	AllocateSeqOneByteString (uint32_t length, AllocationFlags flags=kNone)

TNode< String >	AllocateSeqOneByteString (Node *context, TNode< Uint32T > length, AllocationFlags flags=kNone)

TNode< String >	AllocateSeqTwoByteString (uint32_t length, AllocationFlags flags=kNone)

TNode< String >	AllocateSeqTwoByteString (Node *context, TNode< Uint32T > length, AllocationFlags flags=kNone)

TNode< String >	AllocateSlicedOneByteString (TNode< Uint32T > length, TNode< String > parent, TNode< Smi > offset)

TNode< String >	AllocateSlicedTwoByteString (TNode< Uint32T > length, TNode< String > parent, TNode< Smi > offset)

TNode< String >	AllocateOneByteConsString (TNode< Uint32T > length, TNode< String > first, TNode< String > second, AllocationFlags flags=kNone)

TNode< String >	AllocateTwoByteConsString (TNode< Uint32T > length, TNode< String > first, TNode< String > second, AllocationFlags flags=kNone)

TNode< String >	NewConsString (TNode< Uint32T > length, TNode< String > left, TNode< String > right, AllocationFlags flags=kNone)

TNode< NameDictionary >	AllocateNameDictionary (int at_least_space_for)

TNode< NameDictionary >	AllocateNameDictionary (TNode< IntPtrT > at_least_space_for)

TNode< NameDictionary >	AllocateNameDictionaryWithCapacity (TNode< IntPtrT > capacity)

TNode< NameDictionary >	CopyNameDictionary (TNode< NameDictionary > dictionary, Label *large_object_fallback)

template<typename CollectionType >
Node *	AllocateOrderedHashTable ()

template<typename CollectionType >
void	FindOrderedHashTableEntry (Node table, Node hash, const std::function< void(Node , Label , Label )> &key_compare, Variable entry_start_position, Label entry_found, Label not_found)

template<typename CollectionType >
TNode< CollectionType >	AllocateSmallOrderedHashTable (TNode< IntPtrT > capacity)

Node *	AllocateStruct (Node *map, AllocationFlags flags=kNone)

void	InitializeStructBody (Node object, Node map, Node *size, int start_offset=Struct::kHeaderSize)

Node *	AllocateJSObjectFromMap (Node map, Node properties=nullptr, Node *elements=nullptr, AllocationFlags flags=kNone, SlackTrackingMode slack_tracking_mode=kNoSlackTracking)

void	InitializeJSObjectFromMap (Node object, Node map, Node instance_size, Node properties=nullptr, Node *elements=nullptr, SlackTrackingMode slack_tracking_mode=kNoSlackTracking)

void	InitializeJSObjectBodyWithSlackTracking (Node object, Node map, Node *instance_size)

void	InitializeJSObjectBodyNoSlackTracking (Node object, Node map, Node *instance_size, int start_offset=JSObject::kHeaderSize)

TNode< BoolT >	IsValidFastJSArrayCapacity (Node *capacity, ParameterMode capacity_mode)

TNode< JSArray >	AllocateUninitializedJSArrayWithoutElements (TNode< Map > array_map, TNode< Smi > length, Node *allocation_site=nullptr)

std::pair< TNode< JSArray >, TNode< FixedArrayBase > >	AllocateUninitializedJSArrayWithElements (ElementsKind kind, TNode< Map > array_map, TNode< Smi > length, Node allocation_site, Node capacity, ParameterMode capacity_mode=INTPTR_PARAMETERS, AllocationFlags allocation_flags=kNone)

TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, Node capacity, TNode< Smi > length, Node allocation_site=nullptr, ParameterMode capacity_mode=INTPTR_PARAMETERS, AllocationFlags allocation_flags=kNone)

TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< Smi > capacity, TNode< Smi > length)

TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< IntPtrT > capacity, TNode< Smi > length)

Node *	CloneFastJSArray (Node context, Node array, ParameterMode mode=INTPTR_PARAMETERS, Node *allocation_site=nullptr, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert)

Node *	ExtractFastJSArray (Node context, Node array, Node begin, Node count, ParameterMode mode=INTPTR_PARAMETERS, Node capacity=nullptr, Node allocation_site=nullptr)

TNode< FixedArrayBase >	AllocateFixedArray (ElementsKind kind, Node *capacity, ParameterMode mode=INTPTR_PARAMETERS, AllocationFlags flags=kNone, SloppyTNode< Map > fixed_array_map=nullptr)

TNode< FixedArrayBase >	AllocateFixedArray (ElementsKind kind, TNode< IntPtrT > capacity, AllocationFlags flags, SloppyTNode< Map > fixed_array_map=nullptr)

TNode< FixedArray >	AllocateZeroedFixedArray (TNode< IntPtrT > capacity)

TNode< FixedDoubleArray >	AllocateZeroedFixedDoubleArray (TNode< IntPtrT > capacity)

TNode< FixedArray >	AllocateFixedArrayWithHoles (TNode< IntPtrT > capacity, AllocationFlags flags)

Node *	AllocatePropertyArray (Node *capacity, ParameterMode mode=INTPTR_PARAMETERS, AllocationFlags flags=kNone)

TNode< JSArrayIterator >	CreateArrayIterator (TNode< Context > context, TNode< Object > object, IterationKind mode)

Node *	AllocateJSIteratorResult (Node context, Node value, Node *done)

Node *	AllocateJSIteratorResultForEntry (Node context, Node key, Node *value)

TNode< JSReceiver >	ArraySpeciesCreate (TNode< Context > context, TNode< Object > originalArray, TNode< Number > len)

TNode< JSReceiver >	InternalArrayCreate (TNode< Context > context, TNode< Number > len)

void	FillFixedArrayWithValue (ElementsKind kind, Node array, Node from_index, Node *to_index, RootIndex value_root_index, ParameterMode mode=INTPTR_PARAMETERS)

void	FillFixedArrayWithSmiZero (TNode< FixedArray > array, TNode< IntPtrT > length)

void	FillFixedDoubleArrayWithZero (TNode< FixedDoubleArray > array, TNode< IntPtrT > length)

void	FillPropertyArrayWithUndefined (Node array, Node from_index, Node *to_index, ParameterMode mode=INTPTR_PARAMETERS)

void	CopyPropertyArrayValues (Node from_array, Node to_array, Node *length, WriteBarrierMode barrier_mode, ParameterMode mode, DestroySource destroy_source)

void	CopyFixedArrayElements (ElementsKind kind, Node from_array, Node to_array, Node *length, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, ParameterMode mode=INTPTR_PARAMETERS)

void	CopyFixedArrayElements (ElementsKind from_kind, Node from_array, ElementsKind to_kind, Node to_array, Node element_count, Node capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, ParameterMode mode=INTPTR_PARAMETERS)

void	CopyFixedArrayElements (ElementsKind from_kind, Node from_array, ElementsKind to_kind, Node to_array, Node first_element, Node element_count, Node capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, ParameterMode mode=INTPTR_PARAMETERS, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert, TVariable< BoolT > var_holes_converted=nullptr)

void	CopyFixedArrayElements (ElementsKind from_kind, TNode< FixedArrayBase > from_array, ElementsKind to_kind, TNode< FixedArrayBase > to_array, TNode< Smi > first_element, TNode< Smi > element_count, TNode< Smi > capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)

void	JumpIfPointersFromHereAreInteresting (TNode< Object > object, Label *interesting)

void	MoveElements (ElementsKind kind, TNode< FixedArrayBase > elements, TNode< IntPtrT > dst_index, TNode< IntPtrT > src_index, TNode< IntPtrT > length)

void	CopyElements (ElementsKind kind, TNode< FixedArrayBase > dst_elements, TNode< IntPtrT > dst_index, TNode< FixedArrayBase > src_elements, TNode< IntPtrT > src_index, TNode< IntPtrT > length, WriteBarrierMode write_barrier=UPDATE_WRITE_BARRIER)

TNode< FixedArray >	HeapObjectToFixedArray (TNode< HeapObject > base, Label *cast_fail)

TNode< FixedDoubleArray >	HeapObjectToFixedDoubleArray (TNode< HeapObject > base, Label *cast_fail)

TNode< FixedArray >	HeapObjectToSloppyArgumentsElements (TNode< HeapObject > base, Label *cast_fail)

TNode< Int32T >	ConvertElementsKindToInt (TNode< Int32T > elements_kind)

TNode< FixedArrayBase >	ExtractFixedArray (Node source, Node first, Node count=nullptr, Node capacity=nullptr, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, ParameterMode parameter_mode=INTPTR_PARAMETERS, TVariable< BoolT > var_holes_converted=nullptr, Node source_elements_kind=nullptr)

TNode< FixedArrayBase >	ExtractFixedArray (TNode< FixedArrayBase > source, TNode< Smi > first, TNode< Smi > count, TNode< Smi > capacity, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays)

TNode< FixedArray >	ExtractToFixedArray (Node source, Node first, Node count, Node capacity, Node source_map, ElementsKind from_kind=PACKED_ELEMENTS, AllocationFlags allocation_flags=AllocationFlag::kNone, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, ParameterMode parameter_mode=INTPTR_PARAMETERS, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert, TVariable< BoolT > var_holes_converted=nullptr, Node *source_runtime_kind=nullptr)

TNode< FixedArrayBase >	ExtractFixedDoubleArrayFillingHoles (Node source, Node first, Node count, Node capacity, Node source_map, TVariable< BoolT > var_holes_converted, AllocationFlags allocation_flags, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, ParameterMode parameter_mode=INTPTR_PARAMETERS)

Node *	CloneFixedArray (Node *source, ExtractFixedArrayFlags flags=ExtractFixedArrayFlag::kAllFixedArraysDontCopyCOW)

void	CopyStringCharacters (Node from_string, Node to_string, TNode< IntPtrT > from_index, TNode< IntPtrT > to_index, TNode< IntPtrT > character_count, String::Encoding from_encoding, String::Encoding to_encoding)

Node *	LoadElementAndPrepareForStore (Node array, Node offset, ElementsKind from_kind, ElementsKind to_kind, Label *if_hole)

Node *	CalculateNewElementsCapacity (Node *old_capacity, ParameterMode mode=INTPTR_PARAMETERS)

TNode< Smi >	CalculateNewElementsCapacity (TNode< Smi > old_capacity)

Node *	TryGrowElementsCapacity (Node object, Node elements, ElementsKind kind, Node key, Label bailout)

Node *	TryGrowElementsCapacity (Node object, Node elements, ElementsKind kind, Node key, Node capacity, ParameterMode mode, Label *bailout)

Node *	GrowElementsCapacity (Node object, Node elements, ElementsKind from_kind, ElementsKind to_kind, Node capacity, Node new_capacity, ParameterMode mode, Label *bailout)

void	PossiblyGrowElementsCapacity (ParameterMode mode, ElementsKind kind, Node array, Node length, Variable var_elements, Node growth, Label *bailout)

void	InitializeAllocationMemento (Node base_allocation, Node base_allocation_size, Node *allocation_site)

Node *	TryTaggedToFloat64 (Node value, Label if_valueisnotnumber)

Node *	TruncateTaggedToFloat64 (Node context, Node value)

Node *	TruncateTaggedToWord32 (Node context, Node value)

void	TaggedToWord32OrBigInt (Node context, Node value, Label if_number, Variable var_word32, Label if_bigint, Variable var_bigint)

void	TaggedToWord32OrBigIntWithFeedback (Node context, Node value, Label if_number, Variable var_word32, Label if_bigint, Variable var_bigint, Variable *var_feedback)

Node *	TruncateHeapNumberValueToWord32 (Node *object)

void	TryHeapNumberToSmi (TNode< HeapNumber > number, TVariable< Smi > &output, Label *if_smi)

void	TryFloat64ToSmi (TNode< Float64T > number, TVariable< Smi > &output, Label *if_smi)

TNode< Number >	ChangeFloat64ToTagged (SloppyTNode< Float64T > value)

TNode< Number >	ChangeInt32ToTagged (SloppyTNode< Int32T > value)

TNode< Number >	ChangeUint32ToTagged (SloppyTNode< Uint32T > value)

TNode< Number >	ChangeUintPtrToTagged (TNode< UintPtrT > value)

TNode< Uint32T >	ChangeNumberToUint32 (TNode< Number > value)

TNode< Float64T >	ChangeNumberToFloat64 (SloppyTNode< Number > value)

TNode< UintPtrT >	ChangeNonnegativeNumberToUintPtr (TNode< Number > value)

void	TaggedToNumeric (Node context, Node value, Label done, Variable var_numeric)

void	TaggedToNumericWithFeedback (Node context, Node value, Label done, Variable var_numeric, Variable *var_feedback)

TNode< WordT >	TimesPointerSize (SloppyTNode< WordT > value)

TNode< IntPtrT >	TimesPointerSize (TNode< IntPtrT > value)

TNode< UintPtrT >	TimesPointerSize (TNode< UintPtrT > value)

TNode< WordT >	TimesDoubleSize (SloppyTNode< WordT > value)

TNode< UintPtrT >	TimesDoubleSize (TNode< UintPtrT > value)

TNode< IntPtrT >	TimesDoubleSize (TNode< IntPtrT > value)

TNode< String >	ToThisString (Node context, Node value, char const *method_name)

Node *	ToThisValue (Node context, Node value, PrimitiveType primitive_type, char const *method_name)

Node *	ThrowIfNotInstanceType (Node context, Node value, InstanceType instance_type, char const *method_name)

Node *	ThrowIfNotJSReceiver (Node context, Node value, MessageTemplate msg_template, const char *method_name=nullptr)

void	ThrowRangeError (Node context, MessageTemplate message, Node arg0=nullptr, Node arg1=nullptr, Node arg2=nullptr)

void	ThrowTypeError (Node context, MessageTemplate message, char const arg0=nullptr, char const *arg1=nullptr)

void	ThrowTypeError (Node context, MessageTemplate message, Node arg0, Node arg1=nullptr, Node arg2=nullptr)

TNode< BoolT >	InstanceTypeEqual (SloppyTNode< Int32T > instance_type, int type)

TNode< BoolT >	IsAccessorInfo (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsAccessorPair (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsAllocationSite (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsAnyHeapNumber (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsNoElementsProtectorCellInvalid ()

TNode< BoolT >	IsArrayIteratorProtectorCellInvalid ()

TNode< BoolT >	IsBigIntInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsBigInt (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsBoolean (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsCallableMap (SloppyTNode< Map > map)

TNode< BoolT >	IsCallable (SloppyTNode< HeapObject > object)

TNode< BoolT >	TaggedIsCallable (TNode< Object > object)

TNode< BoolT >	IsCell (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsCode (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsConsStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsConstructorMap (SloppyTNode< Map > map)

TNode< BoolT >	IsConstructor (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsDeprecatedMap (SloppyTNode< Map > map)

TNode< BoolT >	IsNameDictionary (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsGlobalDictionary (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsExtensibleMap (SloppyTNode< Map > map)

TNode< BoolT >	IsExtensibleNonPrototypeMap (TNode< Map > map)

TNode< BoolT >	IsExternalStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsFeedbackCell (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsFeedbackVector (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsContext (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsFixedArray (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsFixedArraySubclass (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsFixedArrayWithKind (SloppyTNode< HeapObject > object, ElementsKind kind)

TNode< BoolT >	IsFixedArrayWithKindOrEmpty (SloppyTNode< HeapObject > object, ElementsKind kind)

TNode< BoolT >	IsFixedDoubleArray (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsFixedTypedArray (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsFunctionWithPrototypeSlotMap (SloppyTNode< Map > map)

TNode< BoolT >	IsHashTable (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsEphemeronHashTable (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsHeapNumber (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsHeapNumberInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsOddball (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsOddballInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsIndirectStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSArrayBuffer (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSDataView (TNode< HeapObject > object)

TNode< BoolT >	IsJSArrayInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSArrayMap (SloppyTNode< Map > map)

TNode< BoolT >	IsJSArray (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSArrayIterator (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSAsyncGeneratorObject (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSFunctionInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsAllocationSiteInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSFunctionMap (SloppyTNode< Map > map)

TNode< BoolT >	IsJSFunction (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSGeneratorObject (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSGlobalProxyInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSGlobalProxy (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSObjectInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSObjectMap (SloppyTNode< Map > map)

TNode< BoolT >	IsJSObject (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSPromiseMap (SloppyTNode< Map > map)

TNode< BoolT >	IsJSPromise (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSProxy (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSReceiverInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSReceiverMap (SloppyTNode< Map > map)

TNode< BoolT >	IsJSReceiver (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSRegExp (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSTypedArray (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsJSValueInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsJSValueMap (SloppyTNode< Map > map)

TNode< BoolT >	IsJSValue (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsMap (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsMutableHeapNumber (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsName (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsNameInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsNativeContext (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsNullOrJSReceiver (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsNullOrUndefined (SloppyTNode< Object > object)

TNode< BoolT >	IsNumberDictionary (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsOneByteStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	HasOnlyOneByteChars (TNode< Int32T > instance_type)

TNode< BoolT >	IsPrimitiveInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsPrivateSymbol (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsPromiseCapability (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsPropertyArray (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsPropertyCell (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsPrototypeInitialArrayPrototype (SloppyTNode< Context > context, SloppyTNode< Map > map)

TNode< BoolT >	IsPrototypeTypedArrayPrototype (SloppyTNode< Context > context, SloppyTNode< Map > map)

TNode< BoolT >	IsFastAliasedArgumentsMap (TNode< Context > context, TNode< Map > map)

TNode< BoolT >	IsSlowAliasedArgumentsMap (TNode< Context > context, TNode< Map > map)

TNode< BoolT >	IsSloppyArgumentsMap (TNode< Context > context, TNode< Map > map)

TNode< BoolT >	IsStrictArgumentsMap (TNode< Context > context, TNode< Map > map)

TNode< BoolT >	IsSequentialStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsUncachedExternalStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsSpecialReceiverInstanceType (TNode< Int32T > instance_type)

TNode< BoolT >	IsCustomElementsReceiverInstanceType (TNode< Int32T > instance_type)

TNode< BoolT >	IsSpecialReceiverMap (SloppyTNode< Map > map)

TNode< BoolT >	IsSimpleObjectMap (TNode< Map > map)

TNode< BoolT >	IsStringInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsString (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsSymbolInstanceType (SloppyTNode< Int32T > instance_type)

TNode< BoolT >	IsSymbol (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsUndetectableMap (SloppyTNode< Map > map)

TNode< BoolT >	IsNotWeakFixedArraySubclass (SloppyTNode< HeapObject > object)

TNode< BoolT >	IsZeroOrContext (SloppyTNode< Object > object)

Node *	IsSharedFunctionInfo (Node *object)

TNode< BoolT >	IsPromiseResolveProtectorCellInvalid ()

TNode< BoolT >	IsPromiseThenProtectorCellInvalid ()

TNode< BoolT >	IsArraySpeciesProtectorCellInvalid ()

TNode< BoolT >	IsTypedArraySpeciesProtectorCellInvalid ()

TNode< BoolT >	IsRegExpSpeciesProtectorCellInvalid ()

TNode< BoolT >	IsPromiseSpeciesProtectorCellInvalid ()

TNode< BoolT >	IsNumber (SloppyTNode< Object > object)

TNode< BoolT >	IsNumeric (SloppyTNode< Object > object)

TNode< BoolT >	IsNumberNormalized (SloppyTNode< Number > number)

TNode< BoolT >	IsNumberPositive (SloppyTNode< Number > number)

TNode< BoolT >	IsHeapNumberPositive (TNode< HeapNumber > number)

TNode< BoolT >	IsNumberNonNegativeSafeInteger (TNode< Number > number)

TNode< BoolT >	IsInteger (TNode< Object > number)

TNode< BoolT >	IsInteger (TNode< HeapNumber > number)

TNode< BoolT >	IsSafeInteger (TNode< Object > number)

TNode< BoolT >	IsSafeInteger (TNode< HeapNumber > number)

TNode< BoolT >	IsHeapNumberUint32 (TNode< HeapNumber > number)

TNode< BoolT >	IsNumberArrayIndex (TNode< Number > number)

Node *	FixedArraySizeDoesntFitInNewSpace (Node *element_count, int base_size=FixedArray::kHeaderSize, ParameterMode mode=INTPTR_PARAMETERS)

TNode< BoolT >	ElementsKindEqual (TNode< Int32T > a, TNode< Int32T > b)

bool	ElementsKindEqual (ElementsKind a, ElementsKind b)

Node *	IsFastElementsKind (Node *elements_kind)

bool	IsFastElementsKind (ElementsKind kind)

TNode< BoolT >	IsDictionaryElementsKind (TNode< Int32T > elements_kind)

TNode< BoolT >	IsDoubleElementsKind (TNode< Int32T > elements_kind)

bool	IsDoubleElementsKind (ElementsKind kind)

Node *	IsFastSmiOrTaggedElementsKind (Node *elements_kind)

Node *	IsFastSmiElementsKind (Node *elements_kind)

Node *	IsHoleyFastElementsKind (Node *elements_kind)

Node *	IsElementsKindGreaterThan (Node *target_kind, ElementsKind reference_kind)

TNode< BoolT >	IsElementsKindLessThanOrEqual (TNode< Int32T > target_kind, ElementsKind reference_kind)

TNode< Int32T >	StringCharCodeAt (SloppyTNode< String > string, SloppyTNode< IntPtrT > index)

TNode< String >	StringFromSingleCharCode (TNode< Int32T > code)

TNode< String >	SubString (TNode< String > string, TNode< IntPtrT > from, TNode< IntPtrT > to)

TNode< String >	StringAdd (Node *context, TNode< String > first, TNode< String > second, AllocationFlags flags=kNone)

void	BranchIfCanDerefIndirectString (Node string, Node instance_type, Label can_deref, Label cannot_deref)

void	DerefIndirectString (Variable var_string, Node instance_type)

void	MaybeDerefIndirectString (Variable var_string, Node instance_type, Label did_deref, Label cannot_deref)

void	MaybeDerefIndirectStrings (Variable var_left, Node left_instance_type, Variable var_right, Node right_instance_type, Label *did_something)

Node *	DerefIndirectString (TNode< String > string, TNode< Int32T > instance_type, Label *cannot_deref)

TNode< String >	StringFromSingleCodePoint (TNode< Int32T > codepoint, UnicodeEncoding encoding)

TNode< Number >	StringToNumber (TNode< String > input)

TNode< String >	NumberToString (TNode< Number > input)

TNode< Number >	NonNumberToNumber (SloppyTNode< Context > context, SloppyTNode< HeapObject > input, BigIntHandling bigint_handling=BigIntHandling::kThrow)

TNode< Numeric >	NonNumberToNumeric (SloppyTNode< Context > context, SloppyTNode< HeapObject > input)

TNode< Number >	ToNumber (SloppyTNode< Context > context, SloppyTNode< Object > input, BigIntHandling bigint_handling=BigIntHandling::kThrow)

TNode< Number >	ToNumber_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input)

TNode< BigInt >	ToBigInt (SloppyTNode< Context > context, SloppyTNode< Object > input)

TNode< Number >	ToUint32 (SloppyTNode< Context > context, SloppyTNode< Object > input)

TNode< String >	ToString (SloppyTNode< Context > context, SloppyTNode< Object > input)

TNode< String >	ToString_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input)

Node *	JSReceiverToPrimitive (Node context, Node input)

TNode< JSReceiver >	ToObject (SloppyTNode< Context > context, SloppyTNode< Object > input)

TNode< JSReceiver >	ToObject_Inline (TNode< Context > context, TNode< Object > input)

TNode< Smi >	ToSmiIndex (TNode< Object > input, TNode< Context > context, Label *range_error)

TNode< Smi >	ToSmiLength (TNode< Object > input, TNode< Context > context, Label *range_error)

TNode< Number >	ToLength_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input)

TNode< Number >	ToInteger_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input, ToIntegerTruncationMode mode=kNoTruncation)

TNode< Number >	ToInteger (SloppyTNode< Context > context, SloppyTNode< Object > input, ToIntegerTruncationMode mode=kNoTruncation)

template<typename BitField >
TNode< Uint32T >	DecodeWord32 (SloppyTNode< Word32T > word32)

template<typename BitField >
TNode< UintPtrT >	DecodeWord (SloppyTNode< WordT > word)

template<typename BitField >
TNode< UintPtrT >	DecodeWordFromWord32 (SloppyTNode< Word32T > word32)

template<typename BitField >
TNode< Uint32T >	DecodeWord32FromWord (SloppyTNode< WordT > word)

TNode< Uint32T >	DecodeWord32 (SloppyTNode< Word32T > word32, uint32_t shift, uint32_t mask)

TNode< UintPtrT >	DecodeWord (SloppyTNode< WordT > word, uint32_t shift, uint32_t mask)

template<typename BitField >
TNode< WordT >	UpdateWord (TNode< WordT > word, TNode< WordT > value)

TNode< WordT >	UpdateWord (TNode< WordT > word, TNode< WordT > value, uint32_t shift, uint32_t mask)

template<typename T >
TNode< BoolT >	IsSetWord32 (SloppyTNode< Word32T > word32)

TNode< BoolT >	IsSetWord32 (SloppyTNode< Word32T > word32, uint32_t mask)

TNode< BoolT >	IsNotSetWord32 (SloppyTNode< Word32T > word32, uint32_t mask)

TNode< BoolT >	IsAllSetWord32 (SloppyTNode< Word32T > word32, uint32_t mask)

template<typename T >
TNode< BoolT >	IsSetWord (SloppyTNode< WordT > word)

TNode< BoolT >	IsSetWord (SloppyTNode< WordT > word, uint32_t mask)

TNode< BoolT >	IsSetSmi (SloppyTNode< Smi > smi, int untagged_mask)

template<typename T >
TNode< BoolT >	IsClearWord32 (SloppyTNode< Word32T > word32)

TNode< BoolT >	IsClearWord32 (SloppyTNode< Word32T > word32, uint32_t mask)

template<typename T >
TNode< BoolT >	IsClearWord (SloppyTNode< WordT > word)

TNode< BoolT >	IsClearWord (SloppyTNode< WordT > word, uint32_t mask)

void	SetCounter (StatsCounter *counter, int value)

void	IncrementCounter (StatsCounter *counter, int delta)

void	DecrementCounter (StatsCounter *counter, int delta)

void	Increment (Variable *variable, int value=1, ParameterMode mode=INTPTR_PARAMETERS)

void	Decrement (Variable *variable, int value=1, ParameterMode mode=INTPTR_PARAMETERS)

void	Use (Label *label)

void	TryToName (Node key, Label if_keyisindex, Variable var_index, Label if_keyisunique, Variable var_unique, Label if_bailout, Label *if_notinternalized=nullptr)

void	TryInternalizeString (Node string, Label if_index, Variable var_index, Label if_internalized, Variable var_internalized, Label if_not_internalized, Label *if_bailout)

template<typename Dictionary >
TNode< IntPtrT >	EntryToIndex (TNode< IntPtrT > entry, int field_index)

template<typename Dictionary >
TNode< IntPtrT >	EntryToIndex (TNode< IntPtrT > entry)

template<class ContainerType >
TNode< Uint32T >	LoadDetailsByKeyIndex (Node container, Node key_index)

template<class ContainerType >
TNode< Object >	LoadValueByKeyIndex (Node container, Node key_index)

template<class ContainerType >
void	StoreDetailsByKeyIndex (TNode< ContainerType > container, TNode< IntPtrT > key_index, TNode< Smi > details)

template<class ContainerType >
void	StoreValueByKeyIndex (TNode< ContainerType > container, TNode< IntPtrT > key_index, TNode< Object > value, WriteBarrierMode write_barrier=UPDATE_WRITE_BARRIER)

TNode< IntPtrT >	HashTableComputeCapacity (TNode< IntPtrT > at_least_space_for)

template<class Dictionary >
TNode< Smi >	GetNumberOfElements (TNode< Dictionary > dictionary)

TNode< Smi >	GetNumberDictionaryNumberOfElements (TNode< NumberDictionary > dictionary)

template<class Dictionary >
void	SetNumberOfElements (TNode< Dictionary > dictionary, TNode< Smi > num_elements_smi)

template<class Dictionary >
TNode< Smi >	GetNumberOfDeletedElements (TNode< Dictionary > dictionary)

template<class Dictionary >
void	SetNumberOfDeletedElements (TNode< Dictionary > dictionary, TNode< Smi > num_deleted_smi)

template<class Dictionary >
TNode< Smi >	GetCapacity (TNode< Dictionary > dictionary)

template<class Dictionary >
TNode< Smi >	GetNextEnumerationIndex (TNode< Dictionary > dictionary)

template<class Dictionary >
void	SetNextEnumerationIndex (TNode< Dictionary > dictionary, TNode< Smi > next_enum_index_smi)

template<typename Dictionary >
TNode< HeapObject >	LoadName (TNode< HeapObject > key)

template<typename Dictionary >
void	NameDictionaryLookup (TNode< Dictionary > dictionary, TNode< Name > unique_name, Label if_found, TVariable< IntPtrT > var_name_index, Label *if_not_found, int inlined_probes=kInlinedDictionaryProbes, LookupMode mode=kFindExisting)

Node *	ComputeUnseededHash (Node *key)

Node *	ComputeSeededHash (Node *key)

void	NumberDictionaryLookup (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, Label if_found, TVariable< IntPtrT > var_entry, Label *if_not_found)

TNode< Object >	BasicLoadNumberDictionaryElement (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, Label not_data, Label if_hole)

void	BasicStoreNumberDictionaryElement (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, TNode< Object > value, Label not_data, Label if_hole, Label *read_only)

template<class Dictionary >
void	FindInsertionEntry (TNode< Dictionary > dictionary, TNode< Name > key, TVariable< IntPtrT > *var_key_index)

template<class Dictionary >
void	InsertEntry (TNode< Dictionary > dictionary, TNode< Name > key, TNode< Object > value, TNode< IntPtrT > index, TNode< Smi > enum_index)

template<class Dictionary >
void	Add (TNode< Dictionary > dictionary, TNode< Name > key, TNode< Object > value, Label *bailout)

void	TryHasOwnProperty (Node object, Node map, Node instance_type, Node unique_name, Label if_found, Label if_not_found, Label *if_bailout)

void	TryGetOwnProperty (Node context, Node receiver, Node object, Node map, Node instance_type, Node unique_name, Label if_found, Variable var_value, Label if_not_found, Label if_bailout)

void	TryGetOwnProperty (Node context, Node receiver, Node object, Node map, Node instance_type, Node unique_name, Label if_found, Variable var_value, Variable var_details, Variable var_raw_value, Label if_not_found, Label if_bailout, GetOwnPropertyMode mode)

TNode< Object >	GetProperty (SloppyTNode< Context > context, SloppyTNode< Object > receiver, Handle< Name > name)

TNode< Object >	GetProperty (SloppyTNode< Context > context, SloppyTNode< Object > receiver, SloppyTNode< Object > name)

TNode< Object >	SetPropertyStrict (TNode< Context > context, TNode< Object > receiver, TNode< Object > key, TNode< Object > value)

TNode< Object >	SetPropertyInLiteral (TNode< Context > context, TNode< JSObject > receiver, TNode< Object > key, TNode< Object > value)

Node *	GetMethod (Node context, Node object, Handle< Name > name, Label *if_null_or_undefined)

template<class... TArgs>
TNode< Object >	CallBuiltin (Builtins::Name id, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
void	TailCallBuiltin (Builtins::Name id, SloppyTNode< Object > context, TArgs... args)

void	LoadPropertyFromFastObject (Node object, Node map, TNode< DescriptorArray > descriptors, Node name_index, Variable var_details, Variable *var_value)

void	LoadPropertyFromFastObject (Node object, Node map, TNode< DescriptorArray > descriptors, Node name_index, Node details, Variable *var_value)

void	LoadPropertyFromNameDictionary (Node dictionary, Node entry, Variable var_details, Variable var_value)

void	LoadPropertyFromGlobalDictionary (Node dictionary, Node entry, Variable var_details, Variable var_value, Label *if_deleted)

void	TryLookupProperty (SloppyTNode< JSObject > object, SloppyTNode< Map > map, SloppyTNode< Int32T > instance_type, SloppyTNode< Name > unique_name, Label if_found_fast, Label if_found_dict, Label if_found_global, TVariable< HeapObject > var_meta_storage, TVariable< IntPtrT > var_name_index, Label if_not_found, Label *if_bailout)

void	TryLookupPropertyInSimpleObject (TNode< JSObject > object, TNode< Map > map, TNode< Name > unique_name, Label if_found_fast, Label if_found_dict, TVariable< HeapObject > var_meta_storage, TVariable< IntPtrT > var_name_index, Label *if_not_found)

void	TryLookupElement (Node object, Node map, SloppyTNode< Int32T > instance_type, SloppyTNode< IntPtrT > intptr_index, Label if_found, Label if_absent, Label if_not_found, Label if_bailout)

void	BranchIfMaybeSpecialIndex (TNode< String > name_string, Label if_maybe_special_index, Label if_not_special_index)

void	TryPrototypeChainLookup (Node receiver, Node key, const LookupInHolder &lookup_property_in_holder, const LookupInHolder &lookup_element_in_holder, Label if_end, Label if_bailout, Label *if_proxy=nullptr)

Node *	HasInPrototypeChain (Node context, Node object, Node *prototype)

Node *	OrdinaryHasInstance (Node context, Node callable, Node *object)

TNode< FeedbackVector >	LoadFeedbackVectorForStub ()

TNode< FeedbackVector >	LoadFeedbackVector (SloppyTNode< JSFunction > closure, Label *if_undefined=nullptr)

TNode< Object >	LoadFeedbackVectorUnchecked (SloppyTNode< JSFunction > closure)

void	UpdateFeedback (Node feedback, Node feedback_vector, Node *slot_id)

void	ReportFeedbackUpdate (SloppyTNode< FeedbackVector > feedback_vector, SloppyTNode< IntPtrT > slot_id, const char *reason)

void	CombineFeedback (Variable *existing_feedback, int feedback)

void	CombineFeedback (Variable existing_feedback, Node feedback)

void	OverwriteFeedback (Variable *existing_feedback, int new_feedback)

void	CheckForAssociatedProtector (Node name, Label if_protector)

TNode< Map >	LoadReceiverMap (SloppyTNode< Object > receiver)

Node *	LoadKeyedSloppyArguments (Node receiver, Node key, Label *bailout)

void	StoreKeyedSloppyArguments (Node receiver, Node key, Node value, Label bailout)

TNode< Context >	LoadScriptContext (TNode< Context > context, TNode< IntPtrT > context_index)

Node *	Int32ToUint8Clamped (Node *int32_value)

Node *	Float64ToUint8Clamped (Node *float64_value)

Node *	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)

void	StoreElement (Node elements, ElementsKind kind, Node index, Node *value, ParameterMode mode)

void	EmitBigTypedArrayElementStore (TNode< JSTypedArray > object, TNode< FixedTypedArrayBase > elements, TNode< IntPtrT > intptr_key, TNode< Object > value, TNode< Context > context, Label *opt_if_neutered)

void	EmitBigTypedArrayElementStore (TNode< FixedTypedArrayBase > elements, TNode< RawPtrT > backing_store, TNode< IntPtrT > offset, TNode< BigInt > bigint_value)

void	BigIntToRawBytes (TNode< BigInt > bigint, TVariable< UintPtrT > var_low, TVariable< UintPtrT > var_high)

void	EmitElementStore (Node object, Node key, Node value, ElementsKind elements_kind, KeyedAccessStoreMode store_mode, Label bailout, Node *context)

Node *	CheckForCapacityGrow (Node object, Node elements, ElementsKind kind, Node length, Node key, ParameterMode mode, Label *bailout)

Node *	CopyElementsOnWrite (Node object, Node elements, ElementsKind kind, Node length, ParameterMode mode, Label bailout)

void	TransitionElementsKind (Node object, Node map, ElementsKind from_kind, ElementsKind to_kind, Label *bailout)

void	TrapAllocationMemento (Node object, Label memento_found)

TNode< IntPtrT >	PageFromAddress (TNode< IntPtrT > address)

TNode< MaybeObject >	StoreWeakReferenceInFeedbackVector (SloppyTNode< FeedbackVector > feedback_vector, Node *slot, SloppyTNode< HeapObject > value, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)

TNode< AllocationSite >	CreateAllocationSiteInFeedbackVector (SloppyTNode< FeedbackVector > feedback_vector, TNode< Smi > slot)

TNode< BoolT >	NotHasBoilerplate (TNode< Object > maybe_literal_site)

TNode< Smi >	LoadTransitionInfo (TNode< AllocationSite > allocation_site)

TNode< JSObject >	LoadBoilerplate (TNode< AllocationSite > allocation_site)

TNode< Int32T >	LoadElementsKind (TNode< AllocationSite > allocation_site)

Node *	BuildFastLoop (const VariableList &var_list, Node start_index, Node end_index, const FastLoopBody &body, int increment, ParameterMode parameter_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)

Node *	BuildFastLoop (Node start_index, Node end_index, const FastLoopBody &body, int increment, ParameterMode parameter_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)

void	BuildFastFixedArrayForEach (const CodeStubAssembler::VariableList &vars, Node fixed_array, ElementsKind kind, Node first_element_inclusive, Node *last_element_exclusive, const FastFixedArrayForEachBody &body, ParameterMode mode=INTPTR_PARAMETERS, ForEachDirection direction=ForEachDirection::kReverse)

void	BuildFastFixedArrayForEach (Node fixed_array, ElementsKind kind, Node first_element_inclusive, Node *last_element_exclusive, const FastFixedArrayForEachBody &body, ParameterMode mode=INTPTR_PARAMETERS, ForEachDirection direction=ForEachDirection::kReverse)

TNode< IntPtrT >	GetArrayAllocationSize (Node *element_count, ElementsKind kind, ParameterMode mode, int header_size)

TNode< IntPtrT >	GetFixedArrayAllocationSize (Node *element_count, ElementsKind kind, ParameterMode mode)

TNode< IntPtrT >	GetPropertyArrayAllocationSize (Node *element_count, ParameterMode mode)

void	GotoIfFixedArraySizeDoesntFitInNewSpace (Node element_count, Label doesnt_fit, int base_size, ParameterMode mode)

void	InitializeFieldsWithRoot (Node object, Node start_offset, Node *end_offset, RootIndex root)

Node *	RelationalComparison (Operation op, Node left, Node right, Node context, Variable var_type_feedback=nullptr)

void	BranchIfNumberRelationalComparison (Operation op, Node left, Node right, Label if_true, Label if_false)

void	BranchIfNumberEqual (TNode< Number > left, TNode< Number > right, Label if_true, Label if_false)

void	BranchIfNumberNotEqual (TNode< Number > left, TNode< Number > right, Label if_true, Label if_false)

void	BranchIfNumberLessThan (TNode< Number > left, TNode< Number > right, Label if_true, Label if_false)

void	BranchIfNumberLessThanOrEqual (TNode< Number > left, TNode< Number > right, Label if_true, Label if_false)

void	BranchIfNumberGreaterThan (TNode< Number > left, TNode< Number > right, Label if_true, Label if_false)

void	BranchIfNumberGreaterThanOrEqual (TNode< Number > left, TNode< Number > right, Label if_true, Label if_false)

void	BranchIfAccessorPair (Node value, Label if_accessor_pair, Label *if_not_accessor_pair)

void	GotoIfNumberGreaterThanOrEqual (Node left, Node right, Label *if_false)

Node *	Equal (Node lhs, Node rhs, Node context, Variable var_type_feedback=nullptr)

Node *	StrictEqual (Node lhs, Node rhs, Variable *var_type_feedback=nullptr)

void	BranchIfSameValue (Node lhs, Node rhs, Label if_true, Label if_false)

TNode< Oddball >	HasProperty (SloppyTNode< Context > context, SloppyTNode< Object > object, SloppyTNode< Object > key, HasPropertyLookupMode mode)

TNode< Oddball >	HasProperty_Inline (TNode< Context > context, TNode< JSReceiver > object, TNode< Object > key)

Node *	Typeof (Node *value)

TNode< Object >	GetSuperConstructor (SloppyTNode< Context > context, SloppyTNode< JSFunction > active_function)

TNode< JSReceiver >	SpeciesConstructor (SloppyTNode< Context > context, SloppyTNode< Object > object, SloppyTNode< JSReceiver > default_constructor)

Node *	InstanceOf (Node object, Node callable, Node *context)

Node *	IsDebugActive ()

TNode< BoolT >	IsRuntimeCallStatsEnabled ()

TNode< Uint32T >	LoadJSArrayBufferBitField (TNode< JSArrayBuffer > array_buffer)

TNode< RawPtrT >	LoadJSArrayBufferBackingStore (TNode< JSArrayBuffer > array_buffer)

Node *	IsDetachedBuffer (Node *buffer)

void	ThrowIfArrayBufferIsDetached (SloppyTNode< Context > context, TNode< JSArrayBuffer > array_buffer, const char *method_name)

TNode< JSArrayBuffer >	LoadJSArrayBufferViewBuffer (TNode< JSArrayBufferView > array_buffer_view)

TNode< UintPtrT >	LoadJSArrayBufferViewByteLength (TNode< JSArrayBufferView > array_buffer_view)

TNode< UintPtrT >	LoadJSArrayBufferViewByteOffset (TNode< JSArrayBufferView > array_buffer_view)

void	ThrowIfArrayBufferViewBufferIsDetached (SloppyTNode< Context > context, TNode< JSArrayBufferView > array_buffer_view, const char *method_name)

TNode< Smi >	LoadJSTypedArrayLength (TNode< JSTypedArray > typed_array)

TNode< IntPtrT >	ElementOffsetFromIndex (Node *index, ElementsKind kind, ParameterMode mode, int base_size=0)

TNode< BoolT >	IsOffsetInBounds (SloppyTNode< IntPtrT > offset, SloppyTNode< IntPtrT > length, int header_size, ElementsKind kind=HOLEY_ELEMENTS)

TNode< Code >	LoadBuiltin (TNode< Smi > builtin_id)

TNode< Code >	GetSharedFunctionInfoCode (SloppyTNode< SharedFunctionInfo > shared_info, Label *if_compile_lazy=nullptr)

Node *	AllocateFunctionWithMapAndContext (Node map, Node shared_info, Node *context)

Node *	IsPromiseHookEnabled ()

Node *	HasAsyncEventDelegate ()

Node *	IsPromiseHookEnabledOrHasAsyncEventDelegate ()

Node *	IsPromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate ()

Node *	MarkerIsFrameType (Node *marker_or_function, StackFrame::Type frame_type)

Node *	MarkerIsNotFrameType (Node *marker_or_function, StackFrame::Type frame_type)

void	CheckPrototypeEnumCache (Node receiver, Node receiver_map, Label if_fast, Label if_slow)

Node *	CheckEnumCache (Node receiver, Label if_empty, Label *if_runtime)

TNode< IntPtrT >	GetArgumentsLength (CodeStubArguments *args)

TNode< Object >	GetArgumentValue (CodeStubArguments *args, TNode< IntPtrT > index)

void	Print (const char *s)

void	Print (const char prefix, Node tagged_value)

void	Print (SloppyTNode< Object > tagged_value)

void	Print (TNode< MaybeObject > tagged_value)

template<class... TArgs>
Node *	MakeTypeError (MessageTemplate message, Node *context, TArgs... args)

void	Abort (AbortReason reason)

bool	ConstexprBoolNot (bool value)

bool	ConstexprInt31Equal (int31_t a, int31_t b)

uint32_t	ConstexprUint32Add (uint32_t a, uint32_t b)

void	PerformStackCheck (TNode< Context > context)

void	SetPropertyLength (TNode< Context > context, TNode< Object > array, TNode< Number > length)

void	GotoIfInitialPrototypePropertyModified (TNode< Map > object_map, TNode< Map > initial_prototype_map, int descfriptor, RootIndex field_name_root_index, Label *if_modified)

void	GotoIfInitialPrototypePropertiesModified (TNode< Map > object_map, TNode< Map > initial_prototype_map, Vector< DescriptorIndexAndName > properties, Label *if_modified)

void	DescriptorLookup (SloppyTNode< Name > unique_name, SloppyTNode< DescriptorArray > descriptors, SloppyTNode< Uint32T > bitfield3, Label if_found, TVariable< IntPtrT > var_name_index, Label *if_not_found)

void	TransitionLookup (SloppyTNode< Name > unique_name, SloppyTNode< TransitionArray > transitions, Label if_found, TVariable< IntPtrT > var_name_index, Label *if_not_found)

template<typename Array >
void	Lookup (TNode< Name > unique_name, TNode< Array > array, TNode< Uint32T > number_of_valid_entries, Label if_found, TVariable< IntPtrT > var_name_index, Label *if_not_found)

template<typename Array >
void	LookupLinear (TNode< Name > unique_name, TNode< Array > array, TNode< Uint32T > number_of_valid_entries, Label if_found, TVariable< IntPtrT > var_name_index, Label *if_not_found)

template<typename Array >
void	LookupBinary (TNode< Name > unique_name, TNode< Array > array, TNode< Uint32T > number_of_valid_entries, Label if_found, TVariable< IntPtrT > var_name_index, Label *if_not_found)

template<typename Array >
TNode< IntPtrT >	EntryIndexToIndex (TNode< Uint32T > entry_index)

template<typename Array >
TNode< IntPtrT >	ToKeyIndex (TNode< Uint32T > entry_index)

template<typename Array >
TNode< Name >	GetKey (TNode< Array > array, TNode< Uint32T > entry_index)

TNode< Uint32T >	DescriptorArrayGetDetails (TNode< DescriptorArray > descriptors, TNode< Uint32T > descriptor_number)

void	DescriptorArrayForEach (VariableList &variable_list, TNode< Uint32T > start_descriptor, TNode< Uint32T > end_descriptor, const ForEachDescriptorBodyFunction &body)

TNode< Name >	LoadKeyByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)

TNode< Uint32T >	LoadDetailsByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)

TNode< Object >	LoadValueByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)

TNode< MaybeObject >	LoadFieldTypeByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)

TNode< IntPtrT >	DescriptorEntryToIndex (TNode< IntPtrT > descriptor)

TNode< Name >	LoadKeyByDescriptorEntry (TNode< DescriptorArray > descriptors, TNode< IntPtrT > descriptor)

TNode< Name >	LoadKeyByDescriptorEntry (TNode< DescriptorArray > descriptors, int descriptor)

TNode< Uint32T >	LoadDetailsByDescriptorEntry (TNode< DescriptorArray > descriptors, TNode< IntPtrT > descriptor)

TNode< Uint32T >	LoadDetailsByDescriptorEntry (TNode< DescriptorArray > descriptors, int descriptor)

TNode< Object >	LoadValueByDescriptorEntry (TNode< DescriptorArray > descriptors, int descriptor)

TNode< MaybeObject >	LoadFieldTypeByDescriptorEntry (TNode< DescriptorArray > descriptors, TNode< IntPtrT > descriptor)

void	ForEachEnumerableOwnProperty (TNode< Context > context, TNode< Map > map, TNode< JSObject > object, const ForEachKeyValueFunction &body, Label *bailout)

TNode< Object >	CallGetterIfAccessor (Node value, Node details, Node context, Node receiver, Label *if_bailout, GetOwnPropertyMode mode=kCallJSGetter)

TNode< IntPtrT >	TryToIntptr (Node key, Label miss)

void	BranchIfPrototypesHaveNoElements (Node receiver_map, Label definitely_no_elements, Label *possibly_elements)

void	InitializeFunctionContext (Node native_context, Node context, int slots)

TNode< JSArray >	ArrayCreate (TNode< Context > context, TNode< Number > length)

TNode< Object >	CloneIfMutablePrimitive (TNode< Object > object)

template<>
TNode< IntPtrT >	LoadArrayLength (TNode< FixedArray > array)

template<>
TNode< IntPtrT >	LoadArrayLength (TNode< WeakFixedArray > array)

template<>
TNode< IntPtrT >	LoadArrayLength (TNode< PropertyArray > array)

template<>
TNode< IntPtrT >	LoadArrayLength (TNode< DescriptorArray > array)

template<>
TNode< IntPtrT >	LoadArrayLength (TNode< TransitionArray > array)

template<>
TNode< HeapObject >	LoadName (TNode< HeapObject > key)

template<>
TNode< HeapObject >	LoadName (TNode< HeapObject > key)

template<>
void	FindInsertionEntry (TNode< NameDictionary > dictionary, TNode< Name > key, TVariable< IntPtrT > *var_key_index)

template<>
void	InsertEntry (TNode< NameDictionary > dictionary, TNode< Name > name, TNode< Object > value, TNode< IntPtrT > index, TNode< Smi > enum_index)

template<>
void	InsertEntry (TNode< GlobalDictionary > dictionary, TNode< Name > key, TNode< Object > value, TNode< IntPtrT > index, TNode< Smi > enum_index)

Public Member Functions inherited from v8::internal::compiler::CodeAssembler
	CodeAssembler (CodeAssemblerState *state)

bool	Is64 () const

bool	IsFloat64RoundUpSupported () const

bool	IsFloat64RoundDownSupported () const

bool	IsFloat64RoundTiesEvenSupported () const

bool	IsFloat64RoundTruncateSupported () const

bool	IsInt32AbsWithOverflowSupported () const

bool	IsInt64AbsWithOverflowSupported () const

bool	IsIntPtrAbsWithOverflowSupported () const

template<class T >
TNode< T >	UncheckedCast (Node *value)

template<class T , class U >
TNode< T >	UncheckedCast (TNode< U > value)

template<class T >
TNode< T >	ReinterpretCast (Node *value)

CheckedNode< Object, false >	Cast (Node value, const char location="")

template<class T >
CheckedNode< T, true >	Cast (TNode< T > value, const char *location="")

TNode< Int32T >	Int32Constant (int32_t value)

TNode< Int64T >	Int64Constant (int64_t value)

TNode< IntPtrT >	IntPtrConstant (intptr_t value)

TNode< Uint32T >	Uint32Constant (uint32_t value)

TNode< UintPtrT >	UintPtrConstant (uintptr_t value)

TNode< Number >	NumberConstant (double value)

TNode< Smi >	SmiConstant (Smi value)

TNode< Smi >	SmiConstant (int value)

template<typename E , typename = typename std::enable_if<std::is_enum<E>::value>::type>
TNode< Smi >	SmiConstant (E value)

TNode< HeapObject >	UntypedHeapConstant (Handle< HeapObject > object)

template<class Type >
TNode< Type >	HeapConstant (Handle< Type > object)

TNode< String >	StringConstant (const char *str)

TNode< Oddball >	BooleanConstant (bool value)

TNode< ExternalReference >	ExternalConstant (ExternalReference address)

TNode< Float64T >	Float64Constant (double value)

TNode< HeapNumber >	NaNConstant ()

TNode< BoolT >	Int32TrueConstant ()

TNode< BoolT >	Int32FalseConstant ()

TNode< BoolT >	BoolConstant (bool value)

bool	ToInt32Constant (Node *node, int32_t &out_value)

bool	ToInt64Constant (Node *node, int64_t &out_value)

bool	ToSmiConstant (Node node, Smi out_value)

bool	ToIntPtrConstant (Node *node, intptr_t &out_value)

bool	IsUndefinedConstant (TNode< Object > node)

bool	IsNullConstant (TNode< Object > node)

TNode< Int32T >	Signed (TNode< Word32T > x)

TNode< IntPtrT >	Signed (TNode< WordT > x)

TNode< Uint32T >	Unsigned (TNode< Word32T > x)

TNode< UintPtrT >	Unsigned (TNode< WordT > x)

Node *	Parameter (int value)

TNode< Context >	GetJSContextParameter ()

void	Return (SloppyTNode< Object > value)

void	Return (SloppyTNode< Object > value1, SloppyTNode< Object > value2)

void	Return (SloppyTNode< Object > value1, SloppyTNode< Object > value2, SloppyTNode< Object > value3)

void	PopAndReturn (Node pop, Node value)

void	ReturnIf (Node condition, Node value)

void	ReturnRaw (Node *value)

void	DebugAbort (Node *message)

void	DebugBreak ()

void	Unreachable ()

void	Comment (const char *format,...)

void	Bind (Label *label)

void	Goto (Label *label)

void	GotoIf (SloppyTNode< IntegralT > condition, Label *true_label)

void	GotoIfNot (SloppyTNode< IntegralT > condition, Label *false_label)

void	Branch (SloppyTNode< IntegralT > condition, Label true_label, Label false_label)

template<class T >
TNode< T >	Uninitialized ()

template<class... T>
void	Bind (CodeAssemblerParameterizedLabel< T... > label, TNode< T > ... phis)

template<class... T, class... Args>
void	Branch (TNode< BoolT > condition, CodeAssemblerParameterizedLabel< T... > if_true, CodeAssemblerParameterizedLabel< T... > if_false, Args... args)

template<class... T, class... Args>
void	Goto (CodeAssemblerParameterizedLabel< T... > *label, Args... args)

void	Branch (TNode< BoolT > condition, const std::function< void()> &true_body, const std::function< void()> &false_body)

void	Branch (TNode< BoolT > condition, Label *true_label, const std::function< void()> &false_body)

void	Branch (TNode< BoolT > condition, const std::function< void()> &true_body, Label *false_label)

void	Switch (Node index, Label default_label, const int32_t case_values, Label *case_labels, size_t case_count)

Node *	LoadFramePointer ()

Node *	LoadParentFramePointer ()

Node *	LoadStackPointer ()

TNode< Object >	TaggedPoisonOnSpeculation (SloppyTNode< Object > value)

TNode< WordT >	WordPoisonOnSpeculation (SloppyTNode< WordT > value)

Node *	Load (MachineType rep, Node *base, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

template<class Type >
TNode< Type >	Load (MachineType rep, TNode< RawPtr< Type >> base)

Node *	Load (MachineType rep, Node base, Node offset, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)

Node *	AtomicLoad (MachineType rep, Node base, Node offset)

TNode< Object >	LoadRoot (RootIndex root_index)

Node *	Store (Node base, Node value)

Node *	Store (Node base, Node offset, Node *value)

Node *	StoreWithMapWriteBarrier (Node base, Node offset, Node *value)

Node *	StoreNoWriteBarrier (MachineRepresentation rep, Node base, Node value)

Node *	StoreNoWriteBarrier (MachineRepresentation rep, Node base, Node offset, Node *value)

Node *	AtomicStore (MachineRepresentation rep, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	AtomicExchange (MachineType type, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	AtomicCompareExchange (MachineType type, Node base, Node offset, Node old_value, Node new_value, Node old_value_high=nullptr, Node new_value_high=nullptr)

Node *	AtomicAdd (MachineType type, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	AtomicSub (MachineType type, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	AtomicAnd (MachineType type, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	AtomicOr (MachineType type, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	AtomicXor (MachineType type, Node base, Node offset, Node value, Node value_high=nullptr)

Node *	StoreRoot (RootIndex root_index, Node *value)

TNode< IntPtrT >	WordShr (TNode< IntPtrT > left, TNode< IntegralT > right)

TNode< IntPtrT >	WordSar (TNode< IntPtrT > left, TNode< IntegralT > right)

TNode< IntPtrT >	WordAnd (TNode< IntPtrT > left, TNode< IntPtrT > right)

template<class Left , class Right , class = typename std::enable_if< (std::is_base_of<Object, Left>::value \|\| std::is_base_of<ObjectPtr, Left>::value) && (std::is_base_of<Object, Right>::value \|\| std::is_base_of<ObjectPtr, Right>::value)>::type>
TNode< BoolT >	WordEqual (TNode< Left > left, TNode< Right > right)

TNode< BoolT >	WordEqual (TNode< Object > left, Node *right)

TNode< BoolT >	WordEqual (Node *left, TNode< Object > right)

template<class Left , class Right , class = typename std::enable_if< (std::is_base_of<Object, Left>::value \|\| std::is_base_of<ObjectPtr, Left>::value) && (std::is_base_of<Object, Right>::value \|\| std::is_base_of<ObjectPtr, Right>::value)>::type>
TNode< BoolT >	WordNotEqual (TNode< Left > left, TNode< Right > right)

TNode< BoolT >	WordNotEqual (TNode< Object > left, Node *right)

TNode< BoolT >	WordNotEqual (Node *left, TNode< Object > right)

TNode< BoolT >	IntPtrEqual (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< BoolT >	WordEqual (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< BoolT >	WordNotEqual (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< BoolT >	Word32Equal (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< BoolT >	Word32NotEqual (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< BoolT >	Word64Equal (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< BoolT >	Word64NotEqual (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< Int32T >	Int32Add (TNode< Int32T > left, TNode< Int32T > right)

TNode< Uint32T >	Uint32Add (TNode< Uint32T > left, TNode< Uint32T > right)

TNode< WordT >	IntPtrAdd (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< IntPtrT >	IntPtrDiv (TNode< IntPtrT > left, TNode< IntPtrT > right)

TNode< WordT >	IntPtrSub (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< WordT >	IntPtrMul (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< IntPtrT >	IntPtrAdd (TNode< IntPtrT > left, TNode< IntPtrT > right)

TNode< IntPtrT >	IntPtrSub (TNode< IntPtrT > left, TNode< IntPtrT > right)

TNode< IntPtrT >	IntPtrMul (TNode< IntPtrT > left, TNode< IntPtrT > right)

TNode< UintPtrT >	UintPtrAdd (TNode< UintPtrT > left, TNode< UintPtrT > right)

TNode< UintPtrT >	UintPtrSub (TNode< UintPtrT > left, TNode< UintPtrT > right)

TNode< WordT >	WordShl (SloppyTNode< WordT > value, int shift)

TNode< WordT >	WordShr (SloppyTNode< WordT > value, int shift)

TNode< WordT >	WordSar (SloppyTNode< WordT > value, int shift)

TNode< IntPtrT >	WordShr (TNode< IntPtrT > value, int shift)

TNode< IntPtrT >	WordSar (TNode< IntPtrT > value, int shift)

TNode< Word32T >	Word32Shr (SloppyTNode< Word32T > value, int shift)

TNode< WordT >	WordOr (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< WordT >	WordAnd (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< WordT >	WordXor (SloppyTNode< WordT > left, SloppyTNode< WordT > right)

TNode< WordT >	WordShl (SloppyTNode< WordT > left, SloppyTNode< IntegralT > right)

TNode< WordT >	WordShr (SloppyTNode< WordT > left, SloppyTNode< IntegralT > right)

TNode< WordT >	WordSar (SloppyTNode< WordT > left, SloppyTNode< IntegralT > right)

TNode< Word32T >	Word32Or (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< Word32T >	Word32And (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< Word32T >	Word32Xor (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< Word32T >	Word32Shl (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< Word32T >	Word32Shr (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< Word32T >	Word32Sar (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)

TNode< Word64T >	Word64Or (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< Word64T >	Word64And (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< Word64T >	Word64Xor (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< Word64T >	Word64Shl (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< Word64T >	Word64Shr (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< Word64T >	Word64Sar (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)

TNode< UintPtrT >	ChangeFloat64ToUintPtr (SloppyTNode< Float64T > value)

TNode< Float64T >	ChangeUintPtrToFloat64 (TNode< UintPtrT > value)

Node *	RoundIntPtrToFloat64 (Node *value)

TNode< UintPtrT >	ChangeUint32ToWord (SloppyTNode< Word32T > value)

TNode< IntPtrT >	ChangeInt32ToIntPtr (SloppyTNode< Word32T > value)

Node *	Retain (Node *value)

Node *	Projection (int index, Node *value)

template<int index, class T1 , class T2 >
TNode< typename std::tuple_element< index, std::tuple< T1, T2 > >::type >	Projection (TNode< PairT< T1, T2 >> value)

template<class... TArgs>
TNode< Object >	CallRuntime (Runtime::FunctionId function, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
TNode< Object >	CallRuntimeWithCEntry (Runtime::FunctionId function, TNode< Code > centry, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
void	TailCallRuntime (Runtime::FunctionId function, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
void	TailCallRuntime (Runtime::FunctionId function, TNode< Int32T > arity, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
void	TailCallRuntimeWithCEntry (Runtime::FunctionId function, TNode< Code > centry, TNode< Object > context, TArgs... args)

template<class T = Object, class... TArgs>
TNode< T >	CallStub (Callable const &callable, SloppyTNode< Object > context, TArgs... args)

template<class T = Object, class... TArgs>
TNode< T >	CallStub (const CallInterfaceDescriptor &descriptor, SloppyTNode< Code > target, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
Node *	CallStubR (const CallInterfaceDescriptor &descriptor, size_t result_size, SloppyTNode< Code > target, SloppyTNode< Object > context, TArgs... args)

Node *	CallStubN (const CallInterfaceDescriptor &descriptor, size_t result_size, int input_count, Node const inputs)

template<class... TArgs>
void	TailCallStub (Callable const &callable, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
void	TailCallStub (const CallInterfaceDescriptor &descriptor, SloppyTNode< Code > target, SloppyTNode< Object > context, TArgs... args)

template<class... TArgs>
Node *	TailCallBytecodeDispatch (const CallInterfaceDescriptor &descriptor, Node *target, TArgs... args)

template<class... TArgs>
Node *	TailCallStubThenBytecodeDispatch (const CallInterfaceDescriptor &descriptor, Node target, Node context, TArgs... args)

TNode< Object >	TailCallJSCode (TNode< Code > code, TNode< Context > context, TNode< JSFunction > function, TNode< Object > new_target, TNode< Int32T > arg_count)

template<class... TArgs>
Node *	CallJS (Callable const &callable, Node context, Node function, Node *receiver, TArgs... args)

template<class... TArgs>
Node *	ConstructJS (Callable const &callable, Node context, Node new_target, TArgs... args)

Node *	CallCFunctionN (Signature< MachineType > signature, int input_count, Node const *inputs)

Node *	CallCFunction1 (MachineType return_type, MachineType arg0_type, Node function, Node arg0)

Node *	CallCFunction1WithCallerSavedRegisters (MachineType return_type, MachineType arg0_type, Node function, Node arg0, SaveFPRegsMode mode)

Node *	CallCFunction2 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, Node function, Node arg0, Node *arg1)

Node *	CallCFunction3 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, Node function, Node arg0, Node arg1, Node arg2)

Node *	CallCFunction3WithCallerSavedRegisters (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, Node function, Node arg0, Node arg1, Node arg2, SaveFPRegsMode mode)

Node *	CallCFunction4 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, Node function, Node arg0, Node arg1, Node arg2, Node *arg3)

Node *	CallCFunction5 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, MachineType arg4_type, Node function, Node arg0, Node arg1, Node arg2, Node arg3, Node arg4)

Node *	CallCFunction6 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, MachineType arg4_type, MachineType arg5_type, Node function, Node arg0, Node arg1, Node arg2, Node arg3, Node arg4, Node *arg5)

Node *	CallCFunction9 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, MachineType arg4_type, MachineType arg5_type, MachineType arg6_type, MachineType arg7_type, MachineType arg8_type, Node function, Node arg0, Node arg1, Node arg2, Node arg3, Node arg4, Node arg5, Node arg6, Node arg7, Node arg8)

void	GotoIfException (Node node, Label if_exception, Variable *exception_var=nullptr)

Factory *	factory () const

Isolate *	isolate () const

Zone *	zone () const

CodeAssemblerState *	state ()

void	BreakOnNode (int node_id)

bool	UnalignedLoadSupported (MachineRepresentation rep) const

bool	UnalignedStoreSupported (MachineRepresentation rep) const

bool	IsExceptionHandlerActive () const

Protected Types
enum	ICMode { kNonGlobalIC, kGlobalIC }

enum	ElementSupport { kOnlyProperties, kSupportElements }

enum	StoreTransitionMapFlags { kCheckPrototypeValidity = 1 << 0, kValidateTransitionHandler = 1 << 1, kStoreTransitionMapFlagsMask }

Protected Member Functions
void	HandleStoreICHandlerCase (const StoreICParameters p, TNode< MaybeObject > handler, Label miss, ICMode ic_mode, ElementSupport support_elements=kOnlyProperties)

void	HandleStoreICTransitionMapHandlerCase (const StoreICParameters p, TNode< Map > transition_map, Label miss, StoreTransitionMapFlags flags)

void	JumpIfDataProperty (Node details, Label writable, Label *readonly)

void	BranchIfStrictMode (Node vector, Node slot, Label *if_strict)

void	InvalidateValidityCellIfPrototype (Node map, Node bitfield2=nullptr)

void	OverwriteExistingFastDataProperty (Node object, Node object_map, Node descriptors, Node descriptor_name_index, Node details, Node value, Label *slow, bool do_transitioning_store)

void	CheckFieldType (TNode< DescriptorArray > descriptors, Node name_index, Node representation, Node value, Label bailout)

Protected Member Functions inherited from v8::internal::compiler::CodeAssembler
void	RegisterCallGenerationCallbacks (const CodeAssemblerCallback &call_prologue, const CodeAssemblerCallback &call_epilogue)

void	UnregisterCallGenerationCallbacks ()

bool	Word32ShiftIsSafe () const

PoisoningMitigationLevel	poisoning_level () const

bool	IsJSFunctionCall () const

Additional Inherited Members
Static Public Member Functions inherited from v8::internal::compiler::CodeAssembler
static Handle< Code >	GenerateCode (CodeAssemblerState *state, const AssemblerOptions &options)

Public Attributes inherited from v8::internal::CodeStubAssembler
	IntPtrGreaterThanOrEqual

	IntPtrLessThanOrEqual

Int32LessThanOrEqual TNode< Smi >	b

Static Public Attributes inherited from v8::internal::CodeStubAssembler
static const int	kInlinedDictionaryProbes = 4

Static Public Attributes inherited from v8::internal::compiler::CodeAssembler
static constexpr int	kTargetParameterIndex = -1

Detailed Description

Definition at line 19 of file accessor-assembler.h.

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

v8/src/ic/accessor-assembler.h
v8/src/ic/accessor-assembler.cc

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Additional Inherited Members

Detailed Description