v8::internal::AsyncBuiltinsAssembler Class Reference

#include <builtins-async-gen.h>

Inheritance diagram for v8::internal::AsyncBuiltinsAssembler:

Collaboration diagram for v8::internal::AsyncBuiltinsAssembler:

Public Member Functions
	AsyncBuiltinsAssembler (compiler::CodeAssemblerState *state)
Public Member Functions inherited from v8::internal::PromiseBuiltinsAssembler
	PromiseBuiltinsAssembler (compiler::CodeAssemblerState *state)
void	ZeroOutEmbedderOffsets (TNode< JSPromise > promise)
TNode< HeapObject >	AllocateJSPromise (TNode< Context > context)
Public Member Functions inherited from v8::internal::CodeStubAssembler
	CodeStubAssembler (compiler::CodeAssemblerState *state)
TNode< UintPtrT >	ArrayBufferMaxByteLength ()
TNode< IntPtrT >	ParameterToIntPtr (TNode< Smi > value)
TNode< IntPtrT >	ParameterToIntPtr (TNode< IntPtrT > value)
TNode< IntPtrT >	ParameterToIntPtr (TNode< UintPtrT > value)
TNode< IntPtrT >	ParameterToIntPtr (TNode< TaggedIndex > value)
TNode< Smi >	ParameterToTagged (TNode< Smi > value)
TNode< Smi >	ParameterToTagged (TNode< IntPtrT > value)
template<typename TIndex >
TNode< TIndex >	TaggedToParameter (TNode< Smi > value)
bool	ToParameterConstant (TNode< Smi > node, intptr_t *out)
bool	ToParameterConstant (TNode< IntPtrT > node, intptr_t *out)
TNode< IntPtrT >	TaggedIndexToIntPtr (TNode< TaggedIndex > value)
TNode< TaggedIndex >	IntPtrToTaggedIndex (TNode< IntPtrT > value)
TNode< Smi >	TaggedIndexToSmi (TNode< TaggedIndex > value)
TNode< TaggedIndex >	SmiToTaggedIndex (TNode< Smi > value)
TNode< Smi >	NormalizeSmiIndex (TNode< Smi > smi_index)
TNode< Smi >	TaggedToSmi (TNode< Object > value, Label *fail)
TNode< Smi >	TaggedToPositiveSmi (TNode< Object > value, Label *fail)
TNode< String >	TaggedToDirectString (TNode< Object > value, Label *fail)
TNode< HeapObject >	TaggedToHeapObject (TNode< Object > value, Label *fail)
TNode< Uint16T >	Uint16Constant (uint16_t t)
TNode< JSDataView >	HeapObjectToJSDataView (TNode< HeapObject > heap_object, Label *fail)
TNode< JSProxy >	HeapObjectToJSProxy (TNode< HeapObject > heap_object, Label *fail)
TNode< JSStringIterator >	HeapObjectToJSStringIterator (TNode< HeapObject > heap_object, Label *fail)
TNode< JSCallable >	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)
TNode< JSFunction >	HeapObjectToJSFunctionWithPrototypeSlot (TNode< HeapObject > heap_object, Label *fail)
template<typename T >
TNode< T >	RunLazy (LazyNode< T > lazy)
	PARAMETER_BINOP (IntPtrOrSmiLessThanOrEqual, IntPtrLessThanOrEqual, SmiLessThanOrEqual) PARAMETER_BINOP(UintPtrOrSmiLessThanOrEqual
SmiBelowOrEqual	PARAMETER_BINOP (UintPtrOrSmiGreaterThanOrEqual, UintPtrGreaterThanOrEqual, SmiAboveOrEqual) uintptr_t ConstexprUintPtrShl(uintptr_t a
uintptr_t	ConstexprUintPtrShr (uintptr_t a, int32_t b)
intptr_t	ConstexprIntPtrAdd (intptr_t a, intptr_t b)
uintptr_t	ConstexprUintPtrAdd (uintptr_t a, uintptr_t b)
intptr_t	ConstexprWordNot (intptr_t a)
uintptr_t	ConstexprWordNot (uintptr_t a)
TNode< BoolT >	TaggedEqual (TNode< AnyTaggedT > a, TNode< AnyTaggedT > b)
TNode< BoolT >	TaggedNotEqual (TNode< AnyTaggedT > a, TNode< AnyTaggedT > b)
TNode< Smi >	NoContextConstant ()
TNode< IntPtrT >	StackAlignmentInBytes ()
TNode< BInt >	BIntConstant (int value)
template<typename TIndex >
TNode< TIndex >	IntPtrOrSmiConstant (int value)
bool	TryGetIntPtrOrSmiConstantValue (TNode< Smi > maybe_constant, int *value)
bool	TryGetIntPtrOrSmiConstantValue (TNode< IntPtrT > maybe_constant, int *value)
TNode< IntPtrT >	PopulationCountFallback (TNode< UintPtrT > value)
TNode< Int64T >	PopulationCount64 (TNode< Word64T > value)
TNode< Int32T >	PopulationCount32 (TNode< Word32T > value)
TNode< Int64T >	CountTrailingZeros64 (TNode< Word64T > value)
TNode< Int32T >	CountTrailingZeros32 (TNode< Word32T > value)
TNode< Int64T >	CountLeadingZeros64 (TNode< Word64T > value)
TNode< Int32T >	CountLeadingZeros32 (TNode< Word32T > value)
TNode< IntPtrT >	IntPtrRoundUpToPowerOfTwo32 (TNode< IntPtrT > value)
TNode< IntPtrT >	IntPtrMax (TNode< IntPtrT > left, TNode< IntPtrT > right)
TNode< IntPtrT >	IntPtrMin (TNode< IntPtrT > left, TNode< IntPtrT > right)
TNode< UintPtrT >	UintPtrMin (TNode< UintPtrT > left, TNode< UintPtrT > right)
TNode< BoolT >	Float64AlmostEqual (TNode< Float64T > x, TNode< Float64T > y, double max_relative_error=0.0000001)
TNode< Float64T >	Float64Ceil (TNode< Float64T > x)
TNode< Float64T >	Float64Floor (TNode< Float64T > x)
TNode< Float64T >	Float64Round (TNode< Float64T > x)
TNode< Float64T >	Float64RoundToEven (TNode< Float64T > x)
TNode< Float64T >	Float64Trunc (TNode< Float64T > x)
TNode< Number >	NumberMax (TNode< Number > left, TNode< Number > right)
TNode< Number >	NumberMin (TNode< Number > left, TNode< Number > right)
TNode< BoolT >	IsValidPositiveSmi (TNode< IntPtrT > value)
TNode< Smi >	SmiTag (TNode< IntPtrT > value)
TNode< IntPtrT >	SmiUntag (TNode< Smi > value)
TNode< IntPtrT >	PositiveSmiUntag (TNode< Smi > value)
TNode< Float64T >	SmiToFloat64 (TNode< Smi > value)
TNode< Smi >	SmiFromIntPtr (TNode< IntPtrT > value)
TNode< Smi >	SmiFromInt32 (TNode< Int32T > value)
TNode< Smi >	SmiFromUint32 (TNode< Uint32T > value)
TNode< IntPtrT >	SmiToIntPtr (TNode< Smi > value)
TNode< Int32T >	SmiToInt32 (TNode< Smi > value)
TNode< Uint32T >	PositiveSmiToUint32 (TNode< Smi > value)
TNode< IntPtrT >	TryIntPtrAdd (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_overflow)
TNode< IntPtrT >	TryIntPtrSub (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_overflow)
TNode< IntPtrT >	TryIntPtrMul (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_overflow)
TNode< IntPtrT >	TryIntPtrDiv (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_div_zero)
TNode< IntPtrT >	TryIntPtrMod (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_div_zero)
TNode< Int32T >	TryInt32Mul (TNode< Int32T > a, TNode< Int32T > 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 >	TrySmiAbs (TNode< Smi > a, Label *if_overflow)
TNode< Smi >	UnsignedSmiShl (TNode< Smi > a, int shift)
TNode< Smi >	SmiShl (TNode< Smi > a, int shift)
TNode< Smi >	SmiShr (TNode< Smi > a, int shift)
TNode< Smi >	SmiSar (TNode< Smi > a, int shift)
TNode< Smi >	WordOrSmiShr (TNode< Smi > a, int shift)
TNode< IntPtrT >	WordOrSmiShr (TNode< IntPtrT > a, int shift)
	SMI_COMPARISON_OP (SmiAboveOrEqual, UintPtrGreaterThanOrEqual, Uint32GreaterThanOrEqual) SMI_COMPARISON_OP(SmiBelowOrEqual
Uint32LessThanOrEqual	SMI_COMPARISON_OP (SmiLessThanOrEqual, IntPtrLessThanOrEqual, Int32LessThanOrEqual) SMI_COMPARISON_OP(SmiGreaterThanOrEqual
Uint32LessThanOrEqual Int32GreaterThanOrEqual TNode< Smi >	SmiMax (TNode< Smi > a, TNode< Smi > b)
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< Object >	GetCoverageInfo (TNode< SharedFunctionInfo > sfi)
	BINT_COMPARISON_OP (BIntAboveOrEqual, SmiAboveOrEqual, UintPtrGreaterThanOrEqual) BINT_COMPARISON_OP(BIntLessThanOrEqual
IntPtrLessThanOrEqual	BINT_COMPARISON_OP (BIntGreaterThanOrEqual, SmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual) TNode< Number > NumberInc(TNode< Number > value)
TNode< Number >	NumberDec (TNode< Number > value)
TNode< Number >	NumberAdd (TNode< Number > a, TNode< Number > b)
TNode< Number >	NumberSub (TNode< Number > a, TNode< Number > b)
void	GotoIfNotNumber (TNode< Object > value, Label *is_not_number)
void	GotoIfNumber (TNode< Object > value, Label *is_number)
TNode< Number >	SmiToNumber (TNode< Smi > v)
void	GotoIfLargeBigInt (TNode< BigInt > bigint, Label *true_label)
TNode< Word32T >	NormalizeShift32OperandIfNecessary (TNode< Word32T > right32)
TNode< Number >	BitwiseOp (TNode< Word32T > left32, TNode< Word32T > right32, Operation bitwise_op)
TNode< Number >	BitwiseSmiOp (TNode< Smi > left32, TNode< Smi > right32, Operation bitwise_op)
TNode< IntPtrT >	AlignToAllocationAlignment (TNode< IntPtrT > value)
TNode< HeapObject >	AllocateInNewSpace (TNode< IntPtrT > size, AllocationFlags flags=AllocationFlag::kNone)
TNode< HeapObject >	AllocateInNewSpace (int size, AllocationFlags flags=AllocationFlag::kNone)
TNode< HeapObject >	Allocate (TNode< IntPtrT > size, AllocationFlags flags=AllocationFlag::kNone)
TNode< HeapObject >	Allocate (int size, AllocationFlags flags=AllocationFlag::kNone)
TNode< BoolT >	IsRegularHeapObjectSize (TNode< IntPtrT > size)
void	Dcheck (const BranchGenerator &branch, const char *message, const char *file, int line, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	Dcheck (const NodeGenerator< BoolT > &condition_body, const char *message, const char *file, int line, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	Dcheck (TNode< Word32T > condition_node, const char *message, const char *file, int line, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	Check (const BranchGenerator &branch, const char *message, const char *file, int line, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	Check (const NodeGenerator< BoolT > &condition_body, const char *message, const char *file, int line, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	Check (TNode< Word32T > condition_node, const char *message, const char *file, int line, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	FailAssert (const char *message, const std::vector< FileAndLine > &files_and_lines, std::initializer_list< ExtraNode > extra_nodes={}, const SourceLocation &loc=SourceLocation::Current())
void	FastCheck (TNode< BoolT > condition)
TNode< RawPtrT >	LoadCodeInstructionStart (TNode< Code > code, CodeEntrypointTag tag)
TNode< BoolT >	IsMarkedForDeoptimization (TNode< Code > code)
void	DCheckReceiver (ConvertReceiverMode mode, TNode< JSAny > receiver)
template<typename TCallable , class... TArgs>
TNode< JSAny >	Call (TNode< Context > context, TNode< TCallable > callable, ConvertReceiverMode mode, TNode< JSAny > receiver, TArgs... args)
template<typename TCallable , class... TArgs>
TNode< JSAny >	Call (TNode< Context > context, TNode< TCallable > callable, TNode< JSReceiver > receiver, TArgs... args)
template<typename TCallable , class... TArgs>
TNode< JSAny >	Call (TNode< Context > context, TNode< TCallable > callable, TNode< JSAny > receiver, TArgs... args)
template<class... TArgs>
TNode< JSAny >	CallFunction (TNode< Context > context, TNode< JSFunction > callable, ConvertReceiverMode mode, TNode< JSAny > receiver, TArgs... args)
template<class... TArgs>
TNode< JSAny >	CallFunction (TNode< Context > context, TNode< JSFunction > callable, TNode< JSReceiver > receiver, TArgs... args)
template<class... TArgs>
TNode< JSAny >	CallFunction (TNode< Context > context, TNode< JSFunction > callable, TNode< JSAny > receiver, TArgs... args)
TNode< Object >	CallApiCallback (TNode< Object > context, TNode< RawPtrT > callback, TNode< Int32T > argc, TNode< Object > data, TNode< Object > holder, TNode< JSAny > receiver)
TNode< Object >	CallApiCallback (TNode< Object > context, TNode< RawPtrT > callback, TNode< Int32T > argc, TNode< Object > data, TNode< Object > holder, TNode< JSAny > receiver, TNode< Object > value)
TNode< Object >	CallRuntimeNewArray (TNode< Context > context, TNode< JSAny > receiver, TNode< Object > length, TNode< Object > new_target, TNode< Object > allocation_site)
void	TailCallRuntimeNewArray (TNode< Context > context, TNode< JSAny > receiver, TNode< Object > length, TNode< Object > new_target, TNode< Object > allocation_site)
template<class... TArgs>
TNode< JSReceiver >	ConstructWithTarget (TNode< Context > context, TNode< JSReceiver > target, TNode< JSReceiver > new_target, TArgs... args)
template<class... TArgs>
TNode< JSReceiver >	Construct (TNode< Context > context, TNode< JSReceiver > new_target, TArgs... args)
template<typename T >
TNode< T >	Select (TNode< BoolT > condition, const NodeGenerator< T > &true_body, const NodeGenerator< T > &false_body, BranchHint branch_hint=BranchHint::kNone)
template<class A >
TNode< A >	SelectConstant (TNode< BoolT > condition, TNode< A > true_value, TNode< A > false_value)
TNode< Int32T >	SelectInt32Constant (TNode< BoolT > condition, int true_value, int false_value)
TNode< IntPtrT >	SelectIntPtrConstant (TNode< BoolT > condition, int true_value, int false_value)
TNode< Boolean >	SelectBooleanConstant (TNode< BoolT > condition)
TNode< Smi >	SelectSmiConstant (TNode< BoolT > condition, Tagged< Smi > true_value, Tagged< Smi > false_value)
TNode< Smi >	SelectSmiConstant (TNode< BoolT > condition, int true_value, Tagged< Smi > false_value)
TNode< Smi >	SelectSmiConstant (TNode< BoolT > condition, Tagged< Smi > true_value, int false_value)
TNode< Smi >	SelectSmiConstant (TNode< BoolT > condition, int true_value, int false_value)
TNode< String >	SingleCharacterStringConstant (char const *single_char)
TNode< Float16RawBitsT >	TruncateFloat32ToFloat16 (TNode< Float32T > value)
TNode< Float16RawBitsT >	TruncateFloat64ToFloat16 (TNode< Float64T > value)
TNode< Int32T >	TruncateWordToInt32 (TNode< WordT > value)
TNode< Int32T >	TruncateIntPtrToInt32 (TNode< IntPtrT > value)
TNode< Word32T >	TruncateWord64ToWord32 (TNode< Word64T > value)
TNode< BoolT >	TaggedIsSmi (TNode< MaybeObject > a)
TNode< BoolT >	TaggedIsNotSmi (TNode< MaybeObject > a)
TNode< BoolT >	TaggedIsPositiveSmi (TNode< Object > a)
TNode< BoolT >	WordIsAligned (TNode< WordT > word, size_t alignment)
TNode< BoolT >	WordIsPowerOfTwo (TNode< IntPtrT > value)
template<typename U >
TNode< BoolT >	IsInRange (TNode< Word32T > value, U lower_limit, U higher_limit)
TNode< BoolT >	IsInRange (TNode< UintPtrT > value, TNode< UintPtrT > lower_limit, TNode< UintPtrT > higher_limit)
TNode< BoolT >	IsInRange (TNode< WordT > value, intptr_t lower_limit, intptr_t higher_limit)
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 (TNode< Float64T > value, Label *if_true, Label *if_false)
void	BranchIfToBooleanIsTrue (TNode< Object > value, Label *if_true, Label *if_false)
void	BranchIfToBooleanIsFalse (TNode< Object > value, Label *if_false, Label *if_true)
void	BranchIfJSReceiver (TNode< Object > object, Label *if_true, Label *if_false)
void	GotoIfForceSlowPath (Label *if_true)
TNode< RawPtrT >	LoadSandboxedPointerFromObject (TNode< HeapObject > object, int offset)
TNode< RawPtrT >	LoadSandboxedPointerFromObject (TNode< HeapObject > object, TNode< IntPtrT > offset)
void	StoreSandboxedPointerToObject (TNode< HeapObject > object, int offset, TNode< RawPtrT > pointer)
void	StoreSandboxedPointerToObject (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< RawPtrT > pointer)
TNode< RawPtrT >	EmptyBackingStoreBufferConstant ()
TNode< UintPtrT >	LoadBoundedSizeFromObject (TNode< HeapObject > object, int offset)
TNode< UintPtrT >	LoadBoundedSizeFromObject (TNode< HeapObject > object, TNode< IntPtrT > offset)
void	StoreBoundedSizeToObject (TNode< HeapObject > object, int offset, TNode< UintPtrT > value)
void	StoreBoundedSizeToObject (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< UintPtrT > value)
TNode< RawPtrT >	ExternalPointerTableAddress (ExternalPointerTagRange tag_range)
TNode< RawPtrT >	LoadExternalPointerFromObject (TNode< HeapObject > object, int offset, ExternalPointerTagRange tag_range)
TNode< RawPtrT >	LoadExternalPointerFromObject (TNode< HeapObject > object, TNode< IntPtrT > offset, ExternalPointerTagRange tag_range)
void	StoreExternalPointerToObject (TNode< HeapObject > object, int offset, TNode< RawPtrT > pointer, ExternalPointerTag tag)
void	StoreExternalPointerToObject (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< RawPtrT > pointer, ExternalPointerTag tag)
TNode< TrustedObject >	LoadTrustedPointerFromObject (TNode< HeapObject > object, int offset, IndirectPointerTag tag)
TNode< Code >	LoadCodePointerFromObject (TNode< HeapObject > object, int offset)
TNode< JSDispatchHandleT >	InvalidDispatchHandleConstant ()
TNode< Object >	LoadProtectedPointerField (TNode< TrustedObject > object, TNode< IntPtrT > offset)
TNode< Object >	LoadProtectedPointerField (TNode< TrustedObject > object, int offset)
TNode< RawPtrT >	LoadForeignForeignAddressPtr (TNode< Foreign > object, ExternalPointerTag tag)
TNode< RawPtrT >	LoadFunctionTemplateInfoJsCallbackPtr (TNode< FunctionTemplateInfo > object)
TNode< RawPtrT >	LoadExternalStringResourcePtr (TNode< ExternalString > object)
TNode< RawPtrT >	LoadExternalStringResourceDataPtr (TNode< ExternalString > object)
TNode< RawPtr< Uint64T > >	Log10OffsetTable ()
TNode< RawPtrT >	LoadJSTypedArrayExternalPointerPtr (TNode< JSTypedArray > holder)
void	StoreJSTypedArrayExternalPointerPtr (TNode< JSTypedArray > holder, TNode< RawPtrT > value)
void	InitializeJSAPIObjectWithEmbedderSlotsCppHeapWrapperPtr (TNode< JSAPIObjectWithEmbedderSlots > holder)
TNode< Object >	LoadFromParentFrame (int offset)
TNode< Object >	LoadBufferObject (TNode< RawPtrT > buffer, int offset)
template<typename T >
TNode< T >	LoadBufferData (TNode< RawPtrT > buffer, int offset)
TNode< RawPtrT >	LoadBufferPointer (TNode< RawPtrT > buffer, int offset)
TNode< Smi >	LoadBufferSmi (TNode< RawPtrT > buffer, int offset)
TNode< IntPtrT >	LoadBufferIntptr (TNode< RawPtrT > buffer, int offset)
TNode< Uint8T >	LoadUint8Ptr (TNode< RawPtrT > ptr, TNode< IntPtrT > offset)
TNode< Uint64T >	LoadUint64Ptr (TNode< RawPtrT > ptr, TNode< IntPtrT > index)
template<typename T >
TNode< T >	LoadObjectField (TNode< HeapObject > object, int offset)
TNode< Object >	LoadObjectField (TNode< HeapObject > object, int offset)
TNode< Object >	LoadObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset)
template<class T > requires std::is_convertible_v<TNode<T>, TNode<UntaggedT>>
TNode< T >	LoadObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset)
TNode< IntPtrT >	LoadAndUntagPositiveSmiObjectField (TNode< HeapObject > object, int offset)
TNode< Int32T >	LoadAndUntagToWord32ObjectField (TNode< HeapObject > object, int offset)
TNode< MaybeObject >	LoadMaybeWeakObjectField (TNode< HeapObject > object, int offset)
TNode< Object >	LoadConstructorOrBackPointer (TNode< Map > map)
TNode< Simd128T >	LoadSimd128 (TNode< IntPtrT > ptr)
template<class T > requires std::is_convertible_v<TNode<T>, TNode<Object>>
TNode< T >	LoadReference (Reference reference)
template<class T > requires (std::is_convertible_v<TNode<T>, TNode<UntaggedT>> || is_maybe_weak_v<T>)
TNode< T >	LoadReference (Reference reference)
template<class T > requires (std::is_convertible_v<TNode<T>, TNode<MaybeObject>>)
void	StoreReference (Reference reference, TNode< T > value)
template<class T > requires std::is_convertible_v<TNode<T>, TNode<UntaggedT>>
void	StoreReference (Reference reference, TNode< T > value)
TNode< RawPtrT >	GCUnsafeReferenceToRawPtr (TNode< Object > object, TNode< IntPtrT > offset)
TNode< Float64T >	LoadHeapNumberValue (TNode< HeapObject > object)
TNode< Int32T >	LoadHeapInt32Value (TNode< HeapObject > object)
void	StoreHeapInt32Value (TNode< HeapObject > object, TNode< Int32T > value)
TNode< Map >	LoadMap (TNode< HeapObject > object)
TNode< Uint16T >	LoadInstanceType (TNode< HeapObject > object)
TNode< BoolT >	HasInstanceType (TNode< HeapObject > object, InstanceType type)
TNode< BoolT >	DoesntHaveInstanceType (TNode< HeapObject > object, InstanceType type)
TNode< BoolT >	TaggedDoesntHaveInstanceType (TNode< HeapObject > any_tagged, InstanceType type)
TNode< Word32T >	IsStringWrapperElementsKind (TNode< Map > map)
void	GotoIfMapHasSlowProperties (TNode< Map > map, Label *if_slow)
TNode< HeapObject >	LoadSlowProperties (TNode< JSReceiver > object)
TNode< HeapObject >	LoadFastProperties (TNode< JSReceiver > object, bool skip_empty_check=false)
TNode< FixedArrayBase >	LoadElements (TNode< JSObject > object)
TNode< Object >	LoadJSArgumentsObjectLength (TNode< Context > context, TNode< JSArgumentsObject > array)
TNode< Smi >	LoadFastJSArrayLength (TNode< JSArray > array)
TNode< Smi >	LoadFixedArrayBaseLength (TNode< FixedArrayBase > array)
template<typename Array >
TNode< Smi >	LoadSmiArrayLength (TNode< Array > array)
TNode< IntPtrT >	LoadAndUntagFixedArrayBaseLength (TNode< FixedArrayBase > array)
TNode< Uint32T >	LoadAndUntagFixedArrayBaseLengthAsUint32 (TNode< FixedArrayBase > array)
TNode< Smi >	LoadWeakFixedArrayLength (TNode< WeakFixedArray > array)
TNode< IntPtrT >	LoadAndUntagWeakFixedArrayLength (TNode< WeakFixedArray > array)
TNode< Uint32T >	LoadAndUntagWeakFixedArrayLengthAsUint32 (TNode< WeakFixedArray > array)
TNode< Uint32T >	LoadAndUntagBytecodeArrayLength (TNode< BytecodeArray > array)
TNode< Int32T >	LoadNumberOfDescriptors (TNode< DescriptorArray > array)
TNode< Int32T >	LoadNumberOfOwnDescriptors (TNode< Map > map)
TNode< Int32T >	LoadMapBitField (TNode< Map > map)
TNode< Int32T >	LoadMapBitField2 (TNode< Map > map)
TNode< Uint32T >	LoadMapBitField3 (TNode< Map > map)
TNode< Uint16T >	LoadMapInstanceType (TNode< Map > map)
TNode< Int32T >	LoadMapElementsKind (TNode< Map > map)
TNode< Int32T >	LoadElementsKind (TNode< HeapObject > object)
TNode< DescriptorArray >	LoadMapDescriptors (TNode< Map > map)
TNode< JSPrototype >	LoadMapPrototype (TNode< Map > map)
TNode< IntPtrT >	LoadMapInstanceSizeInWords (TNode< Map > map)
TNode< IntPtrT >	LoadMapInobjectPropertiesStartInWords (TNode< Map > map)
TNode< IntPtrT >	LoadMapConstructorFunctionIndex (TNode< Map > map)
TNode< Object >	LoadMapConstructor (TNode< Map > map)
TNode< Uint32T >	LoadMapEnumLength (TNode< Map > map)
TNode< Object >	LoadMapBackPointer (TNode< Map > map)
TNode< IntPtrT >	MapUsedInstanceSizeInWords (TNode< Map > map)
TNode< IntPtrT >	MapUsedInObjectProperties (TNode< Map > map)
TNode< Uint32T >	EnsureOnlyHasSimpleProperties (TNode< Map > map, TNode< Int32T > instance_type, Label *bailout)
TNode< Uint32T >	LoadJSReceiverIdentityHash (TNode< JSReceiver > receiver, Label *if_no_hash=nullptr)
void	InitializePropertyArrayLength (TNode< PropertyArray > property_array, TNode< IntPtrT > length)
TNode< BoolT >	IsDictionaryMap (TNode< Map > map)
TNode< Uint32T >	LoadNameHash (TNode< Name > name, Label *if_hash_not_computed=nullptr)
TNode< Uint32T >	LoadNameHashAssumeComputed (TNode< Name > name)
TNode< Uint32T >	LoadNameRawHash (TNode< Name > name)
TNode< Smi >	LoadStringLengthAsSmi (TNode< String > string)
TNode< IntPtrT >	LoadStringLengthAsWord (TNode< String > string)
TNode< Uint32T >	LoadStringLengthAsWord32 (TNode< String > string)
TNode< Object >	LoadJSPrimitiveWrapperValue (TNode< JSPrimitiveWrapper > 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< HeapObjectReference > value)
TNode< HeapObject >	GetHeapObjectIfStrong (TNode< MaybeObject > value, Label *if_not_strong)
TNode< HeapObject >	GetHeapObjectIfStrong (TNode< HeapObjectReference > value, Label *if_not_strong)
TNode< BoolT >	IsWeakOrCleared (TNode< MaybeObject > value)
TNode< BoolT >	IsWeakOrCleared (TNode< HeapObjectReference > 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 > maybe_object, TNode< HeapObject > heap_object)
TNode< BoolT >	IsWeakReferenceToObject (TNode< MaybeObject > maybe_object, TNode< Object > object)
TNode< HeapObjectReference >	MakeWeak (TNode< HeapObject > value)
TNode< MaybeObject >	ClearedValue ()
void	FixedArrayBoundsCheck (TNode< FixedArrayBase > array, TNode< Smi > index, int additional_offset)
void	FixedArrayBoundsCheck (TNode< FixedArray > array, TNode< Smi > index, int additional_offset)
void	FixedArrayBoundsCheck (TNode< FixedArrayBase > array, TNode< IntPtrT > index, int additional_offset)
void	FixedArrayBoundsCheck (TNode< FixedArray > array, TNode< IntPtrT > index, int additional_offset)
void	FixedArrayBoundsCheck (TNode< FixedArrayBase > array, TNode< UintPtrT > index, int additional_offset)
void	FixedArrayBoundsCheck (TNode< FixedArrayBase > array, TNode< TaggedIndex > index, int additional_offset)
void	FixedArrayBoundsCheck (TNode< FixedArray > array, TNode< TaggedIndex > index, int additional_offset)
template<typename Array >
TNode< IntPtrT >	LoadArrayLength (TNode< Array > array)
template<typename Array , typename TIndex , typename TValue = MaybeObject>
TNode< TValue >	LoadArrayElement (TNode< Array > array, int array_header_size, TNode< TIndex > index, int additional_offset=0)
template<typename Array , typename TIndex >
TNode< typename Array::Shape::ElementT >	LoadArrayElement (TNode< Array > array, TNode< TIndex > index, int additional_offset=0)
template<typename TIndex >
TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, TNode< TIndex > index, int additional_offset=0, CheckBounds check_bounds=CheckBounds::kAlways)
TNode< Object >	UnsafeLoadFixedArrayElement (TNode< FixedArray > object, TNode< IntPtrT > index, int additional_offset=0)
TNode< Object >	LoadFixedArrayElement (TNode< FixedArray > object, int index, int additional_offset=0)
TNode< Object >	UnsafeLoadFixedArrayElement (TNode< FixedArray > object, int index, int additional_offset=0)
TNode< Object >	LoadPropertyArrayElement (TNode< PropertyArray > object, TNode< IntPtrT > index)
TNode< IntPtrT >	LoadPropertyArrayLength (TNode< PropertyArray > object)
template<typename Array >
TNode< Int32T >	LoadAndUntagToWord32ArrayElement (TNode< Array > array, int array_header_size, TNode< IntPtrT > index, int additional_offset=0)
TNode< Int32T >	LoadAndUntagToWord32FixedArrayElement (TNode< FixedArray > object, TNode< IntPtrT > index, int additional_offset=0)
TNode< MaybeObject >	LoadWeakFixedArrayElement (TNode< WeakFixedArray > object, TNode< IntPtrT > index, int additional_offset=0)
TNode< Float64T >	LoadFixedDoubleArrayElement (TNode< FixedDoubleArray > object, TNode< IntPtrT > index, Label *if_hole=nullptr, MachineType machine_type=MachineType::Float64())
TNode< Object >	LoadFixedArrayBaseElementAsTagged (TNode< FixedArrayBase > elements, TNode< IntPtrT > index, TNode< Int32T > elements_kind, Label *if_accessor, Label *if_hole)
template<typename TIndex >
TNode< MaybeObject >	LoadFeedbackVectorSlot (TNode< FeedbackVector > feedback_vector, TNode< TIndex > slot, int additional_offset=0)
TNode< IntPtrT >	LoadFeedbackVectorLength (TNode< FeedbackVector >)
TNode< Float64T >	LoadDoubleWithHoleCheck (TNode< FixedDoubleArray > array, TNode< IntPtrT > index, Label *if_hole=nullptr)
TNode< BoolT >	IsDoubleHole (TNode< Object > base, TNode< IntPtrT > offset)
TNode< Float64T >	LoadDoubleWithHoleCheck (TNode< Object > base, TNode< IntPtrT > offset, Label *if_hole, MachineType machine_type=MachineType::Float64())
TNode< Numeric >	LoadFixedTypedArrayElementAsTagged (TNode< RawPtrT > data_pointer, TNode< UintPtrT > index, ElementsKind elements_kind)
TNode< Numeric >	LoadFixedTypedArrayElementAsTagged (TNode< RawPtrT > data_pointer, TNode< UintPtrT > index, TNode< Int32T > elements_kind)
TNode< BigInt >	LoadFixedBigInt64ArrayElementAsTagged (TNode< RawPtrT > data_pointer, TNode< IntPtrT > offset)
TNode< BigInt >	LoadFixedBigUint64ArrayElementAsTagged (TNode< RawPtrT > data_pointer, TNode< IntPtrT > 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)
TNode< ScopeInfo >	LoadScopeInfo (TNode< Context > context)
TNode< BoolT >	LoadScopeInfoHasExtensionField (TNode< ScopeInfo > scope_info)
TNode< BoolT >	LoadScopeInfoClassScopeHasPrivateBrand (TNode< ScopeInfo > scope_info)
void	StoreContextElementNoWriteBarrier (TNode< Context > context, int slot_index, TNode< Object > value)
TNode< NativeContext >	LoadNativeContext (TNode< Context > context)
TNode< Context >	LoadModuleContext (TNode< Context > context)
TNode< Object >	GetImportMetaObject (TNode< Context > context)
void	GotoIfContextElementEqual (TNode< Object > value, TNode< NativeContext > native_context, int slot_index, Label *if_equal)
TNode< Map >	LoadObjectFunctionInitialMap (TNode< NativeContext > native_context)
TNode< Map >	LoadSlowObjectWithNullPrototypeMap (TNode< NativeContext > native_context)
TNode< Map >	LoadCachedMap (TNode< NativeContext > native_context, TNode< IntPtrT > number_of_properties, Label *runtime)
TNode< Map >	LoadJSArrayElementsMap (ElementsKind kind, TNode< NativeContext > native_context)
TNode< Map >	LoadJSArrayElementsMap (TNode< Int32T > kind, TNode< NativeContext > native_context)
TNode< BoolT >	IsJSFunctionWithPrototypeSlot (TNode< HeapObject > object)
TNode< Uint32T >	LoadFunctionKind (TNode< JSFunction > function)
TNode< BoolT >	IsGeneratorFunction (TNode< JSFunction > function)
void	BranchIfHasPrototypeProperty (TNode< JSFunction > function, TNode< Int32T > function_map_bit_field, Label *if_true, Label *if_false)
void	GotoIfPrototypeRequiresRuntimeLookup (TNode< JSFunction > function, TNode< Map > map, Label *runtime)
TNode< HeapObject >	LoadJSFunctionPrototype (TNode< JSFunction > function, Label *if_bailout)
TNode< Code >	LoadJSFunctionCode (TNode< JSFunction > function)
TNode< Object >	LoadSharedFunctionInfoTrustedData (TNode< SharedFunctionInfo > sfi)
TNode< Object >	LoadSharedFunctionInfoUntrustedData (TNode< SharedFunctionInfo > sfi)
TNode< BoolT >	SharedFunctionInfoHasBaselineCode (TNode< SharedFunctionInfo > sfi)
TNode< Smi >	LoadSharedFunctionInfoBuiltinId (TNode< SharedFunctionInfo > sfi)
TNode< BytecodeArray >	LoadSharedFunctionInfoBytecodeArray (TNode< SharedFunctionInfo > sfi)
TNode< Int32T >	LoadBytecodeArrayParameterCount (TNode< BytecodeArray > bytecode_array)
TNode< Int32T >	LoadBytecodeArrayParameterCountWithoutReceiver (TNode< BytecodeArray > bytecode_array)
void	StoreObjectByteNoWriteBarrier (TNode< HeapObject > object, int offset, TNode< Word32T > value)
void	StoreHeapNumberValue (TNode< HeapNumber > object, TNode< Float64T > value)
void	StoreObjectField (TNode< HeapObject > object, int offset, TNode< Smi > value)
void	StoreObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< Smi > value)
void	StoreObjectField (TNode< HeapObject > object, int offset, TNode< Object > value)
void	StoreObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< Object > value)
void	StoreIndirectPointerField (TNode< HeapObject > object, int offset, IndirectPointerTag tag, TNode< ExposedTrustedObject > value)
void	StoreIndirectPointerFieldNoWriteBarrier (TNode< HeapObject > object, int offset, IndirectPointerTag tag, TNode< ExposedTrustedObject > value)
void	StoreTrustedPointerField (TNode< HeapObject > object, int offset, IndirectPointerTag tag, TNode< ExposedTrustedObject > value)
void	StoreTrustedPointerFieldNoWriteBarrier (TNode< HeapObject > object, int offset, IndirectPointerTag tag, TNode< ExposedTrustedObject > value)
void	ClearTrustedPointerField (TNode< HeapObject > object, int offset)
void	StoreCodePointerField (TNode< HeapObject > object, int offset, TNode< Code > value)
void	StoreCodePointerFieldNoWriteBarrier (TNode< HeapObject > object, int offset, TNode< Code > value)
template<class T >
void	StoreObjectFieldNoWriteBarrier (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< T > value)
template<class T >
void	StoreObjectFieldNoWriteBarrier (TNode< HeapObject > object, int offset, TNode< T > value)
void	UnsafeStoreObjectFieldNoWriteBarrier (TNode< HeapObject > object, int offset, TNode< Object > value)
void	StoreMap (TNode< HeapObject > object, TNode< Map > map)
void	StoreMapNoWriteBarrier (TNode< HeapObject > object, RootIndex map_root_index)
void	StoreMapNoWriteBarrier (TNode< HeapObject > object, TNode< Map > map)
void	StoreObjectFieldRoot (TNode< HeapObject > object, int offset, RootIndex root)
void	StoreFixedArrayElement (TNode< FixedArray > object, int index, TNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, CheckBounds check_bounds=CheckBounds::kAlways)
void	StoreFixedArrayElement (TNode< FixedArray > object, int index, TNode< Smi > value, CheckBounds check_bounds=CheckBounds::kAlways)
template<typename TIndex >
void	StoreFixedArrayElement (TNode< FixedArray > array, TNode< TIndex > index, TNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, CheckBounds check_bounds=CheckBounds::kAlways)
template<typename TIndex >
void	StoreFixedArrayElement (TNode< FixedArray > array, TNode< TIndex > index, TNode< Smi > value, int additional_offset=0)
void	UnsafeStoreFixedArrayElement (TNode< FixedArray > object, int index, TNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
template<typename Array >
void	UnsafeStoreArrayElement (TNode< Array > object, int index, TNode< typename Array::Shape::ElementT > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
template<typename Array >
void	UnsafeStoreArrayElement (TNode< Array > object, TNode< Smi > index, TNode< typename Array::Shape::ElementT > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
void	UnsafeStoreFixedArrayElement (TNode< FixedArray > object, int index, TNode< Smi > value)
void	UnsafeStoreFixedArrayElement (TNode< FixedArray > array, TNode< IntPtrT > index, TNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0)
void	UnsafeStoreFixedArrayElement (TNode< FixedArray > array, TNode< IntPtrT > index, TNode< Smi > value, int additional_offset)
void	StorePropertyArrayElement (TNode< PropertyArray > array, TNode< IntPtrT > index, TNode< Object > value)
template<typename TIndex >
void	StoreFixedDoubleArrayElement (TNode< FixedDoubleArray > object, TNode< TIndex > index, TNode< Float64T > value, CheckBounds check_bounds=CheckBounds::kAlways)
void	StoreDoubleHole (TNode< HeapObject > object, TNode< IntPtrT > offset)
void	StoreFixedDoubleArrayHole (TNode< FixedDoubleArray > array, TNode< IntPtrT > index)
void	StoreFeedbackVectorSlot (TNode< FeedbackVector > feedback_vector, TNode< UintPtrT > slot, TNode< AnyTaggedT > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0)
void	StoreSharedObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< Object > value)
void	StoreJSSharedStructPropertyArrayElement (TNode< PropertyArray > array, TNode< IntPtrT > index, TNode< Object > value)
TNode< Int32T >	EnsureArrayPushable (TNode< Context > context, TNode< Map > map, Label *bailout)
void	TryStoreArrayElement (ElementsKind kind, Label *bailout, TNode< FixedArrayBase > elements, TNode< BInt > index, TNode< Object > value)
TNode< Smi >	BuildAppendJSArray (ElementsKind kind, TNode< JSArray > array, CodeStubArguments *args, TVariable< IntPtrT > *arg_index, Label *bailout)
void	BuildAppendJSArray (ElementsKind kind, TNode< JSArray > array, TNode< Object > value, Label *bailout)
void	StoreFieldsNoWriteBarrier (TNode< IntPtrT > start_address, TNode< IntPtrT > end_address, TNode< Object > value)
void	MakeFixedArrayCOW (TNode< FixedArray > array)
TNode< Cell >	AllocateCellWithValue (TNode< Object > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
TNode< Cell >	AllocateSmiCell (int value=0)
TNode< Object >	LoadCellValue (TNode< Cell > cell)
void	StoreCellValue (TNode< Cell > cell, TNode< Object > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
TNode< HeapNumber >	AllocateHeapNumber ()
TNode< HeapNumber >	AllocateHeapNumberWithValue (TNode< Float64T > value)
TNode< HeapNumber >	AllocateHeapNumberWithValue (double value)
TNode< HeapNumber >	AllocateHeapInt32WithValue (TNode< Int32T > value)
TNode< BigInt >	AllocateBigInt (TNode< IntPtrT > length)
TNode< BigInt >	AllocateRawBigInt (TNode< IntPtrT > length)
void	StoreBigIntBitfield (TNode< BigInt > bigint, TNode< Word32T > bitfield)
void	StoreBigIntDigit (TNode< BigInt > bigint, intptr_t digit_index, TNode< UintPtrT > digit)
void	StoreBigIntDigit (TNode< BigInt > bigint, TNode< IntPtrT > digit_index, TNode< UintPtrT > digit)
TNode< Word32T >	LoadBigIntBitfield (TNode< BigInt > bigint)
TNode< UintPtrT >	LoadBigIntDigit (TNode< BigInt > bigint, intptr_t digit_index)
TNode< UintPtrT >	LoadBigIntDigit (TNode< BigInt > bigint, TNode< IntPtrT > digit_index)
TNode< ByteArray >	AllocateNonEmptyByteArray (TNode< UintPtrT > length, AllocationFlags flags=AllocationFlag::kNone)
TNode< ByteArray >	AllocateByteArray (TNode< UintPtrT > length, AllocationFlags flags=AllocationFlag::kNone)
TNode< String >	AllocateSeqOneByteString (uint32_t length, AllocationFlags flags=AllocationFlag::kNone)
TNode< String >	AllocateSeqTwoByteString (uint32_t length, AllocationFlags flags=AllocationFlag::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< NameDictionary >	AllocateNameDictionary (int at_least_space_for)
TNode< NameDictionary >	AllocateNameDictionary (TNode< IntPtrT > at_least_space_for, AllocationFlags=AllocationFlag::kNone)
TNode< NameDictionary >	AllocateNameDictionaryWithCapacity (TNode< IntPtrT > capacity, AllocationFlags=AllocationFlag::kNone)
TNode< PropertyDictionary >	AllocatePropertyDictionary (int at_least_space_for)
TNode< PropertyDictionary >	AllocatePropertyDictionary (TNode< IntPtrT > at_least_space_for, AllocationFlags=AllocationFlag::kNone)
TNode< PropertyDictionary >	AllocatePropertyDictionaryWithCapacity (TNode< IntPtrT > capacity, AllocationFlags=AllocationFlag::kNone)
TNode< NameDictionary >	CopyNameDictionary (TNode< NameDictionary > dictionary, Label *large_object_fallback)
TNode< OrderedHashSet >	AllocateOrderedHashSet ()
TNode< OrderedHashSet >	AllocateOrderedHashSet (TNode< IntPtrT > capacity)
TNode< OrderedHashMap >	AllocateOrderedHashMap ()
TNode< OrderedNameDictionary >	AllocateOrderedNameDictionary (TNode< IntPtrT > capacity)
TNode< OrderedNameDictionary >	AllocateOrderedNameDictionary (int capacity)
TNode< JSObject >	AllocateJSObjectFromMap (TNode< Map > map, std::optional< TNode< HeapObject > > properties=std::nullopt, std::optional< TNode< FixedArray > > elements=std::nullopt, AllocationFlags flags=AllocationFlag::kNone, SlackTrackingMode slack_tracking_mode=kNoSlackTracking)
void	InitializeJSObjectFromMap (TNode< HeapObject > object, TNode< Map > map, TNode< IntPtrT > instance_size, std::optional< TNode< HeapObject > > properties=std::nullopt, std::optional< TNode< FixedArray > > elements=std::nullopt, SlackTrackingMode slack_tracking_mode=kNoSlackTracking)
void	InitializeJSObjectBodyWithSlackTracking (TNode< HeapObject > object, TNode< Map > map, TNode< IntPtrT > instance_size)
void	InitializeJSObjectBodyNoSlackTracking (TNode< HeapObject > object, TNode< Map > map, TNode< IntPtrT > instance_size, int start_offset=JSObject::kHeaderSize)
TNode< BoolT >	IsValidFastJSArrayCapacity (TNode< IntPtrT > capacity)
std::pair< TNode< JSArray >, TNode< FixedArrayBase > >	AllocateUninitializedJSArrayWithElements (ElementsKind kind, TNode< Map > array_map, TNode< Smi > length, std::optional< TNode< AllocationSite > > allocation_site, TNode< IntPtrT > capacity, AllocationFlags allocation_flags=AllocationFlag::kNone, int array_header_size=JSArray::kHeaderSize)
TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< IntPtrT > capacity, TNode< Smi > length, std::optional< TNode< AllocationSite > > allocation_site, AllocationFlags allocation_flags=AllocationFlag::kNone)
TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< Smi > capacity, TNode< Smi > length, std::optional< TNode< AllocationSite > > allocation_site, AllocationFlags allocation_flags=AllocationFlag::kNone)
TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< Smi > capacity, TNode< Smi > length, AllocationFlags allocation_flags=AllocationFlag::kNone)
TNode< JSArray >	AllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< IntPtrT > capacity, TNode< Smi > length, AllocationFlags allocation_flags=AllocationFlag::kNone)
TNode< JSArray >	AllocateJSArray (TNode< Map > array_map, TNode< FixedArrayBase > elements, TNode< Smi > length, std::optional< TNode< AllocationSite > > allocation_site=std::nullopt, int array_header_size=JSArray::kHeaderSize)
TNode< JSArray >	CloneFastJSArray (TNode< Context > context, TNode< JSArray > array, std::optional< TNode< AllocationSite > > allocation_site=std::nullopt, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert)
TNode< JSArray >	ExtractFastJSArray (TNode< Context > context, TNode< JSArray > array, TNode< BInt > begin, TNode< BInt > count)
template<typename TIndex >
TNode< FixedArrayBase >	AllocateFixedArray (ElementsKind kind, TNode< TIndex > capacity, AllocationFlags flags=AllocationFlag::kNone, std::optional< TNode< Map > > fixed_array_map=std::nullopt)
template<typename Function >
TNode< Object >	FastCloneJSObject (TNode< HeapObject > source, TNode< Map > source_map, TNode< Map > target_map, const Function &materialize_target, bool target_is_new)
TNode< NativeContext >	GetCreationContextFromMap (TNode< Map > map, Label *if_bailout)
TNode< NativeContext >	GetCreationContext (TNode< JSReceiver > receiver, Label *if_bailout)
TNode< NativeContext >	GetFunctionRealm (TNode< Context > context, TNode< JSReceiver > receiver, Label *if_bailout)
TNode< Object >	GetConstructor (TNode< Map > map)
void	FindNonDefaultConstructor (TNode< JSFunction > this_function, TVariable< Object > &constructor, Label *found_default_base_ctor, Label *found_something_else)
TNode< Map >	GetInstanceTypeMap (InstanceType instance_type)
TNode< FixedArray >	AllocateUninitializedFixedArray (intptr_t capacity)
TNode< FixedArray >	AllocateZeroedFixedArray (TNode< IntPtrT > capacity)
TNode< FixedDoubleArray >	AllocateZeroedFixedDoubleArray (TNode< IntPtrT > capacity)
TNode< FixedArray >	AllocateFixedArrayWithHoles (TNode< IntPtrT > capacity, AllocationFlags flags=AllocationFlag::kNone)
TNode< FixedDoubleArray >	AllocateFixedDoubleArrayWithHoles (TNode< IntPtrT > capacity, AllocationFlags flags=AllocationFlag::kNone)
TNode< PropertyArray >	AllocatePropertyArray (TNode< IntPtrT > capacity)
TNode< JSObject >	AllocateJSIteratorResult (TNode< Context > context, TNode< Object > value, TNode< Boolean > done)
TNode< JSObject >	AllocateJSIteratorResultForEntry (TNode< Context > context, TNode< Object > key, TNode< Object > value)
TNode< JSObject >	AllocatePromiseWithResolversResult (TNode< Context > context, TNode< Object > promise, TNode< Object > resolve, TNode< Object > reject)
TNode< JSReceiver >	ArraySpeciesCreate (TNode< Context > context, TNode< Object > originalArray, TNode< Number > len)
template<typename TIndex >
void	FillFixedArrayWithValue (ElementsKind kind, TNode< FixedArrayBase > array, TNode< TIndex > from_index, TNode< TIndex > to_index, RootIndex value_root_index)
template<typename TIndex >
void	FillFixedArrayWithValue (ElementsKind kind, TNode< FixedArray > array, TNode< TIndex > from_index, TNode< TIndex > to_index, RootIndex value_root_index)
void	FillFixedArrayWithSmiZero (ElementsKind kind, TNode< FixedArray > array, TNode< IntPtrT > start, TNode< IntPtrT > length)
void	FillEntireFixedArrayWithSmiZero (ElementsKind kind, TNode< FixedArray > array, TNode< IntPtrT > length)
void	FillFixedDoubleArrayWithZero (TNode< FixedDoubleArray > array, TNode< IntPtrT > start, TNode< IntPtrT > length)
void	FillEntireFixedDoubleArrayWithZero (TNode< FixedDoubleArray > array, TNode< IntPtrT > length)
void	FillPropertyArrayWithUndefined (TNode< PropertyArray > array, TNode< IntPtrT > from_index, TNode< IntPtrT > to_index)
void	IncrementCallCount (TNode< FeedbackVector > feedback_vector, TNode< UintPtrT > slot_id)
void	CopyPropertyArrayValues (TNode< HeapObject > from_array, TNode< PropertyArray > to_array, TNode< IntPtrT > length, WriteBarrierMode barrier_mode, DestroySource destroy_source)
template<typename TIndex >
void	CopyFixedArrayElements (ElementsKind kind, TNode< FixedArrayBase > from_array, TNode< FixedArrayBase > to_array, TNode< TIndex > length, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
template<typename TIndex >
void	CopyFixedArrayElements (ElementsKind from_kind, TNode< FixedArrayBase > from_array, ElementsKind to_kind, TNode< FixedArrayBase > to_array, TNode< TIndex > element_count, TNode< TIndex > capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
template<typename TIndex >
void	CopyFixedArrayElements (ElementsKind from_kind, TNode< FixedArrayBase > from_array, ElementsKind to_kind, TNode< FixedArrayBase > to_array, TNode< TIndex > first_element, TNode< TIndex > element_count, TNode< TIndex > capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert, TVariable< BoolT > *var_holes_converted=nullptr)
void	TrySkipWriteBarrier (TNode< Object > object, Label *if_needs_write_barrier)
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)
void	CopyRange (TNode< HeapObject > dst_object, int dst_offset, TNode< HeapObject > src_object, int src_offset, TNode< IntPtrT > length_in_tagged, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
TNode< FixedArray >	HeapObjectToFixedArray (TNode< HeapObject > base, Label *cast_fail)
TNode< FixedDoubleArray >	HeapObjectToFixedDoubleArray (TNode< HeapObject > base, Label *cast_fail)
TNode< ArrayList >	AllocateArrayList (TNode< Smi > size)
TNode< ArrayList >	ArrayListEnsureSpace (TNode< ArrayList > array, TNode< Smi > length)
TNode< ArrayList >	ArrayListAdd (TNode< ArrayList > array, TNode< Object > object)
void	ArrayListSet (TNode< ArrayList > array, TNode< Smi > index, TNode< Object > object)
TNode< Smi >	ArrayListGetLength (TNode< ArrayList > array)
void	ArrayListSetLength (TNode< ArrayList > array, TNode< Smi > length)
TNode< FixedArray >	ArrayListElements (TNode< ArrayList > array)
template<typename T >
bool	ClassHasMapConstant ()
template<typename T >
TNode< Map >	GetClassMapConstant ()
template<typename TIndex >
TNode< FixedArrayBase >	ExtractFixedArray (TNode< FixedArrayBase > source, std::optional< TNode< TIndex > > first, std::optional< TNode< TIndex > > count=std::nullopt, std::optional< TNode< TIndex > > capacity=std::nullopt, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, TVariable< BoolT > *var_holes_converted=nullptr, std::optional< TNode< Int32T > > source_elements_kind=std::nullopt)
template<typename TIndex >
TNode< FixedArray >	ExtractToFixedArray (TNode< FixedArrayBase > source, TNode< TIndex > first, TNode< TIndex > count, TNode< TIndex > capacity, TNode< Map > source_map, ElementsKind from_kind, AllocationFlags allocation_flags, ExtractFixedArrayFlags extract_flags, HoleConversionMode convert_holes, TVariable< BoolT > *var_holes_converted=nullptr, std::optional< TNode< Int32T > > source_runtime_kind=std::nullopt)
template<typename TIndex >
TNode< FixedArrayBase >	ExtractFixedDoubleArrayFillingHoles (TNode< FixedArrayBase > source, TNode< TIndex > first, TNode< TIndex > count, TNode< TIndex > capacity, TNode< Map > source_map, TVariable< BoolT > *var_holes_converted, AllocationFlags allocation_flags, ExtractFixedArrayFlags extract_flags)
TNode< FixedArrayBase >	CloneFixedArray (TNode< FixedArrayBase > source, ExtractFixedArrayFlags flags=ExtractFixedArrayFlag::kAllFixedArraysDontCopyCOW)
template<typename TResult >
TNode< TResult >	LoadElementAndPrepareForStore (TNode< FixedArrayBase > array, TNode< IntPtrT > offset, ElementsKind from_kind, ElementsKind to_kind, Label *if_hole)
template<typename TIndex >
TNode< TIndex >	CalculateNewElementsCapacity (TNode< TIndex > old_capacity)
TNode< FixedArrayBase >	TryGrowElementsCapacity (TNode< HeapObject > object, TNode< FixedArrayBase > elements, ElementsKind kind, TNode< Smi > key, Label *bailout)
template<typename TIndex >
TNode< FixedArrayBase >	TryGrowElementsCapacity (TNode< HeapObject > object, TNode< FixedArrayBase > elements, ElementsKind kind, TNode< TIndex > key, TNode< TIndex > capacity, Label *bailout)
template<typename TIndex >
TNode< FixedArrayBase >	GrowElementsCapacity (TNode< HeapObject > object, TNode< FixedArrayBase > elements, ElementsKind from_kind, ElementsKind to_kind, TNode< TIndex > capacity, TNode< TIndex > new_capacity, Label *bailout)
void	PossiblyGrowElementsCapacity (ElementsKind kind, TNode< HeapObject > array, TNode< BInt > length, TVariable< FixedArrayBase > *var_elements, TNode< BInt > growth, Label *bailout)
void	InitializeAllocationMemento (TNode< HeapObject > base, TNode< IntPtrT > base_allocation_size, TNode< AllocationSite > allocation_site)
TNode< IntPtrT >	TryTaggedToInt32AsIntPtr (TNode< Object > value, Label *if_not_possible)
TNode< Float64T >	TryTaggedToFloat64 (TNode< Object > value, Label *if_valueisnotnumber)
TNode< Float64T >	TruncateTaggedToFloat64 (TNode< Context > context, TNode< Object > value)
TNode< Word32T >	TruncateTaggedToWord32 (TNode< Context > context, TNode< Object > value)
void	TaggedToWord32OrBigInt (TNode< Context > context, TNode< Object > value, Label *if_number, TVariable< Word32T > *var_word32, Label *if_bigint, Label *if_bigint64, TVariable< BigInt > *var_maybe_bigint)
void	TaggedToWord32OrBigIntWithFeedback (TNode< Context > context, TNode< Object > value, Label *if_number, TVariable< Word32T > *var_word32, Label *if_bigint, Label *if_bigint64, TVariable< BigInt > *var_maybe_bigint, const FeedbackValues &feedback)
void	TaggedPointerToWord32OrBigIntWithFeedback (TNode< Context > context, TNode< HeapObject > pointer, Label *if_number, TVariable< Word32T > *var_word32, Label *if_bigint, Label *if_bigint64, TVariable< BigInt > *var_maybe_bigint, const FeedbackValues &feedback)
TNode< Int32T >	TruncateNumberToWord32 (TNode< Number > value)
TNode< Int32T >	TruncateHeapNumberValueToWord32 (TNode< HeapNumber > object)
TNode< Smi >	TryHeapNumberToSmi (TNode< HeapNumber > number, Label *not_smi)
TNode< Smi >	TryFloat32ToSmi (TNode< Float32T > number, Label *not_smi)
TNode< Smi >	TryFloat64ToSmi (TNode< Float64T > number, Label *not_smi)
TNode< Int32T >	TryFloat64ToInt32 (TNode< Float64T > number, Label *if_failed)
TNode< AdditiveSafeIntegerT >	TryFloat64ToAdditiveSafeInteger (TNode< Float64T > number, Label *if_failed)
TNode< BoolT >	IsAdditiveSafeInteger (TNode< Float64T > number)
TNode< Uint32T >	BitcastFloat16ToUint32 (TNode< Float16RawBitsT > value)
TNode< Float16RawBitsT >	BitcastUint32ToFloat16 (TNode< Uint32T > value)
TNode< Float16RawBitsT >	RoundInt32ToFloat16 (TNode< Int32T > value)
TNode< Float64T >	ChangeFloat16ToFloat64 (TNode< Float16RawBitsT > value)
TNode< Float32T >	ChangeFloat16ToFloat32 (TNode< Float16RawBitsT > value)
TNode< Number >	ChangeFloat32ToTagged (TNode< Float32T > value)
TNode< Number >	ChangeFloat64ToTagged (TNode< Float64T > value)
TNode< Number >	ChangeInt32ToTagged (TNode< Int32T > value)
TNode< Number >	ChangeInt32ToTaggedNoOverflow (TNode< Int32T > value)
TNode< Number >	ChangeUint32ToTagged (TNode< Uint32T > value)
TNode< Number >	ChangeUintPtrToTagged (TNode< UintPtrT > value)
TNode< Uint32T >	ChangeNonNegativeNumberToUint32 (TNode< Number > value)
TNode< Float64T >	ChangeNumberToFloat64 (TNode< Number > value)
TNode< Int32T >	ChangeTaggedNonSmiToInt32 (TNode< Context > context, TNode< HeapObject > input)
TNode< Float64T >	ChangeTaggedToFloat64 (TNode< Context > context, TNode< Object > input)
TNode< Int32T >	ChangeBoolToInt32 (TNode< BoolT > b)
void	TaggedToBigInt (TNode< Context > context, TNode< Object > value, Label *if_not_bigint, Label *if_bigint, Label *if_bigint64, TVariable< BigInt > *var_bigint, TVariable< Smi > *var_feedback)
void	SharedValueBarrier (TNode< Context > context, TVariable< Object > *var_shared_value)
TNode< WordT >	TimesSystemPointerSize (TNode< WordT > value)
TNode< IntPtrT >	TimesSystemPointerSize (TNode< IntPtrT > value)
TNode< UintPtrT >	TimesSystemPointerSize (TNode< UintPtrT > value)
TNode< WordT >	TimesTaggedSize (TNode< WordT > value)
TNode< IntPtrT >	TimesTaggedSize (TNode< IntPtrT > value)
TNode< UintPtrT >	TimesTaggedSize (TNode< UintPtrT > value)
TNode< WordT >	TimesDoubleSize (TNode< WordT > value)
TNode< UintPtrT >	TimesDoubleSize (TNode< UintPtrT > value)
TNode< IntPtrT >	TimesDoubleSize (TNode< IntPtrT > value)
TNode< String >	ToThisString (TNode< Context > context, TNode< Object > value, TNode< String > method_name)
TNode< String >	ToThisString (TNode< Context > context, TNode< Object > value, char const *method_name)
TNode< JSAny >	ToThisValue (TNode< Context > context, TNode< JSAny > value, PrimitiveType primitive_type, char const *method_name)
void	ThrowIfNotInstanceType (TNode< Context > context, TNode< Object > value, InstanceType instance_type, char const *method_name)
void	ThrowIfNotJSReceiver (TNode< Context > context, TNode< Object > value, MessageTemplate msg_template, const char *method_name)
void	ThrowIfNotCallable (TNode< Context > context, TNode< Object > value, const char *method_name)
void	ThrowRangeError (TNode< Context > context, MessageTemplate message, std::optional< TNode< Object > > arg0=std::nullopt, std::optional< TNode< Object > > arg1=std::nullopt, std::optional< TNode< Object > > arg2=std::nullopt)
void	ThrowTypeError (TNode< Context > context, MessageTemplate message, char const *arg0=nullptr, char const *arg1=nullptr)
void	ThrowTypeError (TNode< Context > context, MessageTemplate message, std::optional< TNode< Object > > arg0, std::optional< TNode< Object > > arg1=std::nullopt, std::optional< TNode< Object > > arg2=std::nullopt)
void	TerminateExecution (TNode< Context > context)
TNode< Union< Hole, JSMessageObject > >	GetPendingMessage ()
void	SetPendingMessage (TNode< Union< Hole, JSMessageObject > > message)
TNode< BoolT >	IsExecutionTerminating ()
TNode< Object >	GetContinuationPreservedEmbedderData ()
void	SetContinuationPreservedEmbedderData (TNode< Object > value)
TNode< BoolT >	InstanceTypeEqual (TNode< Int32T > instance_type, int type)
TNode< BoolT >	IsNoElementsProtectorCellInvalid ()
TNode< BoolT >	IsMegaDOMProtectorCellInvalid ()
TNode< BoolT >	IsAlwaysSharedSpaceJSObjectInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsArrayIteratorProtectorCellInvalid ()
TNode< BoolT >	IsBigIntInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsBigInt (TNode< HeapObject > object)
TNode< BoolT >	IsBoolean (TNode< HeapObject > object)
TNode< BoolT >	IsCallableMap (TNode< Map > map)
TNode< BoolT >	IsCallable (TNode< HeapObject > object)
TNode< BoolT >	TaggedIsCallable (TNode< Object > object)
TNode< BoolT >	IsCode (TNode< HeapObject > object)
TNode< BoolT >	TaggedIsCode (TNode< Object > object)
TNode< BoolT >	IsConsStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsConstructorMap (TNode< Map > map)
TNode< BoolT >	IsConstructor (TNode< HeapObject > object)
TNode< BoolT >	IsDeprecatedMap (TNode< Map > map)
TNode< BoolT >	IsPropertyDictionary (TNode< HeapObject > object)
TNode< BoolT >	IsOrderedNameDictionary (TNode< HeapObject > object)
TNode< BoolT >	IsGlobalDictionary (TNode< HeapObject > object)
TNode< BoolT >	IsExtensibleMap (TNode< Map > map)
TNode< BoolT >	IsExtensibleNonPrototypeMap (TNode< Map > map)
TNode< BoolT >	IsExternalStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsFixedArray (TNode< HeapObject > object)
TNode< BoolT >	IsFixedArraySubclass (TNode< HeapObject > object)
TNode< BoolT >	IsFixedArrayWithKind (TNode< HeapObject > object, ElementsKind kind)
TNode< BoolT >	IsFixedArrayWithKindOrEmpty (TNode< FixedArrayBase > object, ElementsKind kind)
TNode< BoolT >	IsFunctionWithPrototypeSlotMap (TNode< Map > map)
TNode< BoolT >	IsHashTable (TNode< HeapObject > object)
TNode< BoolT >	IsEphemeronHashTable (TNode< HeapObject > object)
TNode< BoolT >	IsHeapNumberInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsNotAnyHole (TNode< Object > object)
TNode< BoolT >	IsHoleInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsOddball (TNode< HeapObject > object)
TNode< BoolT >	IsOddballInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsIndirectStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSArrayBuffer (TNode< HeapObject > object)
TNode< BoolT >	IsJSDataView (TNode< HeapObject > object)
TNode< BoolT >	IsJSRabGsabDataView (TNode< HeapObject > object)
TNode< BoolT >	IsJSArrayInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSArrayMap (TNode< Map > map)
TNode< BoolT >	IsJSArray (TNode< HeapObject > object)
TNode< BoolT >	IsJSArrayIterator (TNode< HeapObject > object)
TNode< BoolT >	IsJSAsyncGeneratorObject (TNode< HeapObject > object)
TNode< BoolT >	IsFunctionInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSFunctionInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSFunctionMap (TNode< Map > map)
TNode< BoolT >	IsJSFunction (TNode< HeapObject > object)
TNode< BoolT >	IsJSBoundFunction (TNode< HeapObject > object)
TNode< BoolT >	IsJSGeneratorObject (TNode< HeapObject > object)
TNode< BoolT >	IsJSGlobalProxyInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSGlobalProxyMap (TNode< Map > map)
TNode< BoolT >	IsJSGlobalProxy (TNode< HeapObject > object)
TNode< BoolT >	IsJSObjectInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSObjectMap (TNode< Map > map)
TNode< BoolT >	IsJSObject (TNode< HeapObject > object)
TNode< BoolT >	IsJSApiObjectInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSApiObjectMap (TNode< Map > map)
TNode< BoolT >	IsJSApiObject (TNode< HeapObject > object)
TNode< BoolT >	IsJSFinalizationRegistryMap (TNode< Map > map)
TNode< BoolT >	IsJSFinalizationRegistry (TNode< HeapObject > object)
TNode< BoolT >	IsJSPromiseMap (TNode< Map > map)
TNode< BoolT >	IsJSPromise (TNode< HeapObject > object)
TNode< BoolT >	IsJSProxy (TNode< HeapObject > object)
TNode< BoolT >	IsJSStringIterator (TNode< HeapObject > object)
TNode< BoolT >	IsJSShadowRealm (TNode< HeapObject > object)
TNode< BoolT >	IsJSRegExpStringIterator (TNode< HeapObject > object)
TNode< BoolT >	IsJSReceiverInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSReceiverMap (TNode< Map > map)
TNode< BoolT >	IsJSReceiver (TNode< HeapObject > object)
TNode< BoolT >	JSAnyIsNotPrimitiveMap (TNode< Map > map)
TNode< BoolT >	JSAnyIsNotPrimitive (TNode< HeapObject > object)
TNode< BoolT >	IsJSRegExp (TNode< HeapObject > object)
TNode< BoolT >	IsJSTypedArrayInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSTypedArrayMap (TNode< Map > map)
TNode< BoolT >	IsJSTypedArray (TNode< HeapObject > object)
TNode< BoolT >	IsJSGeneratorMap (TNode< Map > map)
TNode< BoolT >	IsJSPrimitiveWrapperInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSPrimitiveWrapperMap (TNode< Map > map)
TNode< BoolT >	IsJSPrimitiveWrapper (TNode< HeapObject > object)
TNode< BoolT >	IsJSSharedArrayInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSSharedArrayMap (TNode< Map > map)
TNode< BoolT >	IsJSSharedArray (TNode< HeapObject > object)
TNode< BoolT >	IsJSSharedArray (TNode< Object > object)
TNode< BoolT >	IsJSSharedStructInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsJSSharedStructMap (TNode< Map > map)
TNode< BoolT >	IsJSSharedStruct (TNode< HeapObject > object)
TNode< BoolT >	IsJSSharedStruct (TNode< Object > object)
TNode< BoolT >	IsJSWrappedFunction (TNode< HeapObject > object)
TNode< BoolT >	IsMap (TNode< HeapObject > object)
TNode< BoolT >	IsName (TNode< HeapObject > object)
TNode< BoolT >	IsNameInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsNullOrJSReceiver (TNode< HeapObject > object)
TNode< BoolT >	IsNullOrUndefined (TNode< Object > object)
TNode< BoolT >	IsNumberDictionary (TNode< HeapObject > object)
TNode< BoolT >	IsOneByteStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsSeqOneByteStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsPrimitiveInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsPrivateName (TNode< Symbol > symbol)
TNode< BoolT >	IsPropertyArray (TNode< HeapObject > object)
TNode< BoolT >	IsPropertyCell (TNode< HeapObject > object)
TNode< BoolT >	IsPromiseReactionJobTask (TNode< HeapObject > object)
TNode< BoolT >	IsPrototypeInitialArrayPrototype (TNode< Context > context, TNode< Map > map)
TNode< BoolT >	IsPrototypeTypedArrayPrototype (TNode< Context > context, TNode< 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 (TNode< Int32T > instance_type)
TNode< BoolT >	IsUncachedExternalStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsSpecialReceiverInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsCustomElementsReceiverInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsSpecialReceiverMap (TNode< Map > map)
TNode< BoolT >	IsStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsString (TNode< HeapObject > object)
TNode< Word32T >	IsStringWrapper (TNode< HeapObject > object)
TNode< BoolT >	IsSeqOneByteString (TNode< HeapObject > object)
TNode< BoolT >	IsSequentialString (TNode< HeapObject > object)
TNode< BoolT >	IsSeqOneByteStringMap (TNode< Map > map)
TNode< BoolT >	IsSequentialStringMap (TNode< Map > map)
TNode< BoolT >	IsExternalStringMap (TNode< Map > map)
TNode< BoolT >	IsUncachedExternalStringMap (TNode< Map > map)
TNode< BoolT >	IsOneByteStringMap (TNode< Map > map)
TNode< BoolT >	IsSymbolInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsInternalizedStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsSharedStringInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsTemporalInstantInstanceType (TNode< Int32T > instance_type)
TNode< BoolT >	IsUniqueName (TNode< HeapObject > object)
TNode< BoolT >	IsUniqueNameNoIndex (TNode< HeapObject > object)
TNode< BoolT >	IsUniqueNameNoCachedIndex (TNode< HeapObject > object)
TNode< BoolT >	IsUndetectableMap (TNode< Map > map)
TNode< BoolT >	IsNotWeakFixedArraySubclass (TNode< HeapObject > object)
TNode< BoolT >	IsZeroOrContext (TNode< Object > object)
TNode< BoolT >	IsPromiseResolveProtectorCellInvalid ()
TNode< BoolT >	IsPromiseThenProtectorCellInvalid ()
TNode< BoolT >	IsArraySpeciesProtectorCellInvalid ()
TNode< BoolT >	IsIsConcatSpreadableProtectorCellInvalid ()
TNode< BoolT >	IsTypedArraySpeciesProtectorCellInvalid ()
TNode< BoolT >	IsRegExpSpeciesProtectorCellInvalid ()
TNode< BoolT >	IsPromiseSpeciesProtectorCellInvalid ()
TNode< BoolT >	IsNumberStringNotRegexpLikeProtectorCellInvalid ()
TNode< BoolT >	IsSetIteratorProtectorCellInvalid ()
TNode< BoolT >	IsMapIteratorProtectorCellInvalid ()
void	InvalidateStringWrapperToPrimitiveProtector ()
TNode< IntPtrT >	LoadMemoryChunkFlags (TNode< HeapObject > object)
TNode< BoolT >	LoadRuntimeFlag (ExternalReference address_of_flag)
TNode< BoolT >	IsMockArrayBufferAllocatorFlag ()
TNode< BoolT >	HasBuiltinSubclassingFlag ()
TNode< BoolT >	HasSharedStringTableFlag ()
TNode< BoolT >	IsScriptContextMutableHeapNumberFlag ()
TNode< BoolT >	IsScriptContextMutableHeapInt32Flag ()
TNode< BoolT >	IsAdditiveSafeIntegerFeedbackEnabled ()
TNode< BoolT >	IsNumeric (TNode< Object > object)
TNode< BoolT >	IsNumberNormalized (TNode< Number > number)
TNode< BoolT >	IsNumberPositive (TNode< 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)
template<typename TIndex >
TNode< BoolT >	FixedArraySizeDoesntFitInNewSpace (TNode< TIndex > element_count, int base_size)
TNode< BoolT >	ElementsKindEqual (TNode< Int32T > a, TNode< Int32T > b)
bool	ElementsKindEqual (ElementsKind a, ElementsKind b)
TNode< BoolT >	IsFastElementsKind (TNode< Int32T > elements_kind)
bool	IsFastElementsKind (ElementsKind kind)
TNode< BoolT >	IsFastPackedElementsKind (TNode< Int32T > elements_kind)
bool	IsFastPackedElementsKind (ElementsKind kind)
TNode< BoolT >	IsFastOrNonExtensibleOrSealedElementsKind (TNode< Int32T > elements_kind)
TNode< BoolT >	IsDictionaryElementsKind (TNode< Int32T > elements_kind)
TNode< BoolT >	IsDoubleElementsKind (TNode< Int32T > elements_kind)
bool	IsDoubleElementsKind (ElementsKind kind)
TNode< BoolT >	IsFastSmiOrTaggedElementsKind (TNode< Int32T > elements_kind)
TNode< BoolT >	IsFastSmiElementsKind (TNode< Int32T > elements_kind)
TNode< BoolT >	IsHoleyFastElementsKind (TNode< Int32T > elements_kind)
TNode< BoolT >	IsHoleyFastElementsKindForRead (TNode< Int32T > elements_kind)
TNode< BoolT >	IsElementsKindGreaterThan (TNode< Int32T > target_kind, ElementsKind reference_kind)
TNode< BoolT >	IsElementsKindGreaterThanOrEqual (TNode< Int32T > target_kind, ElementsKind reference_kind)
TNode< BoolT >	IsElementsKindLessThanOrEqual (TNode< Int32T > target_kind, ElementsKind reference_kind)
TNode< BoolT >	IsElementsKindInRange (TNode< Int32T > target_kind, ElementsKind lower_reference_kind, ElementsKind higher_reference_kind)
TNode< Int32T >	GetNonRabGsabElementsKind (TNode< Int32T > elements_kind)
TNode< Uint16T >	StringCharCodeAt (TNode< String > string, TNode< UintPtrT > index)
TNode< String >	StringFromSingleCharCode (TNode< Int32T > code)
TNode< Number >	StringToNumber (TNode< String > input)
TNode< String >	NumberToString (TNode< Number > input)
TNode< String >	NumberToString (TNode< Number > input, Label *bailout)
TNode< Number >	NonNumberToNumber (TNode< Context > context, TNode< HeapObject > input, BigIntHandling bigint_handling=BigIntHandling::kThrow)
TNode< Numeric >	NonNumberToNumeric (TNode< Context > context, TNode< HeapObject > input)
TNode< Number >	ToNumber (TNode< Context > context, TNode< Object > input, BigIntHandling bigint_handling=BigIntHandling::kThrow)
TNode< Number >	ToNumber_Inline (TNode< Context > context, TNode< Object > input)
TNode< Numeric >	ToNumberOrNumeric (LazyNode< Context > context, TNode< Object > input, TVariable< Smi > *var_type_feedback, Object::Conversion mode, BigIntHandling bigint_handling=BigIntHandling::kThrow)
TNode< Number >	PlainPrimitiveToNumber (TNode< Object > input)
TNode< BigInt >	ToBigInt (TNode< Context > context, TNode< Object > input)
TNode< BigInt >	ToBigIntConvertNumber (TNode< Context > context, TNode< Object > input)
TNode< Number >	ToUint32 (TNode< Context > context, TNode< Object > input)
TNode< IntPtrT >	ChangePositiveInt32ToIntPtr (TNode< Int32T > input)
TNode< String >	ToString_Inline (TNode< Context > context, TNode< Object > input)
TNode< JSReceiver >	ToObject (TNode< Context > context, TNode< Object > input)
TNode< JSReceiver >	ToObject_Inline (TNode< Context > context, TNode< Object > input)
TNode< Number >	ToLength_Inline (TNode< Context > context, TNode< Object > input)
TNode< Object >	OrdinaryToPrimitive (TNode< Context > context, TNode< Object > input, OrdinaryToPrimitiveHint hint)
template<typename BitField >
TNode< Uint32T >	DecodeWord32 (TNode< Word32T > word32)
template<typename BitField >
TNode< UintPtrT >	DecodeWord (TNode< WordT > word)
template<typename BitField >
TNode< UintPtrT >	DecodeWordFromWord32 (TNode< Word32T > word32)
template<typename BitField >
TNode< Uint32T >	DecodeWord32FromWord (TNode< WordT > word)
TNode< Uint32T >	DecodeWord32 (TNode< Word32T > word32, uint32_t shift, uint32_t mask)
TNode< UintPtrT >	DecodeWord (TNode< WordT > word, uint32_t shift, uintptr_t mask)
template<typename BitField >
TNode< Word32T >	UpdateWord32 (TNode< Word32T > word, TNode< Uint32T > value, bool starts_as_zero=false)
template<typename BitField >
TNode< WordT >	UpdateWord (TNode< WordT > word, TNode< UintPtrT > value, bool starts_as_zero=false)
template<typename BitField >
TNode< Word32T >	UpdateWordInWord32 (TNode< Word32T > word, TNode< UintPtrT > value, bool starts_as_zero=false)
template<typename BitField >
TNode< WordT >	UpdateWord32InWord (TNode< WordT > word, TNode< Uint32T > value, bool starts_as_zero=false)
TNode< Word32T >	UpdateWord32 (TNode< Word32T > word, TNode< Uint32T > value, uint32_t shift, uint32_t mask, bool starts_as_zero=false)
TNode< WordT >	UpdateWord (TNode< WordT > word, TNode< UintPtrT > value, uint32_t shift, uintptr_t mask, bool starts_as_zero=false)
template<typename T >
TNode< BoolT >	IsSetWord32 (TNode< Word32T > word32)
template<typename T >
TNode< BoolT >	IsNotSetWord32 (TNode< Word32T > word32)
TNode< BoolT >	IsSetWord32 (TNode< Word32T > word32, uint32_t mask)
TNode< BoolT >	IsNotSetWord32 (TNode< Word32T > word32, uint32_t mask)
TNode< BoolT >	IsAllSetWord32 (TNode< Word32T > word32, uint32_t mask)
template<typename BitField >
TNode< BoolT >	IsEqualInWord32 (TNode< Word32T > word32, typename BitField::FieldType value)
template<typename BitField1 , typename BitField2 >
TNode< BoolT >	IsBothEqualInWord32 (TNode< Word32T > word32, typename BitField1::FieldType value1, typename BitField2::FieldType value2)
template<typename BitField >
TNode< BoolT >	IsNotEqualInWord32 (TNode< Word32T > word32, typename BitField::FieldType value)
template<typename T >
TNode< BoolT >	IsSetWord (TNode< WordT > word)
TNode< BoolT >	IsSetWord (TNode< WordT > word, uint32_t mask)
TNode< BoolT >	IsSetSmi (TNode< Smi > smi, int untagged_mask)
template<typename T >
TNode< BoolT >	IsClearWord32 (TNode< Word32T > word32)
TNode< BoolT >	IsClearWord32 (TNode< Word32T > word32, uint32_t mask)
template<typename T >
TNode< BoolT >	IsClearWord (TNode< WordT > word)
TNode< BoolT >	IsClearWord (TNode< WordT > word, uint32_t mask)
void	SetCounter (StatsCounter *counter, int value)
void	IncrementCounter (StatsCounter *counter, int delta)
void	DecrementCounter (StatsCounter *counter, int delta)
template<typename TIndex >
void	Increment (TVariable< TIndex > *variable, int value=1)
template<typename TIndex >
void	Decrement (TVariable< TIndex > *variable, int value=1)
void	Use (Label *label)
void	TryToName (TNode< Object > key, Label *if_keyisindex, TVariable< IntPtrT > *var_index, Label *if_keyisunique, TVariable< Name > *var_unique, Label *if_bailout, Label *if_notinternalized=nullptr)
void	StringWriteToFlatOneByte (TNode< String > source, TNode< RawPtrT > sink, TNode< Int32T > start, TNode< Int32T > length)
void	StringWriteToFlatTwoByte (TNode< String > source, TNode< RawPtrT > sink, TNode< Int32T > start, TNode< Int32T > length)
TNode< RawPtr< Uint8T > >	ExternalOneByteStringGetChars (TNode< ExternalOneByteString > string)
TNode< RawPtr< Uint16T > >	ExternalTwoByteStringGetChars (TNode< ExternalTwoByteString > string)
TNode< RawPtr< Uint8T > >	IntlAsciiCollationWeightsL1 ()
TNode< RawPtr< Uint8T > >	IntlAsciiCollationWeightsL3 ()
void	TryInternalizeString (TNode< String > string, Label *if_index, TVariable< IntPtrT > *var_index, Label *if_internalized, TVariable< Name > *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 (TNode< ContainerType > container, TNode< IntPtrT > key_index)
template<class ContainerType >
TNode< Object >	LoadValueByKeyIndex (TNode< ContainerType > container, TNode< IntPtrT > 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)
TNode< IntPtrT >	NameToIndexHashTableLookup (TNode< NameToIndexHashTable > table, TNode< Name > name, Label *not_found)
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<class Dictionary >
TNode< Smi >	GetNameDictionaryFlags (TNode< Dictionary > dictionary)
template<class Dictionary >
void	SetNameDictionaryFlags (TNode< Dictionary >, TNode< Smi > flags)
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, LookupMode mode=kFindExisting)
template<typename Dictionary >
void	NameDictionaryLookupWithForwardIndex (TNode< Dictionary > dictionary, TNode< Name > unique_name, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found, LookupMode mode=kFindExisting)
TNode< Word32T >	ComputeSeededHash (TNode< IntPtrT > key)
void	NumberDictionaryLookup (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, Label *if_found, TVariable< IntPtrT > *var_entry, Label *if_not_found)
TNode< JSAny >	BasicLoadNumberDictionaryElement (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, Label *not_data, Label *if_hole)
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	AddToDictionary (TNode< Dictionary > dictionary, TNode< Name > key, TNode< Object > value, Label *bailout, std::optional< TNode< IntPtrT > > insertion_index=std::nullopt)
void	TryHasOwnProperty (TNode< HeapObject > object, TNode< Map > map, TNode< Int32T > instance_type, TNode< Name > unique_name, Label *if_found, Label *if_not_found, Label *if_bailout)
void	TryGetOwnProperty (TNode< Context > context, TNode< JSAny > receiver, TNode< JSReceiver > object, TNode< Map > map, TNode< Int32T > instance_type, TNode< Name > unique_name, Label *if_found_value, TVariable< Object > *var_value, Label *if_not_found, Label *if_bailout, ExpectedReceiverMode expected_receiver_mode=kExpectingAnyReceiver)
void	TryGetOwnProperty (TNode< Context > context, TNode< JSAny > receiver, TNode< JSReceiver > object, TNode< Map > map, TNode< Int32T > instance_type, TNode< Name > unique_name, Label *if_found_value, TVariable< Object > *var_value, TVariable< Uint32T > *var_details, TVariable< Object > *var_raw_value, Label *if_not_found, Label *if_bailout, GetOwnPropertyMode mode, ExpectedReceiverMode expected_receiver_mode=kExpectingAnyReceiver)
TNode< PropertyDescriptorObject >	AllocatePropertyDescriptorObject (TNode< Context > context)
void	InitializePropertyDescriptorObject (TNode< PropertyDescriptorObject > descriptor, TNode< Object > value, TNode< Uint32T > details, Label *if_bailout)
TNode< JSAny >	GetProperty (TNode< Context > context, TNode< JSAny > receiver, Handle< Name > name)
TNode< JSAny >	GetProperty (TNode< Context > context, TNode< JSAny > receiver, TNode< Object > name)
TNode< BoolT >	IsInterestingProperty (TNode< Name > name)
TNode< JSAny >	GetInterestingProperty (TNode< Context > context, TNode< JSReceiver > receiver, TNode< Name > name, Label *if_not_found)
TNode< JSAny >	GetInterestingProperty (TNode< Context > context, TNode< JSAny > receiver, TVariable< JSAnyNotSmi > *var_holder, TVariable< Map > *var_holder_map, TNode< Name > name, Label *if_not_found)
TNode< Object >	SetPropertyStrict (TNode< Context > context, TNode< JSAny > receiver, TNode< Object > key, TNode< Object > value)
TNode< Object >	CreateDataProperty (TNode< Context > context, TNode< JSObject > receiver, TNode< Object > key, TNode< Object > value)
TNode< JSAny >	GetMethod (TNode< Context > context, TNode< JSAny > object, Handle< Name > name, Label *if_null_or_undefined)
TNode< JSAny >	GetIteratorMethod (TNode< Context > context, TNode< JSAnyNotSmi > heap_obj, Label *if_iteratorundefined)
TNode< JSAny >	CreateAsyncFromSyncIterator (TNode< Context > context, TNode< JSAny > sync_iterator)
TNode< JSObject >	CreateAsyncFromSyncIterator (TNode< Context > context, TNode< JSReceiver > sync_iterator, TNode< Object > next)
void	LoadPropertyFromFastObject (TNode< HeapObject > object, TNode< Map > map, TNode< DescriptorArray > descriptors, TNode< IntPtrT > name_index, TVariable< Uint32T > *var_details, TVariable< Object > *var_value)
void	LoadPropertyFromFastObject (TNode< HeapObject > object, TNode< Map > map, TNode< DescriptorArray > descriptors, TNode< IntPtrT > name_index, TNode< Uint32T >, TVariable< Object > *var_value)
template<typename Dictionary >
void	LoadPropertyFromDictionary (TNode< Dictionary > dictionary, TNode< IntPtrT > name_index, TVariable< Uint32T > *var_details, TVariable< Object > *var_value)
void	LoadPropertyFromGlobalDictionary (TNode< GlobalDictionary > dictionary, TNode< IntPtrT > name_index, TVariable< Uint32T > *var_details, TVariable< Object > *var_value, Label *if_deleted)
void	TryLookupProperty (TNode< HeapObject > object, TNode< Map > map, TNode< Int32T > instance_type, TNode< 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, Label *bailout)
void	TryLookupElement (TNode< HeapObject > object, TNode< Map > map, TNode< Int32T > instance_type, TNode< 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 (TNode< JSAny > receiver, TNode< JSAny > object, TNode< Object > key, const LookupPropertyInHolder &lookup_property_in_holder, const LookupElementInHolder &lookup_element_in_holder, Label *if_end, Label *if_bailout, Label *if_proxy, bool handle_private_names=false)
TNode< Boolean >	HasInPrototypeChain (TNode< Context > context, TNode< HeapObject > object, TNode< Object > prototype)
TNode< Boolean >	OrdinaryHasInstance (TNode< Context > context, TNode< Object > callable, TNode< Object > object)
TNode< BytecodeArray >	LoadBytecodeArrayFromBaseline ()
TNode< FeedbackVector >	LoadFeedbackVectorForStub ()
TNode< FeedbackVector >	LoadFeedbackVectorFromBaseline ()
TNode< Context >	LoadContextFromBaseline ()
TNode< FeedbackVector >	LoadFeedbackVectorForStubWithTrampoline ()
TNode< HeapObject >	LoadFeedbackCellValue (TNode< JSFunction > closure)
TNode< HeapObject >	LoadFeedbackVector (TNode< JSFunction > closure)
TNode< FeedbackVector >	LoadFeedbackVector (TNode< JSFunction > closure, Label *if_no_feedback_vector)
TNode< ClosureFeedbackCellArray >	LoadClosureFeedbackArray (TNode< JSFunction > closure)
bool	UpdateFeedbackModeEqual (UpdateFeedbackMode a, UpdateFeedbackMode b)
void	UpdateFeedback (TNode< Smi > feedback, TNode< HeapObject > maybe_feedback_vector, TNode< UintPtrT > slot_id, UpdateFeedbackMode mode)
void	UpdateFeedback (TNode< Smi > feedback, TNode< FeedbackVector > feedback_vector, TNode< UintPtrT > slot_id)
void	MaybeUpdateFeedback (TNode< Smi > feedback, TNode< HeapObject > maybe_feedback_vector, TNode< UintPtrT > slot_id)
void	ReportFeedbackUpdate (TNode< FeedbackVector > feedback_vector, TNode< UintPtrT > slot_id, const char *reason)
void	CombineFeedback (TVariable< Smi > *existing_feedback, int feedback)
void	CombineFeedback (TVariable< Smi > *existing_feedback, TNode< Smi > feedback)
void	OverwriteFeedback (TVariable< Smi > *existing_feedback, int new_feedback)
void	CheckForAssociatedProtector (TNode< Name > name, Label *if_protector)
TNode< Map >	LoadReceiverMap (TNode< Object > receiver)
TNode< Context >	LoadScriptContext (TNode< Context > context, TNode< IntPtrT > context_index)
TNode< Uint8T >	Int32ToUint8Clamped (TNode< Int32T > int32_value)
TNode< Uint8T >	Float64ToUint8Clamped (TNode< Float64T > float64_value)
template<typename T >
TNode< T >	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
template<typename TIndex , typename TValue >
void	StoreElement (TNode< RawPtrT > elements, ElementsKind kind, TNode< TIndex > index, TNode< TValue > value)
void	BigIntToRawBytes (TNode< BigInt > bigint, TVariable< UintPtrT > *var_low, TVariable< UintPtrT > *var_high)
void	EmitElementStore (TNode< JSObject > object, TNode< Object > key, TNode< Object > value, ElementsKind elements_kind, KeyedAccessStoreMode store_mode, Label *bailout, TNode< Context > context, TVariable< Object > *maybe_converted_value=nullptr)
TNode< FixedArrayBase >	CheckForCapacityGrow (TNode< JSObject > object, TNode< FixedArrayBase > elements, ElementsKind kind, TNode< UintPtrT > length, TNode< IntPtrT > key, Label *bailout)
TNode< FixedArrayBase >	CopyElementsOnWrite (TNode< HeapObject > object, TNode< FixedArrayBase > elements, ElementsKind kind, TNode< IntPtrT > length, Label *bailout)
void	TransitionElementsKind (TNode< JSObject > object, TNode< Map > map, ElementsKind from_kind, ElementsKind to_kind, Label *bailout)
void	TrapAllocationMemento (TNode< JSObject > object, Label *memento_found)
TNode< IntPtrT >	MemoryChunkFromAddress (TNode< IntPtrT > address)
TNode< IntPtrT >	PageMetadataFromMemoryChunk (TNode< IntPtrT > address)
TNode< IntPtrT >	PageMetadataFromAddress (TNode< IntPtrT > address)
TNode< MaybeObject >	StoreWeakReferenceInFeedbackVector (TNode< FeedbackVector > feedback_vector, TNode< UintPtrT > slot, TNode< HeapObject > value, int additional_offset=0)
TNode< AllocationSite >	CreateAllocationSiteInFeedbackVector (TNode< FeedbackVector > feedback_vector, TNode< UintPtrT > slot)
TNode< BoolT >	HasBoilerplate (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)
TNode< Object >	LoadNestedAllocationSite (TNode< AllocationSite > allocation_site)
TNode< Object >	LoadAccessorPairGetter (TNode< AccessorPair > accessor_pair)
TNode< Object >	LoadAccessorPairSetter (TNode< AccessorPair > accessor_pair)
template<typename TIndex >
void	BuildFastLoop (const VariableList &vars, TVariable< TIndex > &var_index, TNode< TIndex > start_index, TNode< TIndex > end_index, const FastLoopBody< TIndex > &body, TNode< TIndex > increment, LoopUnrollingMode unrolling_mode, IndexAdvanceMode advance_mode, IndexAdvanceDirection advance_direction)
template<typename TIndex >
void	BuildFastLoop (const VariableList &vars, TVariable< TIndex > &var_index, TNode< TIndex > start_index, TNode< TIndex > end_index, const FastLoopBody< TIndex > &body, int increment, LoopUnrollingMode unrolling_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)
template<typename TIndex >
void	BuildFastLoop (TVariable< TIndex > &var_index, TNode< TIndex > start_index, TNode< TIndex > end_index, const FastLoopBody< TIndex > &body, int increment, LoopUnrollingMode unrolling_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)
template<typename TIndex >
void	BuildFastLoop (const VariableList &vars, TNode< TIndex > start_index, TNode< TIndex > end_index, const FastLoopBody< TIndex > &body, int increment, LoopUnrollingMode unrolling_mode, IndexAdvanceMode advance_mode)
template<typename TIndex >
void	BuildFastLoop (TNode< TIndex > start_index, TNode< TIndex > end_index, const FastLoopBody< TIndex > &body, int increment, LoopUnrollingMode unrolling_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)
template<typename TIndex >
void	BuildFastArrayForEach (TNode< UnionOf< FixedArray, PropertyArray, HeapObject > > array, ElementsKind kind, TNode< TIndex > first_element_inclusive, TNode< TIndex > last_element_exclusive, const FastArrayForEachBody &body, LoopUnrollingMode loop_unrolling_mode, ForEachDirection direction=ForEachDirection::kReverse)
template<typename TIndex >
TNode< IntPtrT >	GetArrayAllocationSize (TNode< TIndex > element_count, ElementsKind kind, int header_size)
template<typename TIndex >
TNode< IntPtrT >	GetFixedArrayAllocationSize (TNode< TIndex > element_count, ElementsKind kind)
TNode< IntPtrT >	GetPropertyArrayAllocationSize (TNode< IntPtrT > element_count)
template<typename TIndex >
void	GotoIfFixedArraySizeDoesntFitInNewSpace (TNode< TIndex > element_count, Label *doesnt_fit, int base_size)
void	InitializeFieldsWithRoot (TNode< HeapObject > object, TNode< IntPtrT > start_offset, TNode< IntPtrT > end_offset, RootIndex root)
TNode< Context >	GotoIfHasContextExtensionUpToDepth (TNode< Context > context, TNode< Uint32T > depth, Label *target)
TNode< Boolean >	RelationalComparison (Operation op, TNode< Object > left, TNode< Object > right, TNode< Context > context, TVariable< Smi > *var_type_feedback=nullptr)
TNode< Boolean >	RelationalComparison (Operation op, TNode< Object > left, TNode< Object > right, const LazyNode< Context > &context, TVariable< Smi > *var_type_feedback=nullptr)
void	BranchIfNumberRelationalComparison (Operation op, TNode< Number > left, TNode< Number > 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 (TNode< Object > value, Label *if_accessor_pair, Label *if_not_accessor_pair)
void	GotoIfNumberGreaterThanOrEqual (TNode< Number > left, TNode< Number > right, Label *if_false)
TNode< Boolean >	Equal (TNode< Object > lhs, TNode< Object > rhs, TNode< Context > context, TVariable< Smi > *var_type_feedback=nullptr)
TNode< Boolean >	Equal (TNode< Object > lhs, TNode< Object > rhs, const LazyNode< Context > &context, TVariable< Smi > *var_type_feedback=nullptr)
TNode< Boolean >	StrictEqual (TNode< Object > lhs, TNode< Object > rhs, TVariable< Smi > *var_type_feedback=nullptr)
void	GotoIfStringEqual (TNode< String > lhs, TNode< IntPtrT > lhs_length, TNode< String > rhs, Label *if_true)
void	BranchIfStringEqual (TNode< String > lhs, TNode< String > rhs, Label *if_true, Label *if_false, TVariable< Boolean > *result=nullptr)
void	BranchIfStringEqual (TNode< String > lhs, TNode< IntPtrT > lhs_length, TNode< String > rhs, TNode< IntPtrT > rhs_length, Label *if_true, Label *if_false, TVariable< Boolean > *result=nullptr)
void	BranchIfSameValue (TNode< Object > lhs, TNode< Object > rhs, Label *if_true, Label *if_false, SameValueMode mode=SameValueMode::kFull)
void	BranchIfSameNumberValue (TNode< Float64T > lhs_value, TNode< Float64T > rhs_value, Label *if_true, Label *if_false)
TNode< Boolean >	HasProperty (TNode< Context > context, TNode< JSAny > object, TNode< Object > key, HasPropertyLookupMode mode)
TNode< Boolean >	HasProperty_Inline (TNode< Context > context, TNode< JSReceiver > object, TNode< Object > key)
void	ForInPrepare (TNode< HeapObject > enumerator, TNode< UintPtrT > slot, TNode< HeapObject > maybe_feedback_vector, TNode< FixedArray > *cache_array_out, TNode< Smi > *cache_length_out, UpdateFeedbackMode update_feedback_mode)
TNode< String >	Typeof (TNode< Object > value, std::optional< TNode< UintPtrT > > slot_id={}, std::optional< TNode< HeapObject > > maybe_feedback_vector={})
TNode< HeapObject >	GetSuperConstructor (TNode< JSFunction > active_function)
TNode< JSReceiver >	SpeciesConstructor (TNode< Context > context, TNode< JSAny > object, TNode< JSReceiver > default_constructor)
TNode< Boolean >	InstanceOf (TNode< Object > object, TNode< JSAny > callable, TNode< Context > context)
TNode< BoolT >	IsDebugActive ()
TNode< UintPtrT >	LoadJSArrayBufferByteLength (TNode< JSArrayBuffer > array_buffer)
TNode< UintPtrT >	LoadJSArrayBufferMaxByteLength (TNode< JSArrayBuffer > array_buffer)
TNode< RawPtrT >	LoadJSArrayBufferBackingStorePtr (TNode< JSArrayBuffer > array_buffer)
void	ThrowIfArrayBufferIsDetached (TNode< 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)
void	StoreJSArrayBufferViewByteLength (TNode< JSArrayBufferView > array_buffer_view, TNode< UintPtrT > value)
TNode< UintPtrT >	LoadJSArrayBufferViewByteOffset (TNode< JSArrayBufferView > array_buffer_view)
void	StoreJSArrayBufferViewByteOffset (TNode< JSArrayBufferView > array_buffer_view, TNode< UintPtrT > value)
void	ThrowIfArrayBufferViewBufferIsDetached (TNode< Context > context, TNode< JSArrayBufferView > array_buffer_view, const char *method_name)
TNode< UintPtrT >	LoadJSTypedArrayLength (TNode< JSTypedArray > typed_array)
void	StoreJSTypedArrayLength (TNode< JSTypedArray > typed_array, TNode< UintPtrT > value)
TNode< UintPtrT >	LoadJSTypedArrayLengthAndCheckDetached (TNode< JSTypedArray > typed_array, Label *detached)
TNode< UintPtrT >	LoadVariableLengthJSTypedArrayLength (TNode< JSTypedArray > array, TNode< JSArrayBuffer > buffer, Label *detached_or_out_of_bounds)
TNode< UintPtrT >	LoadVariableLengthJSTypedArrayByteLength (TNode< Context > context, TNode< JSTypedArray > array, TNode< JSArrayBuffer > buffer)
TNode< UintPtrT >	LoadVariableLengthJSArrayBufferViewByteLength (TNode< JSArrayBufferView > array, TNode< JSArrayBuffer > buffer, Label *detached_or_out_of_bounds)
void	IsJSArrayBufferViewDetachedOrOutOfBounds (TNode< JSArrayBufferView > array_buffer_view, Label *detached_or_oob, Label *not_detached_nor_oob)
TNode< BoolT >	IsJSArrayBufferViewDetachedOrOutOfBoundsBoolean (TNode< JSArrayBufferView > array_buffer_view)
void	CheckJSTypedArrayIndex (TNode< JSTypedArray > typed_array, TNode< UintPtrT > index, Label *detached_or_out_of_bounds)
TNode< IntPtrT >	RabGsabElementsKindToElementByteSize (TNode< Int32T > elementsKind)
TNode< RawPtrT >	LoadJSTypedArrayDataPtr (TNode< JSTypedArray > typed_array)
TNode< JSArrayBuffer >	GetTypedArrayBuffer (TNode< Context > context, TNode< JSTypedArray > array)
template<typename TIndex >
TNode< IntPtrT >	ElementOffsetFromIndex (TNode< TIndex > index, ElementsKind kind, int base_size=0)
template<typename Array , typename TIndex >
TNode< IntPtrT >	OffsetOfElementAt (TNode< TIndex > index)
TNode< BoolT >	IsOffsetInBounds (TNode< IntPtrT > offset, TNode< IntPtrT > length, int header_size, ElementsKind kind=HOLEY_ELEMENTS)
TNode< Code >	LoadBuiltin (TNode< Smi > builtin_id)
void	SetSupportsDynamicParameterCount (TNode< JSFunction > callee, TNode< JSDispatchHandleT > dispatch_handle)
TNode< Code >	GetSharedFunctionInfoCode (TNode< SharedFunctionInfo > shared_info, TVariable< Uint16T > *data_type_out=nullptr, Label *if_compile_lazy=nullptr)
TNode< JSFunction >	AllocateRootFunctionWithContext (RootIndex function, TNode< Context > context, std::optional< TNode< NativeContext > > maybe_native_context)
TNode< JSFunction >	AllocateRootFunctionWithContext (intptr_t function, TNode< Context > context, TNode< NativeContext > native_context)
TNode< Uint32T >	PromiseHookFlags ()
TNode< BoolT >	HasAsyncEventDelegate ()
TNode< BoolT >	IsIsolatePromiseHookEnabled (TNode< Uint32T > flags)
TNode< BoolT >	IsAnyPromiseHookEnabled (TNode< Uint32T > flags)
TNode< BoolT >	IsAnyPromiseHookEnabled ()
TNode< BoolT >	IsIsolatePromiseHookEnabledOrHasAsyncEventDelegate (TNode< Uint32T > flags)
TNode< BoolT >	IsIsolatePromiseHookEnabledOrHasAsyncEventDelegate ()
TNode< BoolT >	IsIsolatePromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate (TNode< Uint32T > flags)
TNode< BoolT >	IsIsolatePromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate ()
TNode< BoolT >	NeedsAnyPromiseHooks (TNode< Uint32T > flags)
TNode< BoolT >	NeedsAnyPromiseHooks ()
void	CheckPrototypeEnumCache (TNode< JSReceiver > receiver, TNode< Map > receiver_map, Label *if_fast, Label *if_slow)
TNode< Map >	CheckEnumCache (TNode< JSReceiver > receiver, Label *if_empty, Label *if_runtime)
TNode< JSAny >	GetArgumentValue (TorqueStructArguments args, TNode< IntPtrT > index)
void	SetArgumentValue (TorqueStructArguments args, TNode< IntPtrT > index, TNode< JSAny > value)
TorqueStructArguments	GetFrameArguments (TNode< RawPtrT > frame, TNode< IntPtrT > argc, FrameArgumentsArgcType argc_type=FrameArgumentsArgcType::kCountExcludesReceiver)
TNode< Int32T >	JSParameterCount (int argc_without_receiver)
TNode< Word32T >	JSParameterCount (TNode< Word32T > argc_without_receiver)
void	Print (const char *s)
void	Print (const char *prefix, TNode< MaybeObject > tagged_value)
void	Print (TNode< MaybeObject > tagged_value)
void	Print (const char *prefix, TNode< UintPtrT > value)
void	Print (const char *prefix, TNode< Float64T > value)
void	PrintErr (const char *s)
void	PrintErr (const char *prefix, TNode< MaybeObject > tagged_value)
void	PrintErr (TNode< MaybeObject > tagged_value)
void	PrintToStream (const char *s, int stream)
void	PrintToStream (const char *prefix, TNode< MaybeObject > tagged_value, int stream)
void	PrintToStream (const char *prefix, TNode< UintPtrT > value, int stream)
void	PrintToStream (const char *prefix, TNode< Float64T > value, int stream)
template<class... TArgs>
TNode< HeapObject >	MakeTypeError (MessageTemplate message, TNode< Context > context, TArgs... args)
void	Abort (AbortReason reason)
bool	ConstexprBoolNot (bool value)
int31_t	ConstexprIntegerLiteralToInt31 (const IntegerLiteral &i)
int32_t	ConstexprIntegerLiteralToInt32 (const IntegerLiteral &i)
uint32_t	ConstexprIntegerLiteralToUint32 (const IntegerLiteral &i)
int8_t	ConstexprIntegerLiteralToInt8 (const IntegerLiteral &i)
uint8_t	ConstexprIntegerLiteralToUint8 (const IntegerLiteral &i)
int64_t	ConstexprIntegerLiteralToInt64 (const IntegerLiteral &i)
uint64_t	ConstexprIntegerLiteralToUint64 (const IntegerLiteral &i)
intptr_t	ConstexprIntegerLiteralToIntptr (const IntegerLiteral &i)
uintptr_t	ConstexprIntegerLiteralToUintptr (const IntegerLiteral &i)
double	ConstexprIntegerLiteralToFloat64 (const IntegerLiteral &i)
bool	ConstexprIntegerLiteralEqual (IntegerLiteral lhs, IntegerLiteral rhs)
IntegerLiteral	ConstexprIntegerLiteralAdd (const IntegerLiteral &lhs, const IntegerLiteral &rhs)
IntegerLiteral	ConstexprIntegerLiteralLeftShift (const IntegerLiteral &lhs, const IntegerLiteral &rhs)
IntegerLiteral	ConstexprIntegerLiteralBitwiseOr (const IntegerLiteral &lhs, const IntegerLiteral &rhs)
bool	ConstexprInt31Equal (int31_t a, int31_t b)
bool	ConstexprInt31NotEqual (int31_t a, int31_t b)
bool	ConstexprInt31GreaterThanEqual (int31_t a, int31_t b)
bool	ConstexprUint32Equal (uint32_t a, uint32_t b)
bool	ConstexprUint32NotEqual (uint32_t a, uint32_t b)
bool	ConstexprInt32Equal (int32_t a, int32_t b)
bool	ConstexprInt32NotEqual (int32_t a, int32_t b)
bool	ConstexprInt32GreaterThanEqual (int32_t a, int32_t b)
uint32_t	ConstexprUint32Add (uint32_t a, uint32_t b)
int32_t	ConstexprUint32Sub (uint32_t a, uint32_t b)
int32_t	ConstexprInt32Sub (int32_t a, int32_t b)
int32_t	ConstexprInt32Add (int32_t a, int32_t b)
int31_t	ConstexprInt31Add (int31_t a, int31_t b)
int31_t	ConstexprInt31Mul (int31_t a, int31_t b)
int32_t	ConstexprWord32Or (int32_t a, int32_t b)
uint32_t	ConstexprWord32Shl (uint32_t a, int32_t b)
bool	ConstexprUintPtrLessThan (uintptr_t a, uintptr_t b)
void	PerformStackCheck (TNode< Context > context)
void	SetPropertyLength (TNode< Context > context, TNode< JSAny > array, TNode< Number > length)
void	DescriptorLookup (TNode< Name > unique_name, TNode< DescriptorArray > descriptors, TNode< Uint32T > bitfield3, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
void	TransitionLookup (TNode< Name > unique_name, TNode< 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)
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, TNode< IntPtrT > 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, PropertiesEnumerationMode mode, const ForEachKeyValueFunction &body, Label *bailout)
TNode< Object >	CallGetterIfAccessor (TNode< Object > value, TNode< Union< JSReceiver, PropertyCell > > holder, TNode< Uint32T > details, TNode< Context > context, TNode< JSAny > receiver, TNode< Object > name, Label *if_bailout, GetOwnPropertyMode mode=kCallJSGetterDontUseCachedName, ExpectedReceiverMode expected_receiver_mode=kExpectingJSReceiver)
TNode< IntPtrT >	TryToIntptr (TNode< Object > key, Label *if_not_intptr, TVariable< Int32T > *var_instance_type=nullptr)
TNode< JSArray >	ArrayCreate (TNode< Context > context, TNode< Number > length)
TNode< Object >	CloneIfMutablePrimitive (TNode< Object > object)
TNode< Smi >	RefillMathRandom (TNode< NativeContext > native_context)
TNode< IntPtrT >	FeedbackIteratorEntrySize ()
TNode< IntPtrT >	FeedbackIteratorHandlerOffset ()
TNode< SwissNameDictionary >	AllocateSwissNameDictionary (TNode< IntPtrT > at_least_space_for)
TNode< SwissNameDictionary >	AllocateSwissNameDictionary (int at_least_space_for)
TNode< SwissNameDictionary >	AllocateSwissNameDictionaryWithCapacity (TNode< IntPtrT > capacity)
TNode< IntPtrT >	SwissNameDictionaryOffsetIntoDataTableMT (TNode< SwissNameDictionary > dict, TNode< IntPtrT > index, int field_index)
TNode< IntPtrT >	SwissNameDictionaryOffsetIntoPropertyDetailsTableMT (TNode< SwissNameDictionary > dict, TNode< IntPtrT > capacity, TNode< IntPtrT > index)
TNode< IntPtrT >	LoadSwissNameDictionaryNumberOfElements (TNode< SwissNameDictionary > table, TNode< IntPtrT > capacity)
TNode< IntPtrT >	LoadSwissNameDictionaryNumberOfDeletedElements (TNode< SwissNameDictionary > table, TNode< IntPtrT > capacity)
TNode< Uint32T >	SwissNameDictionaryIncreaseElementCountOrBailout (TNode< ByteArray > meta_table, TNode< IntPtrT > capacity, TNode< Uint32T > max_usable_capacity, Label *bailout)
TNode< Uint32T >	SwissNameDictionaryUpdateCountsForDeletion (TNode< ByteArray > meta_table, TNode< IntPtrT > capacity)
void	StoreSwissNameDictionaryCapacity (TNode< SwissNameDictionary > table, TNode< Int32T > capacity)
void	StoreSwissNameDictionaryEnumToEntryMapping (TNode< SwissNameDictionary > table, TNode< IntPtrT > capacity, TNode< IntPtrT > enum_index, TNode< Int32T > entry)
TNode< Name >	LoadSwissNameDictionaryKey (TNode< SwissNameDictionary > dict, TNode< IntPtrT > entry)
void	StoreSwissNameDictionaryKeyAndValue (TNode< SwissNameDictionary > dict, TNode< IntPtrT > entry, TNode< Object > key, TNode< Object > value)
void	SwissNameDictionarySetCtrl (TNode< SwissNameDictionary > table, TNode< IntPtrT > capacity, TNode< IntPtrT > entry, TNode< Uint8T > ctrl)
TNode< Uint64T >	LoadSwissNameDictionaryCtrlTableGroup (TNode< IntPtrT > address)
TNode< Uint8T >	LoadSwissNameDictionaryPropertyDetails (TNode< SwissNameDictionary > table, TNode< IntPtrT > capacity, TNode< IntPtrT > entry)
void	StoreSwissNameDictionaryPropertyDetails (TNode< SwissNameDictionary > table, TNode< IntPtrT > capacity, TNode< IntPtrT > entry, TNode< Uint8T > details)
TNode< SwissNameDictionary >	CopySwissNameDictionary (TNode< SwissNameDictionary > original)
void	SwissNameDictionaryFindEntry (TNode< SwissNameDictionary > table, TNode< Name > key, Label *found, TVariable< IntPtrT > *var_found_entry, Label *not_found)
void	SwissNameDictionaryAdd (TNode< SwissNameDictionary > table, TNode< Name > key, TNode< Object > value, TNode< Uint8T > property_details, Label *needs_resize)
TNode< BoolT >	IsMarked (TNode< Object > object)
void	GetMarkBit (TNode< IntPtrT > object, TNode< IntPtrT > *cell, TNode< IntPtrT > *mask)
TNode< BoolT >	IsPageFlagSet (TNode< IntPtrT > object, int mask)
TNode< BoolT >	IsPageFlagReset (TNode< IntPtrT > object, int mask)
template<>
TNode< Smi >	IntPtrOrSmiConstant (int value)
template<>
TNode< IntPtrT >	IntPtrOrSmiConstant (int value)
template<>
TNode< UintPtrT >	IntPtrOrSmiConstant (int value)
template<>
TNode< RawPtrT >	IntPtrOrSmiConstant (int value)
template<>
TNode< Smi >	TaggedToParameter (TNode< Smi > value)
template<>
TNode< IntPtrT >	TaggedToParameter (TNode< Smi > value)
template<>
TNode< IntPtrT >	LoadArrayLength (TNode< FixedArray > array)
template<>
TNode< IntPtrT >	LoadArrayLength (TNode< ClosureFeedbackCellArray > array)
template<>
TNode< IntPtrT >	LoadArrayLength (TNode< ScriptContextTable > array)
template<>
TNode< IntPtrT >	LoadArrayLength (TNode< RegExpMatchInfo > 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< IntPtrT >	LoadArrayLength (TNode< TrustedFixedArray > array)
template<>
TNode< Object >	LoadElementAndPrepareForStore (TNode< FixedArrayBase > array, TNode< IntPtrT > offset, ElementsKind from_kind, ElementsKind to_kind, Label *if_hole)
template<>
TNode< Float64T >	LoadElementAndPrepareForStore (TNode< FixedArrayBase > array, TNode< IntPtrT > offset, ElementsKind from_kind, ElementsKind to_kind, Label *if_hole)
template<>
V8_EXPORT_PRIVATE TNode< Object >	LoadValueByKeyIndex (TNode< SwissNameDictionary > container, TNode< IntPtrT > key_index)
template<>
V8_EXPORT_PRIVATE TNode< Uint32T >	LoadDetailsByKeyIndex (TNode< SwissNameDictionary > container, TNode< IntPtrT > key_index)
template<>
V8_EXPORT_PRIVATE void	StoreDetailsByKeyIndex (TNode< SwissNameDictionary > container, TNode< IntPtrT > key_index, TNode< Smi > details)
template<>
V8_EXPORT_PRIVATE void	StoreValueByKeyIndex (TNode< SwissNameDictionary > container, TNode< IntPtrT > key_index, TNode< Object > value, WriteBarrierMode write_barrier)
template<>
TNode< HeapObject >	LoadName (TNode< HeapObject > key)
template<>
TNode< HeapObject >	LoadName (TNode< HeapObject > key)
template<>
TNode< HeapObject >	LoadName (TNode< HeapObject > key)
template<>
void	NameDictionaryLookup (TNode< SwissNameDictionary > dictionary, TNode< Name > unique_name, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found, LookupMode mode)
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)
template<>
void	AddToDictionary (TNode< SwissNameDictionary > dictionary, TNode< Name > key, TNode< Object > value, Label *bailout, std::optional< TNode< IntPtrT > > insertion_index)
template<>
TNode< Smi >	GetNumberOfElements (TNode< SwissNameDictionary > dictionary)
template<>
TNode< Smi >	GetNameDictionaryFlags (TNode< NameDictionary > dictionary)
template<>
void	SetNameDictionaryFlags (TNode< NameDictionary > dictionary, TNode< Smi > flags)
template<>
TNode< Smi >	GetNameDictionaryFlags (TNode< SwissNameDictionary > dictionary)
template<>
void	SetNameDictionaryFlags (TNode< SwissNameDictionary > dictionary, TNode< Smi > flags)
template<>
void	StoreElementTypedArray (TNode< RawPtrT > elements, ElementsKind kind, TNode< UintPtrT > index, TNode< BigInt > value)
template<>
void	StoreElementTypedArray (TNode< RawPtrT > elements, ElementsKind kind, TNode< IntPtrT > index, TNode< BigInt > value)
template<>
void	StoreElementTypedArray (TNode< RawPtrT > elements, ElementsKind kind, TNode< UintPtrT > index, TNode< Word32T > value)
template<>
void	StoreElementTypedArray (TNode< RawPtrT > elements, ElementsKind kind, TNode< IntPtrT > index, TNode< Word32T > value)
template<>
TNode< Word32T >	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
template<>
TNode< Float16RawBitsT >	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
template<>
TNode< Float32T >	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
template<>
TNode< Float64T >	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
template<>
TNode< BigInt >	PrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
template<>
void	EmitElementStoreTypedArrayUpdateValue (TNode< Object > value, ElementsKind elements_kind, TNode< Word32T > converted_value, TVariable< Object > *maybe_converted_value)
template<>
void	EmitElementStoreTypedArrayUpdateValue (TNode< Object > value, ElementsKind elements_kind, TNode< Float16RawBitsT > converted_value, TVariable< Object > *maybe_converted_value)
template<>
void	EmitElementStoreTypedArrayUpdateValue (TNode< Object > value, ElementsKind elements_kind, TNode< Float32T > converted_value, TVariable< Object > *maybe_converted_value)
template<>
void	EmitElementStoreTypedArrayUpdateValue (TNode< Object > value, ElementsKind elements_kind, TNode< Float64T > converted_value, TVariable< Object > *maybe_converted_value)
template<>
void	EmitElementStoreTypedArrayUpdateValue (TNode< Object > value, ElementsKind elements_kind, TNode< BigInt > converted_value, TVariable< Object > *maybe_converted_value)
template<typename TIndex >
void	BuildFastArrayForEach (TNode< UnionOf< UnionOf< FixedArray, PropertyArray >, HeapObject > > array, ElementsKind kind, TNode< TIndex > first_element_inclusive, TNode< TIndex > last_element_exclusive, const FastArrayForEachBody &body, LoopUnrollingMode loop_unrolling_mode, ForEachDirection direction)
Public Member Functions inherited from v8::internal::compiler::CodeAssembler
	CodeAssembler (CodeAssemblerState *state)
	~CodeAssembler ()
	CodeAssembler (const CodeAssembler &)=delete
CodeAssembler &	operator= (const CodeAssembler &)=delete
bool	Is64 () const
bool	Is32 () const
bool	IsFloat64RoundUpSupported () const
bool	IsFloat64RoundDownSupported () const
bool	IsFloat64RoundTiesEvenSupported () const
bool	IsFloat64RoundTruncateSupported () const
bool	IsTruncateFloat64ToFloat16RawBitsSupported () const
bool	IsInt32AbsWithOverflowSupported () const
bool	IsInt64AbsWithOverflowSupported () const
bool	IsIntPtrAbsWithOverflowSupported () const
bool	IsWord32PopcntSupported () const
bool	IsWord64PopcntSupported () const
bool	IsWord32CtzSupported () const
bool	IsWord64CtzSupported () 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 >	UniqueInt32Constant (int32_t value)
TNode< Int32T >	Int32Constant (int32_t value)
TNode< Int64T >	UniqueInt64Constant (int64_t value)
TNode< Int64T >	Int64Constant (int64_t value)
TNode< Uint64T >	Uint64Constant (uint64_t value)
TNode< IntPtrT >	IntPtrConstant (intptr_t value)
TNode< IntPtrT >	UniqueIntPtrConstant (intptr_t value)
TNode< Uint32T >	UniqueUint32Constant (int32_t value)
TNode< Uint32T >	Uint32Constant (uint32_t value)
TNode< Uint32T >	Uint64HighWordConstant (uint64_t value)
TNode< Uint32T >	Uint64HighWordConstantNoLowWord (uint64_t value)
TNode< Uint32T >	Uint64LowWordConstant (uint64_t value)
TNode< UintPtrT >	UintPtrConstant (uintptr_t value)
TNode< TaggedIndex >	TaggedIndexConstant (intptr_t value)
TNode< RawPtrT >	PointerConstant (void *value)
TNode< Number >	NumberConstant (double value)
TNode< Smi >	SmiConstant (Tagged< Smi > value)
TNode< Smi >	SmiConstant (int value)
template<typename E > requires std::is_enum<E>::value
TNode< Smi >	SmiConstant (E value)
void	CanonicalizeEmbeddedBuiltinsConstantIfNeeded (Handle< HeapObject > object)
TNode< HeapObject >	UntypedHeapConstantNoHole (Handle< HeapObject > object)
TNode< HeapObject >	UntypedHeapConstantMaybeHole (Handle< HeapObject > object)
TNode< HeapObject >	UntypedHeapConstantHole (Handle< HeapObject > object)
template<class Type >
TNode< Type >	HeapConstantNoHole (Handle< Type > object)
template<class Type >
TNode< Type >	HeapConstantMaybeHole (Handle< Type > object)
template<class Type >
TNode< Type >	HeapConstantHole (Handle< Type > object)
TNode< String >	StringConstant (const char *str)
TNode< Boolean >	BooleanConstant (bool value)
TNode< ExternalReference >	ExternalConstant (ExternalReference address)
TNode< ExternalReference >	IsolateField (IsolateFieldId id)
TNode< Float32T >	Float32Constant (double value)
TNode< Float64T >	Float64Constant (double value)
TNode< BoolT >	Int32TrueConstant ()
TNode< BoolT >	Int32FalseConstant ()
TNode< BoolT >	BoolConstant (bool value)
TNode< ExternalPointerHandleT >	ExternalPointerHandleNullConstant ()
bool	IsMapOffsetConstant (Node *node)
bool	TryToInt32Constant (TNode< IntegralT > node, int32_t *out_value)
bool	TryToInt64Constant (TNode< IntegralT > node, int64_t *out_value)
bool	TryToIntPtrConstant (TNode< IntegralT > node, intptr_t *out_value)
bool	TryToIntPtrConstant (TNode< Smi > tnode, intptr_t *out_value)
bool	TryToSmiConstant (TNode< IntegralT > node, Tagged< Smi > *out_value)
bool	TryToSmiConstant (TNode< Smi > node, Tagged< Smi > *out_value)
bool	IsUndefinedConstant (TNode< Object > node)
bool	IsNullConstant (TNode< Object > node)
TNode< Int32T >	Signed (TNode< Word32T > x)
TNode< Int64T >	Signed (TNode< Word64T > x)
TNode< IntPtrT >	Signed (TNode< WordT > x)
TNode< Uint32T >	Unsigned (TNode< Word32T > x)
TNode< Uint64T >	Unsigned (TNode< Word64T > x)
TNode< UintPtrT >	Unsigned (TNode< WordT > x)
bool	HasDynamicJSParameterCount ()
TNode< Uint16T >	DynamicJSParameterCount ()
void	SetDynamicJSParameterCount (TNode< Uint16T > parameter_count)
template<class T >
TNode< T >	Parameter (int value, const SourceLocation &loc=SourceLocation::Current())
template<class T >
TNode< T >	UncheckedParameter (int value)
Node *	UntypedParameter (int value)
TNode< Context >	GetJSContextParameter ()
void	Return (TNode< Object > value)
void	Return (TNode< Object > value1, TNode< Object > value2)
void	Return (TNode< Object > value1, TNode< Object > value2, TNode< Object > value3)
void	Return (TNode< Int32T > value)
void	Return (TNode< Uint32T > value)
void	Return (TNode< WordT > value)
void	Return (TNode< Float32T > value)
void	Return (TNode< Float64T > value)
void	Return (TNode< WordT > value1, TNode< WordT > value2)
void	Return (TNode< Word32T > value1, TNode< Word32T > value2)
void	Return (TNode< WordT > value1, TNode< Object > value2)
void	Return (TNode< Word32T > value1, TNode< Object > value2)
void	PopAndReturn (Node *pop, Node *value)
void	PopAndReturn (Node *pop, Node *value1, Node *value2, Node *value3, Node *value4)
void	ReturnIf (TNode< BoolT > condition, TNode< Object > value)
void	AbortCSADcheck (Node *message)
void	DebugBreak ()
void	Unreachable ()
template<class... Args>
void	Comment (MessageWithSourceLocation message, Args &&... args)
void	StaticAssert (TNode< BoolT > value, const char *source="unknown position")
void	SetSourcePosition (const char *file, int line)
void	PushSourcePosition ()
void	PopSourcePosition ()
const std::vector< FileAndLine > &	GetMacroSourcePositionStack () const
void	Bind (Label *label)
void	Goto (Label *label)
void	GotoIf (TNode< IntegralT > condition, Label *true_label, GotoHint goto_hint=GotoHint::kNone)
void	GotoIfNot (TNode< IntegralT > condition, Label *false_label, GotoHint goto_hint=GotoHint::kNone)
void	Branch (TNode< IntegralT > condition, Label *true_label, Label *false_label, BranchHint branch_hint=BranchHint::kNone)
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... U>
void	Branch (TNode< BoolT > condition, CodeAssemblerParameterizedLabel< T... > *if_true, std::vector< Node * > args_true, CodeAssemblerParameterizedLabel< U... > *if_false, std::vector< Node * > args_false)
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)
TNode< RawPtrT >	LoadFramePointer ()
TNode< RawPtrT >	LoadParentFramePointer ()
TNode< RawPtrT >	StackSlotPtr (int size, int alignment)
TNode< RawPtrT >	LoadPointerFromRootRegister (TNode< IntPtrT > offset)
TNode< Uint8T >	LoadUint8FromRootRegister (TNode< IntPtrT > offset)
Node *	Load (MachineType type, Node *base)
template<class Type >
TNode< Type >	Load (MachineType type, TNode< RawPtr< Type > > base)
Node *	Load (MachineType type, Node *base, Node *offset)
template<class Type >
TNode< Type >	Load (Node *base)
template<class Type >
TNode< Type >	Load (Node *base, TNode< WordT > offset)
template<class Type >
TNode< Type >	AtomicLoad (AtomicMemoryOrder order, TNode< RawPtrT > base, TNode< WordT > offset)
template<class Type >
TNode< Type >	AtomicLoad64 (AtomicMemoryOrder order, TNode< RawPtrT > base, TNode< WordT > offset)
TNode< Object >	LoadFullTagged (Node *base)
TNode< Object >	LoadFullTagged (Node *base, TNode< IntPtrT > offset)
Node *	LoadFromObject (MachineType type, TNode< Object > object, TNode< IntPtrT > offset)
Node *	LoadProtectedPointerFromObject (TNode< Object > object, TNode< IntPtrT > offset)
TNode< Object >	LoadRoot (RootIndex root_index)
TNode< AnyTaggedT >	LoadRootMapWord (RootIndex root_index)
template<typename Type >
TNode< Type >	UnalignedLoad (TNode< RawPtrT > base, TNode< IntPtrT > offset)
void	Store (Node *base, Node *value)
void	Store (Node *base, Node *offset, Node *value)
void	StoreEphemeronKey (Node *base, Node *offset, Node *value)
void	StoreNoWriteBarrier (MachineRepresentation rep, Node *base, Node *value)
void	StoreNoWriteBarrier (MachineRepresentation rep, Node *base, Node *offset, Node *value)
void	UnsafeStoreNoWriteBarrier (MachineRepresentation rep, Node *base, Node *value)
void	UnsafeStoreNoWriteBarrier (MachineRepresentation rep, Node *base, Node *offset, Node *value)
void	StoreFullTaggedNoWriteBarrier (TNode< RawPtrT > base, TNode< Object > tagged_value)
void	StoreFullTaggedNoWriteBarrier (TNode< RawPtrT > base, TNode< IntPtrT > offset, TNode< Object > tagged_value)
TNode< HeapObject >	OptimizedAllocate (TNode< IntPtrT > size, AllocationType allocation)
void	StoreToObject (MachineRepresentation rep, TNode< Object > object, TNode< IntPtrT > offset, Node *value, StoreToObjectWriteBarrier write_barrier)
void	OptimizedStoreField (MachineRepresentation rep, TNode< HeapObject > object, int offset, Node *value)
void	OptimizedStoreIndirectPointerField (TNode< HeapObject > object, int offset, IndirectPointerTag tag, Node *value)
void	OptimizedStoreIndirectPointerFieldNoWriteBarrier (TNode< HeapObject > object, int offset, IndirectPointerTag tag, Node *value)
void	OptimizedStoreFieldAssertNoWriteBarrier (MachineRepresentation rep, TNode< HeapObject > object, int offset, Node *value)
void	OptimizedStoreFieldUnsafeNoWriteBarrier (MachineRepresentation rep, TNode< HeapObject > object, int offset, Node *value)
void	OptimizedStoreMap (TNode< HeapObject > object, TNode< Map >)
void	AtomicStore (MachineRepresentation rep, AtomicMemoryOrder order, TNode< RawPtrT > base, TNode< WordT > offset, TNode< Word32T > value)
void	AtomicStore64 (AtomicMemoryOrder order, TNode< RawPtrT > base, TNode< WordT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicAdd (MachineType type, TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< Word32T > value)
template<class Type >
TNode< Type >	AtomicAdd64 (TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicSub (MachineType type, TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< Word32T > value)
template<class Type >
TNode< Type >	AtomicSub64 (TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicAnd (MachineType type, TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< Word32T > value)
template<class Type >
TNode< Type >	AtomicAnd64 (TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicOr (MachineType type, TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< Word32T > value)
template<class Type >
TNode< Type >	AtomicOr64 (TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicXor (MachineType type, TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< Word32T > value)
template<class Type >
TNode< Type >	AtomicXor64 (TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicExchange (MachineType type, TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< Word32T > value)
template<class Type >
TNode< Type >	AtomicExchange64 (TNode< RawPtrT > base, TNode< UintPtrT > offset, TNode< UintPtrT > value, TNode< UintPtrT > value_high)
TNode< Word32T >	AtomicCompareExchange (MachineType type, TNode< RawPtrT > base, TNode< WordT > offset, TNode< Word32T > old_value, TNode< Word32T > new_value)
template<class Type >
TNode< Type >	AtomicCompareExchange64 (TNode< RawPtrT > base, TNode< WordT > offset, TNode< UintPtrT > old_value, TNode< UintPtrT > new_value, TNode< UintPtrT > old_value_high, TNode< UintPtrT > new_value_high)
void	MemoryBarrier (AtomicMemoryOrder order)
void	StoreRoot (RootIndex root_index, TNode< Object > value)
TNode< PairT< Word32T, Word32T > >	Int32PairAdd (TNode< Word32T > lhs_lo_word, TNode< Word32T > lhs_hi_word, TNode< Word32T > rhs_lo_word, TNode< Word32T > rhs_hi_word)
TNode< PairT< Word32T, Word32T > >	Int32PairSub (TNode< Word32T > lhs_lo_word, TNode< Word32T > lhs_hi_word, TNode< Word32T > rhs_lo_word, TNode< Word32T > rhs_hi_word)
TNode< UintPtrT >	WordShr (TNode< UintPtrT > left, TNode< IntegralT > right)
TNode< IntPtrT >	WordSar (TNode< IntPtrT > left, TNode< IntegralT > right)
TNode< IntPtrT >	WordShl (TNode< IntPtrT > left, TNode< IntegralT > right)
TNode< UintPtrT >	WordShl (TNode< UintPtrT > left, TNode< IntegralT > right)
TNode< Int32T >	Word32Shl (TNode< Int32T > left, TNode< Int32T > right)
TNode< Uint32T >	Word32Shl (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< Uint32T >	Word32Shr (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< Int32T >	Word32Sar (TNode< Int32T > left, TNode< Int32T > right)
TNode< Int64T >	Word64Shl (TNode< Int64T > left, TNode< Int64T > right)
TNode< Uint64T >	Word64Shl (TNode< Uint64T > left, TNode< Uint64T > right)
TNode< Int64T >	Word64Shr (TNode< Int64T > left, TNode< Uint64T > right)
TNode< Uint64T >	Word64Shr (TNode< Uint64T > left, TNode< Uint64T > right)
TNode< Int64T >	Word64Sar (TNode< Int64T > left, TNode< Int64T > right)
TNode< Int64T >	Word64And (TNode< Int64T > left, TNode< Int64T > right)
TNode< Uint64T >	Word64And (TNode< Uint64T > left, TNode< Uint64T > right)
TNode< Int64T >	Word64Xor (TNode< Int64T > left, TNode< Int64T > right)
TNode< Uint64T >	Word64Xor (TNode< Uint64T > left, TNode< Uint64T > right)
TNode< Int64T >	Word64Not (TNode< Int64T > value)
TNode< Uint64T >	Word64Not (TNode< Uint64T > value)
TNode< IntPtrT >	WordAnd (TNode< IntPtrT > left, TNode< IntPtrT > right)
TNode< UintPtrT >	WordAnd (TNode< UintPtrT > left, TNode< UintPtrT > right)
TNode< Int32T >	Word32And (TNode< Int32T > left, TNode< Int32T > right)
TNode< Uint32T >	Word32And (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< IntPtrT >	WordOr (TNode< IntPtrT > left, TNode< IntPtrT > right)
TNode< Int32T >	Word32Or (TNode< Int32T > left, TNode< Int32T > right)
TNode< Uint32T >	Word32Or (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< BoolT >	IntPtrEqual (TNode< WordT > left, TNode< WordT > right)
TNode< BoolT >	WordEqual (TNode< WordT > left, TNode< WordT > right)
TNode< BoolT >	WordNotEqual (TNode< WordT > left, TNode< WordT > right)
TNode< BoolT >	Word32Equal (TNode< Word32T > left, TNode< Word32T > right)
TNode< BoolT >	Word32NotEqual (TNode< Word32T > left, TNode< Word32T > right)
TNode< BoolT >	Word64Equal (TNode< Word64T > left, TNode< Word64T > right)
TNode< BoolT >	Word64NotEqual (TNode< Word64T > left, TNode< Word64T > right)
TNode< IntPtrT >	WordNot (TNode< IntPtrT > a)
TNode< Int32T >	Word32BitwiseNot (TNode< Int32T > a)
TNode< BoolT >	Word32Or (TNode< BoolT > left, TNode< BoolT > right)
TNode< BoolT >	Word32And (TNode< BoolT > left, TNode< BoolT > right)
TNode< Int32T >	Int32Add (TNode< Int32T > left, TNode< Int32T > right)
TNode< Uint32T >	Uint32Add (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< Uint32T >	Uint32Sub (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< Int32T >	Int32Sub (TNode< Int32T > left, TNode< Int32T > right)
TNode< Int32T >	Int32Mul (TNode< Int32T > left, TNode< Int32T > right)
TNode< Uint32T >	Uint32Mul (TNode< Uint32T > left, TNode< Uint32T > right)
TNode< Int64T >	Int64Add (TNode< Int64T > left, TNode< Int64T > right)
TNode< Uint64T >	Uint64Add (TNode< Uint64T > left, TNode< Uint64T > right)
TNode< Int64T >	Int64Sub (TNode< Int64T > left, TNode< Int64T > right)
TNode< Uint64T >	Uint64Sub (TNode< Uint64T > left, TNode< Uint64T > right)
TNode< Int64T >	Int64Mul (TNode< Int64T > left, TNode< Int64T > right)
TNode< Uint64T >	Uint64Mul (TNode< Uint64T > left, TNode< Uint64T > 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< RawPtrT >	RawPtrAdd (TNode< RawPtrT > left, TNode< IntPtrT > right)
TNode< RawPtrT >	RawPtrSub (TNode< RawPtrT > left, TNode< IntPtrT > right)
TNode< IntPtrT >	RawPtrSub (TNode< RawPtrT > left, TNode< RawPtrT > right)
TNode< WordT >	WordShl (TNode< WordT > value, int shift)
TNode< WordT >	WordShr (TNode< WordT > value, int shift)
TNode< WordT >	WordSar (TNode< WordT > value, int shift)
TNode< IntPtrT >	WordShr (TNode< IntPtrT > value, int shift)
TNode< IntPtrT >	WordSar (TNode< IntPtrT > value, int shift)
TNode< Word32T >	Word32Shr (TNode< Word32T > value, int shift)
TNode< Word32T >	Word32Sar (TNode< Word32T > value, int shift)
TNode< Int32T >	Int32Sub (TNode< Int32T > left, int right)
TNode< Word32T >	Word32And (TNode< Word32T > left, int right)
TNode< Int32T >	Word32Shl (TNode< Int32T > left, int right)
TNode< BoolT >	Word32Equal (TNode< Word32T > left, int right)
template<class Dummy = void>
TNode< IntPtrT >	BitcastTaggedToWord (TNode< Smi > node)
TNode< IntPtrT >	ChangeFloat64ToIntPtr (TNode< Float64T > value)
TNode< UintPtrT >	ChangeFloat64ToUintPtr (TNode< Float64T > value)
TNode< Float64T >	ChangeUintPtrToFloat64 (TNode< UintPtrT > value)
TNode< Float64T >	RoundIntPtrToFloat64 (Node *value)
TNode< UintPtrT >	ChangeUint32ToWord (TNode< Word32T > value)
TNode< IntPtrT >	ChangeInt32ToIntPtr (TNode< Word32T > value)
TNode< Int32T >	TruncateFloat32ToInt32 (TNode< Float32T > value)
TNode< Int64T >	TruncateFloat64ToInt64 (TNode< Float64T > 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 T = Object, class... TArgs>
TNode< T >	CallRuntime (Runtime::FunctionId function, TNode< Object > context, TArgs... args)
template<class... TArgs>
void	TailCallRuntime (Runtime::FunctionId function, TNode< Object > context, TArgs... args)
template<class... TArgs>
void	TailCallRuntime (Runtime::FunctionId function, TNode< Int32T > arity, TNode< Object > context, TArgs... args)
Builtin	builtin ()
TNode< RawPtrT >	SwitchToTheCentralStackIfNeeded ()
TNode< RawPtrT >	SwitchToTheCentralStack ()
void	SwitchFromTheCentralStack (TNode< RawPtrT > old_sp)
template<typename T = Object, class... TArgs>
TNode< T >	CallBuiltin (Builtin id, TNode< Object > context, TArgs... args)
template<class... TArgs>
void	CallBuiltinVoid (Builtin id, TNode< Object > context, TArgs... args)
template<class... TArgs>
void	TailCallBuiltin (Builtin id, TNode< Object > context, TArgs... args)
template<class T = Object, class... TArgs>
TNode< T >	CallStub (const CallInterfaceDescriptor &descriptor, TNode< Code > target, TNode< Object > context, TArgs... args)
template<class T = Object, class... TArgs>
TNode< T >	CallBuiltinPointer (const CallInterfaceDescriptor &descriptor, TNode< BuiltinPtr > target, TNode< Object > context, TArgs... args)
template<class... TArgs>
void	TailCallStub (const CallInterfaceDescriptor &descriptor, TNode< Code > target, TNode< Object > context, TArgs... args)
template<class... TArgs>
void	TailCallBytecodeDispatch (const CallInterfaceDescriptor &descriptor, TNode< RawPtrT > target, TArgs... args)
template<class... TArgs>
void	TailCallBuiltinThenBytecodeDispatch (Builtin builtin, Node *context, TArgs... args)
template<class... TArgs>
TNode< Object >	CallJSBuiltin (Builtin builtin, TNode< Context > context, TNode< Object > function, std::optional< TNode< Object > > new_target, TNode< Object > receiver, TArgs... args)
void	TailCallJSBuiltin (Builtin id, TNode< Object > context, TNode< Object > function, TNode< Object > new_target, TNode< Int32T > arg_count, TNode< JSDispatchHandleT > dispatch_handle)
template<class... TArgs>
TNode< JSAny >	CallJS (Builtin builtin, TNode< Context > context, TNode< Object > function, TNode< JSAny > receiver, TArgs... args)
template<class... TArgs>
TNode< JSAny >	ConstructJS (Builtin builtin, TNode< Context > context, TNode< Object > function, TNode< JSAny > new_target, TArgs... args)
void	TailCallJSCode (TNode< Code > code, TNode< Context > context, TNode< JSFunction > function, TNode< Object > new_target, TNode< Int32T > arg_count, TNode< JSDispatchHandleT > dispatch_handle)
Node *	CallCFunctionN (Signature< MachineType > *signature, int input_count, Node *const *inputs)
template<class... CArgs>
Node *	CallCFunction (Node *function, std::optional< MachineType > return_type, CArgs... cargs)
template<class... CArgs>
Node *	CallCFunctionWithoutFunctionDescriptor (Node *function, MachineType return_type, CArgs... cargs)
template<class... CArgs>
Node *	CallCFunctionWithCallerSavedRegisters (Node *function, MachineType return_type, SaveFPRegsMode mode, CArgs... cargs)
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
using	CreateClosures

Protected Member Functions
TNode< Object >	Await (TNode< Context > context, TNode< JSGeneratorObject > generator, TNode< JSAny > value, TNode< JSPromise > outer_promise, const CreateClosures &CreateClosures)
TNode< Object >	Await (TNode< Context > context, TNode< JSGeneratorObject > generator, TNode< JSAny > value, TNode< JSPromise > outer_promise, RootIndex on_resolve_sfi, RootIndex on_reject_sfi)
TNode< JSFunction >	CreateUnwrapClosure (TNode< NativeContext > native_context, TNode< Boolean > done)
Protected Member Functions inherited from v8::internal::compiler::CodeAssembler
void	RegisterCallGenerationCallbacks (const CodeAssemblerCallback &call_prologue, const CodeAssemblerCallback &call_epilogue)
void	UnregisterCallGenerationCallbacks ()
bool	Word32ShiftIsSafe () const
bool	IsJSFunctionCall () const

Private Member Functions
TNode< Context >	AllocateAsyncIteratorValueUnwrapContext (TNode< NativeContext > native_context, TNode< Boolean > done)

Additional Inherited Members
Public Types inherited from v8::internal::CodeStubAssembler
enum class	AllocationFlag : uint8_t { kNone = 0 , kDoubleAlignment = 1 , kPretenured = 1 << 1 }
enum	SlackTrackingMode { kWithSlackTracking , kNoSlackTracking , kDontInitializeInObjectProperties }
enum class	HoleConversionMode { kDontConvert , kConvertToUndefined }
enum class	DestroySource { kNo , kYes }
enum class	ExtractFixedArrayFlag {   kFixedArrays = 1 , kFixedDoubleArrays = 2 , kDontCopyCOW = 4 , kAllFixedArrays = kFixedArrays | kFixedDoubleArrays ,   kAllFixedArraysDontCopyCOW = kAllFixedArrays | kDontCopyCOW }
enum class	BigIntHandling { kConvertToNumber , kThrow }
enum	LookupMode { kFindExisting , kFindInsertionIndex , kFindExistingOrInsertionIndex }
enum	GetOwnPropertyMode { kCallJSGetterDontUseCachedName , kCallJSGetterUseCachedName , kReturnAccessorPair }
enum	ExpectedReceiverMode { kExpectingJSReceiver , kExpectingAnyReceiver }
enum class	IndexAdvanceMode { kPre , kPost }
enum class	IndexAdvanceDirection { kUp , kDown }
enum class	LoopUnrollingMode { kNo , kYes }
enum class	ForEachDirection { kForward , kReverse }
enum class	SameValueMode { kNumbersOnly , kFull }
enum	HasPropertyLookupMode { kHasProperty , kForInHasProperty }
enum class	FrameArgumentsArgcType { kCountIncludesReceiver , kCountExcludesReceiver }
using	ScopedExceptionHandler = compiler::ScopedExceptionHandler
template<typename T >
using	LazyNode = std::function<TNode<T>()>
using	AllocationFlags = base::Flags<AllocationFlag>
using	BranchGenerator = std::function<void(Label*, Label*)>
template<typename T >
using	NodeGenerator = std::function<TNode<T>()>
using	ExtraNode = std::pair<TNode<Object>, const char*>
using	ExtractFixedArrayFlags = base::Flags<ExtractFixedArrayFlag>
using	LookupPropertyInHolder
using	LookupElementInHolder
template<typename TIndex >
using	FastLoopBody = std::function<void(TNode<TIndex> index)>
using	FastArrayForEachBody
using	ForEachDescriptorBodyFunction
using	ForEachKeyValueFunction
Public Types inherited from v8::internal::compiler::CodeAssembler
using	Label = CodeAssemblerLabel
template<class T >
using	TVariable = TypedCodeAssemblerVariable<T>
using	VariableList = CodeAssemblerVariableList
using	CFunctionArg = std::pair<MachineType, Node*>
Static Public Member Functions inherited from v8::internal::CodeStubAssembler
static uintptr_t	MaxSafeIntegerUintPtr ()
Public Attributes inherited from v8::internal::CodeStubAssembler
	UintPtrLessThanOrEqual
SmiBelowOrEqual int32_t	b { return a << b
Uint32LessThanOrEqual	IntPtrGreaterThanOrEqual
	SmiLessThanOrEqual
Static Public Attributes inherited from v8::internal::compiler::CodeAssembler
static constexpr int	kTargetParameterIndex = kJSCallClosureParameterIndex

Detailed Description

Definition at line 14 of file builtins-async-gen.h.

Member Typedef Documentation

CreateClosures

using v8::internal::AsyncBuiltinsAssembler::CreateClosures

protected

Initial value:

 
      std::function<std::pair<TNode<JSFunction>, TNode<JSFunction>>(
          TNode<Context>, TNode<NativeContext>)>

Definition at line 24 of file builtins-async-gen.h.

Constructor & Destructor Documentation

AsyncBuiltinsAssembler()

v8::internal::AsyncBuiltinsAssembler::AsyncBuiltinsAssembler ( compiler::CodeAssemblerState * state )

inlineexplicit

Definition at line 16 of file builtins-async-gen.h.

Member Function Documentation

AllocateAsyncIteratorValueUnwrapContext()

TNode< Context > v8::internal::AsyncBuiltinsAssembler::AllocateAsyncIteratorValueUnwrapContext ( TNode< NativeContext > native_context, TNode< Boolean > done )

private

Definition at line 170 of file builtins-async-gen.cc.

Here is the call graph for this function:

Here is the caller graph for this function:

Await() [1/2]

TNode< Object > v8::internal::AsyncBuiltinsAssembler::Await ( TNode< Context > context, TNode< JSGeneratorObject > generator, TNode< JSAny > value, TNode< JSPromise > outer_promise, const CreateClosures & CreateClosures )

protected

Definition at line 44 of file builtins-async-gen.cc.

Here is the call graph for this function:

Here is the caller graph for this function:

Await() [2/2]

TNode< Object > v8::internal::AsyncBuiltinsAssembler::Await ( TNode< Context > context, TNode< JSGeneratorObject > generator, TNode< JSAny > value, TNode< JSPromise > outer_promise, RootIndex on_resolve_sfi, RootIndex on_reject_sfi )

protected

Definition at line 27 of file builtins-async-gen.cc.

Here is the call graph for this function:

CreateUnwrapClosure()

TNode< JSFunction > v8::internal::AsyncBuiltinsAssembler::CreateUnwrapClosure ( TNode< NativeContext > native_context, TNode< Boolean > done )

protected

Definition at line 161 of file builtins-async-gen.cc.

Here is the call graph for this function:

---

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

• src/builtins/builtins-async-gen.h
• src/builtins/builtins-async-gen.cc