V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
v8::internal::AccessorAssembler Class Reference
Inheritance diagram for v8::internal::AccessorAssembler:
v8::internal::CodeStubAssembler v8::internal::compiler::CodeAssembler BaseBuiltinsFromDSLAssembler v8::internal::DeletePropertyBaseAssembler v8::internal::KeyedStoreGenericAssembler

Classes

struct  LoadICParameters
 
struct  StoreICParameters
 

Public Types

enum  StubCacheTable : int
 
using Node = compiler::Node
 
template<class T >
using TNode = compiler::TNode< T >
 
template<class T >
using SloppyTNode = compiler::SloppyTNode< T >
 
- Public Types inherited from v8::internal::CodeStubAssembler
enum  AllocationFlag : uint8_t { kNone = 0, kDoubleAlignment = 1, kPretenured = 1 << 1, kAllowLargeObjectAllocation = 1 << 2 }
 
enum  SlackTrackingMode { kWithSlackTracking, kNoSlackTracking }
 
enum  ParameterMode { SMI_PARAMETERS, INTPTR_PARAMETERS }
 
enum  HoleConversionMode { kDontConvert, kConvertToUndefined }
 
enum  DestroySource { kNo, kYes }
 
enum  ExtractFixedArrayFlag {
  kFixedArrays = 1, kFixedDoubleArrays = 2, kDontCopyCOW = 4, kNewSpaceAllocationOnly = 8,
  kAllFixedArrays = kFixedArrays | kFixedDoubleArrays, kAllFixedArraysDontCopyCOW = kAllFixedArrays | kDontCopyCOW
}
 
enum  BigIntHandling { kConvertToNumber, kThrow }
 
enum  ToIntegerTruncationMode { kNoTruncation, kTruncateMinusZero }
 
enum  LookupMode { kFindExisting, kFindInsertionIndex }
 
enum  GetOwnPropertyMode { kCallJSGetter, kReturnAccessorPair }
 
enum  IndexAdvanceMode { kPre, kPost }
 
enum  ForEachDirection { kForward, kReverse }
 
enum  HasPropertyLookupMode { kHasProperty, kForInHasProperty }
 
using Node = compiler::Node
 
template<class T >
using TNode = compiler::TNode< T >
 
template<class T >
using SloppyTNode = compiler::SloppyTNode< T >
 
template<typename T >
using LazyNode = std::function< TNode< T >()>
 
typedef base::Flags< AllocationFlag > AllocationFlags
 
typedef std::function< void(Label *, Label *)> BranchGenerator
 
typedef std::function< Node *()> NodeGenerator
 
typedef base::Flags< ExtractFixedArrayFlag > ExtractFixedArrayFlags
 
typedef std::function< void(Node *receiver, Node *holder, Node *map, Node *instance_type, Node *key, Label *next_holder, Label *if_bailout)> LookupInHolder
 
typedef std::function< void(Node *index)> FastLoopBody
 
typedef std::function< void(Node *fixed_array, Node *offset)> FastFixedArrayForEachBody
 
typedef std::function< void(TNode< IntPtrT > descriptor_key_index)> ForEachDescriptorBodyFunction
 
typedef std::function< void(TNode< Name > key, TNode< Object > value)> ForEachKeyValueFunction
 
- Public Types inherited from v8::internal::compiler::CodeAssembler
using Label = CodeAssemblerLabel
 
using Variable = CodeAssemblerVariable
 
template<class T >
using TVariable = TypedCodeAssemblerVariable< T >
 
using VariableList = CodeAssemblerVariableList
 

Public Member Functions

 AccessorAssembler (compiler::CodeAssemblerState *state)
 
void GenerateLoadIC ()
 
void GenerateLoadIC_Megamorphic ()
 
void GenerateLoadIC_Noninlined ()
 
void GenerateLoadIC_Uninitialized ()
 
void GenerateLoadICTrampoline ()
 
void GenerateLoadICTrampoline_Megamorphic ()
 
void GenerateKeyedLoadIC ()
 
void GenerateKeyedLoadIC_Megamorphic ()
 
void GenerateKeyedLoadIC_PolymorphicName ()
 
void GenerateKeyedLoadICTrampoline ()
 
void GenerateKeyedLoadICTrampoline_Megamorphic ()
 
void GenerateStoreIC ()
 
void GenerateStoreICTrampoline ()
 
void GenerateStoreGlobalIC ()
 
void GenerateStoreGlobalICTrampoline ()
 
void GenerateCloneObjectIC ()
 
void GenerateCloneObjectIC_Slow ()
 
void GenerateLoadGlobalIC (TypeofMode typeof_mode)
 
void GenerateLoadGlobalICTrampoline (TypeofMode typeof_mode)
 
void GenerateKeyedStoreIC ()
 
void GenerateKeyedStoreICTrampoline ()
 
void GenerateStoreInArrayLiteralIC ()
 
void TryProbeStubCache (StubCache *stub_cache, Node *receiver, Node *name, Label *if_handler, TVariable< MaybeObject > *var_handler, Label *if_miss)
 
NodeStubCachePrimaryOffsetForTesting (Node *name, Node *map)
 
NodeStubCacheSecondaryOffsetForTesting (Node *name, Node *map)
 
void LoadGlobalIC (TNode< FeedbackVector > vector, Node *slot, const LazyNode< Context > &lazy_context, const LazyNode< Name > &lazy_name, TypeofMode typeof_mode, ExitPoint *exit_point, ParameterMode slot_mode=SMI_PARAMETERS)
 
void LoadIC_BytecodeHandler (const LoadICParameters *p, ExitPoint *exit_point)
 
TNode< MaybeObjectLoadHandlerDataField (SloppyTNode< DataHandler > handler, int data_index)
 
- Public Member Functions inherited from v8::internal::CodeStubAssembler
 CodeStubAssembler (compiler::CodeAssemblerState *state)
 
ParameterMode OptimalParameterMode () const
 
MachineRepresentation ParameterRepresentation (ParameterMode mode) const
 
MachineRepresentation OptimalParameterRepresentation () const
 
TNode< IntPtrTParameterToIntPtr (Node *value, ParameterMode mode)
 
NodeIntPtrToParameter (SloppyTNode< IntPtrT > value, ParameterMode mode)
 
NodeInt32ToParameter (SloppyTNode< Int32T > value, ParameterMode mode)
 
TNode< SmiParameterToTagged (Node *value, ParameterMode mode)
 
NodeTaggedToParameter (SloppyTNode< Smi > value, ParameterMode mode)
 
TNode< SmiTaggedToSmi (TNode< Object > value, Label *fail)
 
TNode< NumberTaggedToNumber (TNode< Object > value, Label *fail)
 
TNode< HeapObjectTaggedToHeapObject (TNode< Object > value, Label *fail)
 
TNode< JSArrayHeapObjectToJSArray (TNode< HeapObject > heap_object, Label *fail)
 
TNode< JSArrayTaggedToFastJSArray (TNode< Context > context, TNode< Object > value, Label *fail)
 
TNode< JSDataViewHeapObjectToJSDataView (TNode< HeapObject > heap_object, Label *fail)
 
TNode< JSReceiverHeapObjectToCallable (TNode< HeapObject > heap_object, Label *fail)
 
TNode< StringHeapObjectToString (TNode< HeapObject > heap_object, Label *fail)
 
TNode< JSReceiverHeapObjectToConstructor (TNode< HeapObject > heap_object, Label *fail)
 
NodeMatchesParameterMode (Node *value, ParameterMode mode)
 
 PARAMETER_BINOP (IntPtrOrSmiLessThanOrEqual, IntPtrLessThanOrEqual, SmiLessThanOrEqual) PARAMETER_BINOP(IntPtrOrSmiGreaterThanOrEqual
 
SmiGreaterThanOrEqual PARAMETER_BINOP (UintPtrOrSmiGreaterThanOrEqual, UintPtrGreaterThanOrEqual, SmiAboveOrEqual) TNode< Object > NoContextConstant()
 
NodeIntPtrOrSmiConstant (int value, ParameterMode mode)
 
TNode< SmiLanguageModeConstant (LanguageMode mode)
 
bool IsIntPtrOrSmiConstantZero (Node *test, ParameterMode mode)
 
bool TryGetIntPtrOrSmiConstantValue (Node *maybe_constant, int *value, ParameterMode mode)
 
TNode< IntPtrTIntPtrRoundUpToPowerOfTwo32 (TNode< IntPtrT > value)
 
TNode< IntPtrTIntPtrMax (SloppyTNode< IntPtrT > left, SloppyTNode< IntPtrT > right)
 
TNode< IntPtrTIntPtrMin (SloppyTNode< IntPtrT > left, SloppyTNode< IntPtrT > right)
 
TNode< Float64TFloat64Ceil (SloppyTNode< Float64T > x)
 
TNode< Float64TFloat64Floor (SloppyTNode< Float64T > x)
 
TNode< Float64TFloat64Round (SloppyTNode< Float64T > x)
 
TNode< Float64TFloat64RoundToEven (SloppyTNode< Float64T > x)
 
TNode< Float64TFloat64Trunc (SloppyTNode< Float64T > x)
 
TNode< NumberNumberMax (SloppyTNode< Number > left, SloppyTNode< Number > right)
 
TNode< NumberNumberMin (SloppyTNode< Number > left, SloppyTNode< Number > right)
 
TNode< IntPtrTConvertToRelativeIndex (TNode< Context > context, TNode< Object > index, TNode< IntPtrT > length)
 
TNode< BoolTIsValidPositiveSmi (TNode< IntPtrT > value)
 
TNode< SmiSmiTag (SloppyTNode< IntPtrT > value)
 
TNode< IntPtrTSmiUntag (SloppyTNode< Smi > value)
 
TNode< Float64TSmiToFloat64 (SloppyTNode< Smi > value)
 
TNode< SmiSmiFromIntPtr (SloppyTNode< IntPtrT > value)
 
TNode< SmiSmiFromInt32 (SloppyTNode< Int32T > value)
 
TNode< IntPtrTSmiToIntPtr (SloppyTNode< Smi > value)
 
TNode< Int32TSmiToInt32 (SloppyTNode< Smi > value)
 
TNode< SmiSmiInc (TNode< Smi > value)
 
TNode< IntPtrTTryIntPtrAdd (TNode< IntPtrT > a, TNode< IntPtrT > b, Label *if_overflow)
 
TNode< SmiTrySmiAdd (TNode< Smi > a, TNode< Smi > b, Label *if_overflow)
 
TNode< SmiTrySmiSub (TNode< Smi > a, TNode< Smi > b, Label *if_overflow)
 
TNode< SmiSmiShl (TNode< Smi > a, int shift)
 
TNode< SmiSmiShr (TNode< Smi > a, int shift)
 
NodeWordOrSmiShl (Node *a, int shift, ParameterMode mode)
 
NodeWordOrSmiShr (Node *a, int shift, ParameterMode mode)
 
 SMI_COMPARISON_OP (SmiAboveOrEqual, UintPtrGreaterThanOrEqual, Uint32GreaterThanOrEqual) SMI_COMPARISON_OP(SmiLessThanOrEqual
 
Int32LessThanOrEqual SMI_COMPARISON_OP (SmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual, Int32GreaterThanOrEqual) TNode< Smi > SmiMax(TNode< Smi > a
 
TNode< SmiSmiMin (TNode< Smi > a, TNode< Smi > b)
 
TNode< NumberSmiMod (TNode< Smi > a, TNode< Smi > b)
 
TNode< NumberSmiMul (TNode< Smi > a, TNode< Smi > b)
 
TNode< SmiTrySmiDiv (TNode< Smi > dividend, TNode< Smi > divisor, Label *bailout)
 
TNode< SmiSmiLexicographicCompare (TNode< Smi > x, TNode< Smi > y)
 
TNode< NumberNumberInc (SloppyTNode< Number > value)
 
TNode< NumberNumberDec (SloppyTNode< Number > value)
 
TNode< NumberNumberAdd (SloppyTNode< Number > a, SloppyTNode< Number > b)
 
TNode< NumberNumberSub (SloppyTNode< Number > a, SloppyTNode< Number > b)
 
void GotoIfNotNumber (Node *value, Label *is_not_number)
 
void GotoIfNumber (Node *value, Label *is_number)
 
TNode< NumberSmiToNumber (TNode< Smi > v)
 
TNode< NumberBitwiseOp (Node *left32, Node *right32, Operation bitwise_op)
 
TNode< HeapObjectAllocateInNewSpace (TNode< IntPtrT > size, AllocationFlags flags=kNone)
 
TNode< HeapObjectAllocateInNewSpace (int size, AllocationFlags flags=kNone)
 
TNode< HeapObjectAllocate (TNode< IntPtrT > size, AllocationFlags flags=kNone)
 
TNode< HeapObjectAllocate (int size, AllocationFlags flags=kNone)
 
TNode< HeapObjectInnerAllocate (TNode< HeapObject > previous, int offset)
 
TNode< HeapObjectInnerAllocate (TNode< HeapObject > previous, TNode< IntPtrT > offset)
 
TNode< BoolTIsRegularHeapObjectSize (TNode< IntPtrT > size)
 
void Assert (const BranchGenerator &branch, const char *message=nullptr, const char *file=nullptr, int line=0, Node *extra_node1=nullptr, const char *extra_node1_name="", Node *extra_node2=nullptr, const char *extra_node2_name="", Node *extra_node3=nullptr, const char *extra_node3_name="", Node *extra_node4=nullptr, const char *extra_node4_name="", Node *extra_node5=nullptr, const char *extra_node5_name="")
 
void Assert (const NodeGenerator &condition_body, const char *message=nullptr, const char *file=nullptr, int line=0, Node *extra_node1=nullptr, const char *extra_node1_name="", Node *extra_node2=nullptr, const char *extra_node2_name="", Node *extra_node3=nullptr, const char *extra_node3_name="", Node *extra_node4=nullptr, const char *extra_node4_name="", Node *extra_node5=nullptr, const char *extra_node5_name="")
 
void Check (const BranchGenerator &branch, const char *message=nullptr, const char *file=nullptr, int line=0, Node *extra_node1=nullptr, const char *extra_node1_name="", Node *extra_node2=nullptr, const char *extra_node2_name="", Node *extra_node3=nullptr, const char *extra_node3_name="", Node *extra_node4=nullptr, const char *extra_node4_name="", Node *extra_node5=nullptr, const char *extra_node5_name="")
 
void Check (const NodeGenerator &condition_body, const char *message=nullptr, const char *file=nullptr, int line=0, Node *extra_node1=nullptr, const char *extra_node1_name="", Node *extra_node2=nullptr, const char *extra_node2_name="", Node *extra_node3=nullptr, const char *extra_node3_name="", Node *extra_node4=nullptr, const char *extra_node4_name="", Node *extra_node5=nullptr, const char *extra_node5_name="")
 
void FailAssert (const char *message=nullptr, const char *file=nullptr, int line=0, Node *extra_node1=nullptr, const char *extra_node1_name="", Node *extra_node2=nullptr, const char *extra_node2_name="", Node *extra_node3=nullptr, const char *extra_node3_name="", Node *extra_node4=nullptr, const char *extra_node4_name="", Node *extra_node5=nullptr, const char *extra_node5_name="")
 
void FastCheck (TNode< BoolT > condition)
 
template<class... TArgs>
TNode< ObjectCall (TNode< Context > context, TNode< Object > callable, TNode< JSReceiver > receiver, TArgs... args)
 
template<class... TArgs>
TNode< ObjectCall (TNode< Context > context, TNode< Object > callable, TNode< Object > receiver, TArgs... args)
 
template<class... TArgs>
TNode< JSReceiverConstruct (TNode< Context > context, TNode< JSReceiver > new_target, TArgs... args)
 
template<class A , class F , class G >
TNode< A > Select (SloppyTNode< BoolT > condition, const F &true_body, const G &false_body)
 
template<class A >
TNode< A > SelectConstant (TNode< BoolT > condition, TNode< A > true_value, TNode< A > false_value)
 
TNode< Int32TSelectInt32Constant (SloppyTNode< BoolT > condition, int true_value, int false_value)
 
TNode< IntPtrTSelectIntPtrConstant (SloppyTNode< BoolT > condition, int true_value, int false_value)
 
TNode< OddballSelectBooleanConstant (SloppyTNode< BoolT > condition)
 
TNode< SmiSelectSmiConstant (SloppyTNode< BoolT > condition, Smi true_value, Smi false_value)
 
TNode< SmiSelectSmiConstant (SloppyTNode< BoolT > condition, int true_value, Smi false_value)
 
TNode< SmiSelectSmiConstant (SloppyTNode< BoolT > condition, Smi true_value, int false_value)
 
TNode< SmiSelectSmiConstant (SloppyTNode< BoolT > condition, int true_value, int false_value)
 
TNode< Int32TTruncateIntPtrToInt32 (SloppyTNode< IntPtrT > value)
 
TNode< BoolTTaggedIsSmi (SloppyTNode< Object > a)
 
TNode< BoolTTaggedIsSmi (TNode< MaybeObject > a)
 
TNode< BoolTTaggedIsNotSmi (SloppyTNode< Object > a)
 
TNode< BoolTTaggedIsPositiveSmi (SloppyTNode< Object > a)
 
TNode< BoolTWordIsWordAligned (SloppyTNode< WordT > word)
 
TNode< BoolTWordIsPowerOfTwo (SloppyTNode< IntPtrT > value)
 
void Bind (Label *label)
 
template<class... T>
void Bind (compiler::CodeAssemblerParameterizedLabel< T... > *label, TNode< T > *... phis)
 
void BranchIfSmiEqual (TNode< Smi > a, TNode< Smi > b, Label *if_true, Label *if_false)
 
void BranchIfSmiLessThan (TNode< Smi > a, TNode< Smi > b, Label *if_true, Label *if_false)
 
void BranchIfSmiLessThanOrEqual (TNode< Smi > a, TNode< Smi > b, Label *if_true, Label *if_false)
 
void BranchIfFloat64IsNaN (Node *value, Label *if_true, Label *if_false)
 
void BranchIfToBooleanIsTrue (Node *value, Label *if_true, Label *if_false)
 
void BranchIfJSReceiver (Node *object, Label *if_true, Label *if_false)
 
void GotoIfForceSlowPath (Label *if_true)
 
void GotoIfDebugExecutionModeChecksSideEffects (Label *if_true)
 
NodeLoadFromFrame (int offset, MachineType rep=MachineType::AnyTagged())
 
NodeLoadFromParentFrame (int offset, MachineType rep=MachineType::AnyTagged())
 
TNode< JSFunctionLoadTargetFromFrame ()
 
NodeLoadBufferObject (Node *buffer, int offset, MachineType rep=MachineType::AnyTagged())
 
NodeLoadObjectField (SloppyTNode< HeapObject > object, int offset, MachineType rep)
 
template<class T , typename std::enable_if< std::is_convertible< TNode< T >, TNode< Object >>::value, int >::type = 0>
TNode< TLoadObjectField (TNode< HeapObject > object, int offset)
 
template<class T , typename std::enable_if< std::is_convertible< TNode< T >, TNode< UntaggedT >>::value, int >::type = 0>
TNode< TLoadObjectField (TNode< HeapObject > object, int offset)
 
TNode< ObjectLoadObjectField (SloppyTNode< HeapObject > object, int offset)
 
NodeLoadObjectField (SloppyTNode< HeapObject > object, SloppyTNode< IntPtrT > offset, MachineType rep)
 
TNode< ObjectLoadObjectField (SloppyTNode< HeapObject > object, SloppyTNode< IntPtrT > offset)
 
template<class T , typename std::enable_if< std::is_convertible< TNode< T >, TNode< UntaggedT >>::value, int >::type = 0>
TNode< TLoadObjectField (TNode< HeapObject > object, TNode< IntPtrT > offset)
 
TNode< IntPtrTLoadAndUntagObjectField (SloppyTNode< HeapObject > object, int offset)
 
TNode< Int32TLoadAndUntagToWord32ObjectField (Node *object, int offset)
 
TNode< IntPtrTLoadAndUntagSmi (Node *base, int index)
 
TNode< Int32TLoadAndUntagToWord32Root (RootIndex root_index)
 
TNode< MaybeObjectLoadMaybeWeakObjectField (SloppyTNode< HeapObject > object, int offset)
 
NodeStoreAndTagSmi (Node *base, int offset, Node *value)
 
TNode< Float64TLoadHeapNumberValue (SloppyTNode< HeapNumber > object)
 
TNode< MapLoadMap (SloppyTNode< HeapObject > object)
 
TNode< Int32TLoadInstanceType (SloppyTNode< HeapObject > object)
 
TNode< BoolTHasInstanceType (SloppyTNode< HeapObject > object, InstanceType type)
 
TNode< BoolTDoesntHaveInstanceType (SloppyTNode< HeapObject > object, InstanceType type)
 
TNode< BoolTTaggedDoesntHaveInstanceType (SloppyTNode< HeapObject > any_tagged, InstanceType type)
 
TNode< HeapObjectLoadSlowProperties (SloppyTNode< JSObject > object)
 
TNode< HeapObjectLoadFastProperties (SloppyTNode< JSObject > object)
 
TNode< FixedArrayBaseLoadElements (SloppyTNode< JSObject > object)
 
TNode< ObjectLoadJSArgumentsObjectWithLength (SloppyTNode< JSArgumentsObjectWithLength > array)
 
TNode< NumberLoadJSArrayLength (SloppyTNode< JSArray > array)
 
TNode< SmiLoadFastJSArrayLength (SloppyTNode< JSArray > array)
 
TNode< SmiLoadFixedArrayBaseLength (SloppyTNode< FixedArrayBase > array)
 
TNode< IntPtrTLoadAndUntagFixedArrayBaseLength (SloppyTNode< FixedArrayBase > array)
 
TNode< SmiLoadWeakFixedArrayLength (TNode< WeakFixedArray > array)
 
TNode< IntPtrTLoadAndUntagWeakFixedArrayLength (SloppyTNode< WeakFixedArray > array)
 
TNode< Int32TLoadNumberOfDescriptors (TNode< DescriptorArray > array)
 
TNode< Int32TLoadMapBitField (SloppyTNode< Map > map)
 
TNode< Int32TLoadMapBitField2 (SloppyTNode< Map > map)
 
TNode< Uint32TLoadMapBitField3 (SloppyTNode< Map > map)
 
TNode< Int32TLoadMapInstanceType (SloppyTNode< Map > map)
 
TNode< Int32TLoadMapElementsKind (SloppyTNode< Map > map)
 
TNode< Int32TLoadElementsKind (SloppyTNode< HeapObject > object)
 
TNode< DescriptorArrayLoadMapDescriptors (SloppyTNode< Map > map)
 
TNode< HeapObjectLoadMapPrototype (SloppyTNode< Map > map)
 
TNode< PrototypeInfoLoadMapPrototypeInfo (SloppyTNode< Map > map, Label *if_has_no_proto_info)
 
TNode< IntPtrTLoadMapInstanceSizeInWords (SloppyTNode< Map > map)
 
TNode< IntPtrTLoadMapInobjectPropertiesStartInWords (SloppyTNode< Map > map)
 
TNode< IntPtrTLoadMapConstructorFunctionIndex (SloppyTNode< Map > map)
 
TNode< ObjectLoadMapConstructor (SloppyTNode< Map > map)
 
NodeLoadMapEnumLength (SloppyTNode< Map > map)
 
TNode< ObjectLoadMapBackPointer (SloppyTNode< Map > map)
 
TNode< Uint32TEnsureOnlyHasSimpleProperties (TNode< Map > map, TNode< Int32T > instance_type, Label *bailout)
 
TNode< IntPtrTLoadJSReceiverIdentityHash (SloppyTNode< Object > receiver, Label *if_no_hash=nullptr)
 
void InitializePropertyArrayLength (Node *property_array, Node *length, ParameterMode mode)
 
TNode< BoolTIsDictionaryMap (SloppyTNode< Map > map)
 
TNode< Uint32TLoadNameHashField (SloppyTNode< Name > name)
 
TNode< Uint32TLoadNameHash (SloppyTNode< Name > name, Label *if_hash_not_computed=nullptr)
 
TNode< SmiLoadStringLengthAsSmi (SloppyTNode< String > string)
 
TNode< IntPtrTLoadStringLengthAsWord (SloppyTNode< String > string)
 
TNode< Uint32TLoadStringLengthAsWord32 (SloppyTNode< String > string)
 
NodePointerToSeqStringData (Node *seq_string)
 
NodeLoadJSValueValue (Node *object)
 
void DispatchMaybeObject (TNode< MaybeObject > maybe_object, Label *if_smi, Label *if_cleared, Label *if_weak, Label *if_strong, TVariable< Object > *extracted)
 
TNode< BoolTIsStrong (TNode< MaybeObject > value)
 
TNode< BoolTIsStrong (TNode< Object > value)
 
TNode< HeapObjectGetHeapObjectIfStrong (TNode< MaybeObject > value, Label *if_not_strong)
 
TNode< BoolTIsWeakOrCleared (TNode< MaybeObject > value)
 
TNode< BoolTIsCleared (TNode< MaybeObject > value)
 
TNode< BoolTIsNotCleared (TNode< MaybeObject > value)
 
TNode< HeapObjectGetHeapObjectAssumeWeak (TNode< MaybeObject > value)
 
TNode< HeapObjectGetHeapObjectAssumeWeak (TNode< MaybeObject > value, Label *if_cleared)
 
TNode< BoolTIsWeakReferenceTo (TNode< MaybeObject > object, TNode< Object > value)
 
TNode< BoolTIsNotWeakReferenceTo (TNode< MaybeObject > object, TNode< Object > value)
 
TNode< BoolTIsStrongReferenceTo (TNode< MaybeObject > object, TNode< Object > value)
 
TNode< MaybeObjectMakeWeak (TNode< HeapObject > value)
 
void FixedArrayBoundsCheck (TNode< FixedArrayBase > array, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
template<typename Array >
TNode< IntPtrTLoadArrayLength (TNode< Array > array)
 
template<typename Array >
TNode< MaybeObjectLoadArrayElement (TNode< Array > array, int array_header_size, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
TNode< ObjectLoadFixedArrayElement (TNode< FixedArray > object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
TNode< ObjectLoadFixedArrayElement (TNode< FixedArray > object, TNode< IntPtrT > index, LoadSensitivity needs_poisoning)
 
TNode< ObjectLoadFixedArrayElement (TNode< FixedArray > object, TNode< IntPtrT > index, int additional_offset=0, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
TNode< ObjectLoadFixedArrayElement (TNode< FixedArray > object, int index, int additional_offset=0, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
TNode< ObjectLoadFixedArrayElement (TNode< FixedArray > object, TNode< Smi > index)
 
TNode< ObjectLoadPropertyArrayElement (TNode< PropertyArray > object, SloppyTNode< IntPtrT > index)
 
TNode< IntPtrTLoadPropertyArrayLength (TNode< PropertyArray > object)
 
template<typename Array >
TNode< Int32TLoadAndUntagToWord32ArrayElement (TNode< Array > array, int array_header_size, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
TNode< Int32TLoadAndUntagToWord32FixedArrayElement (TNode< FixedArray > object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
TNode< Int32TLoadAndUntagToWord32FixedArrayElement (TNode< FixedArray > object, int index, int additional_offset=0)
 
TNode< MaybeObjectLoadWeakFixedArrayElement (TNode< WeakFixedArray > object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
TNode< MaybeObjectLoadWeakFixedArrayElement (TNode< WeakFixedArray > object, int index, int additional_offset=0, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
TNode< Float64TLoadFixedDoubleArrayElement (SloppyTNode< FixedDoubleArray > object, Node *index, MachineType machine_type, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS, Label *if_hole=nullptr)
 
NodeLoadFixedDoubleArrayElement (TNode< FixedDoubleArray > object, TNode< Smi > index, Label *if_hole=nullptr)
 
NodeLoadFixedDoubleArrayElement (TNode< FixedDoubleArray > object, TNode< IntPtrT > index, Label *if_hole=nullptr)
 
TNode< ObjectLoadFixedArrayBaseElementAsTagged (TNode< FixedArrayBase > elements, TNode< IntPtrT > index, TNode< Int32T > elements_kind, Label *if_accessor, Label *if_hole)
 
TNode< MaybeObjectLoadFeedbackVectorSlot (Node *object, Node *index, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
TNode< IntPtrTLoadFeedbackVectorLength (TNode< FeedbackVector >)
 
TNode< Float64TLoadDoubleWithHoleCheck (TNode< FixedDoubleArray > array, TNode< Smi > index, Label *if_hole=nullptr)
 
TNode< Float64TLoadDoubleWithHoleCheck (TNode< FixedDoubleArray > array, TNode< IntPtrT > index, Label *if_hole=nullptr)
 
TNode< Float64TLoadDoubleWithHoleCheck (SloppyTNode< Object > base, SloppyTNode< IntPtrT > offset, Label *if_hole, MachineType machine_type=MachineType::Float64())
 
TNode< RawPtrTLoadFixedTypedArrayBackingStore (TNode< FixedTypedArrayBase > typed_array)
 
NodeLoadFixedTypedArrayElementAsTagged (Node *data_pointer, Node *index_node, ElementsKind elements_kind, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
TNode< NumericLoadFixedTypedArrayElementAsTagged (TNode< WordT > data_pointer, TNode< Smi > index, TNode< Int32T > elements_kind)
 
NodeLoadFixedBigInt64ArrayElementAsTagged (Node *data_pointer, Node *offset)
 
NodeLoadFixedBigUint64ArrayElementAsTagged (Node *data_pointer, Node *offset)
 
TNode< BigIntBigIntFromInt64 (TNode< IntPtrT > value)
 
TNode< BigIntBigIntFromUint64 (TNode< UintPtrT > value)
 
TNode< BigIntBigIntFromInt32Pair (TNode< IntPtrT > low, TNode< IntPtrT > high)
 
TNode< BigIntBigIntFromUint32Pair (TNode< UintPtrT > low, TNode< UintPtrT > high)
 
void StoreFixedTypedArrayElementFromTagged (TNode< Context > context, TNode< FixedTypedArrayBase > elements, TNode< Object > index_node, TNode< Object > value, ElementsKind elements_kind, ParameterMode parameter_mode)
 
TNode< ObjectLoadContextElement (SloppyTNode< Context > context, int slot_index)
 
TNode< ObjectLoadContextElement (SloppyTNode< Context > context, SloppyTNode< IntPtrT > slot_index)
 
TNode< ObjectLoadContextElement (TNode< Context > context, TNode< Smi > slot_index)
 
void StoreContextElement (SloppyTNode< Context > context, int slot_index, SloppyTNode< Object > value)
 
void StoreContextElement (SloppyTNode< Context > context, SloppyTNode< IntPtrT > slot_index, SloppyTNode< Object > value)
 
void StoreContextElementNoWriteBarrier (SloppyTNode< Context > context, int slot_index, SloppyTNode< Object > value)
 
TNode< ContextLoadNativeContext (SloppyTNode< Context > context)
 
TNode< ContextLoadModuleContext (SloppyTNode< Context > context)
 
void GotoIfContextElementEqual (Node *value, Node *native_context, int slot_index, Label *if_equal)
 
TNode< MapLoadJSArrayElementsMap (ElementsKind kind, SloppyTNode< Context > native_context)
 
TNode< MapLoadJSArrayElementsMap (SloppyTNode< Int32T > kind, SloppyTNode< Context > native_context)
 
TNode< BoolTIsGeneratorFunction (TNode< JSFunction > function)
 
TNode< BoolTHasPrototypeProperty (TNode< JSFunction > function, TNode< Map > map)
 
void GotoIfPrototypeRequiresRuntimeLookup (TNode< JSFunction > function, TNode< Map > map, Label *runtime)
 
NodeLoadJSFunctionPrototype (Node *function, Label *if_bailout)
 
TNode< BytecodeArrayLoadSharedFunctionInfoBytecodeArray (SloppyTNode< SharedFunctionInfo > shared)
 
TNode< ObjectLoadJSFunctionPrototypeOrInitialMap (TNode< JSFunction > function)
 
void StoreObjectByteNoWriteBarrier (TNode< HeapObject > object, int offset, TNode< Word32T > value)
 
void StoreHeapNumberValue (SloppyTNode< HeapNumber > object, SloppyTNode< Float64T > value)
 
void StoreMutableHeapNumberValue (SloppyTNode< MutableHeapNumber > object, SloppyTNode< Float64T > value)
 
NodeStoreObjectField (Node *object, int offset, Node *value)
 
NodeStoreObjectField (Node *object, Node *offset, Node *value)
 
NodeStoreObjectFieldNoWriteBarrier (Node *object, int offset, Node *value, MachineRepresentation rep=MachineRepresentation::kTagged)
 
NodeStoreObjectFieldNoWriteBarrier (Node *object, Node *offset, Node *value, MachineRepresentation rep=MachineRepresentation::kTagged)
 
template<class T = Object>
TNode< TStoreObjectFieldNoWriteBarrier (TNode< HeapObject > object, TNode< IntPtrT > offset, TNode< T > value)
 
NodeStoreMap (Node *object, Node *map)
 
NodeStoreMapNoWriteBarrier (Node *object, RootIndex map_root_index)
 
NodeStoreMapNoWriteBarrier (Node *object, Node *map)
 
NodeStoreObjectFieldRoot (Node *object, int offset, RootIndex root)
 
void StoreFixedArrayElement (TNode< FixedArray > object, int index, SloppyTNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
 
void StoreFixedArrayElement (TNode< FixedArray > object, int index, TNode< Smi > value)
 
NodeStoreJSArrayLength (TNode< JSArray > array, TNode< Smi > length)
 
NodeStoreElements (TNode< Object > object, TNode< FixedArrayBase > elements)
 
void StoreFixedArrayOrPropertyArrayElement (Node *array, Node *index, Node *value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
void StoreFixedArrayElement (TNode< FixedArray > array, Node *index, SloppyTNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
void StorePropertyArrayElement (TNode< PropertyArray > array, Node *index, SloppyTNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
void StoreFixedArrayElementSmi (TNode< FixedArray > array, TNode< Smi > index, TNode< Object > value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
 
void StoreFixedArrayElement (TNode< FixedArray > array, TNode< IntPtrT > index, TNode< Smi > value)
 
void StoreFixedDoubleArrayElement (TNode< FixedDoubleArray > object, Node *index, TNode< Float64T > value, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
void StoreFixedDoubleArrayElementSmi (TNode< FixedDoubleArray > object, TNode< Smi > index, TNode< Float64T > value)
 
void StoreFixedDoubleArrayHole (TNode< FixedDoubleArray > array, Node *index, ParameterMode mode=INTPTR_PARAMETERS)
 
void StoreFixedDoubleArrayHoleSmi (TNode< FixedDoubleArray > array, TNode< Smi > index)
 
NodeStoreFeedbackVectorSlot (Node *object, Node *index, Node *value, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
void EnsureArrayLengthWritable (TNode< Map > map, Label *bailout)
 
TNode< Int32TEnsureArrayPushable (TNode< Map > map, Label *bailout)
 
void TryStoreArrayElement (ElementsKind kind, ParameterMode mode, Label *bailout, Node *elements, Node *index, Node *value)
 
TNode< SmiBuildAppendJSArray (ElementsKind kind, SloppyTNode< JSArray > array, CodeStubArguments *args, TVariable< IntPtrT > *arg_index, Label *bailout)
 
void BuildAppendJSArray (ElementsKind kind, Node *array, Node *value, Label *bailout)
 
void StoreFieldsNoWriteBarrier (Node *start_address, Node *end_address, Node *value)
 
NodeAllocateCellWithValue (Node *value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
 
NodeAllocateSmiCell (int value=0)
 
NodeLoadCellValue (Node *cell)
 
NodeStoreCellValue (Node *cell, Node *value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
 
TNode< HeapNumberAllocateHeapNumber ()
 
TNode< HeapNumberAllocateHeapNumberWithValue (SloppyTNode< Float64T > value)
 
TNode< HeapNumberAllocateHeapNumberWithValue (double value)
 
TNode< MutableHeapNumberAllocateMutableHeapNumberWithValue (SloppyTNode< Float64T > value)
 
TNode< BigIntAllocateBigInt (TNode< IntPtrT > length)
 
TNode< BigIntAllocateRawBigInt (TNode< IntPtrT > length)
 
void StoreBigIntBitfield (TNode< BigInt > bigint, TNode< WordT > bitfield)
 
void StoreBigIntDigit (TNode< BigInt > bigint, int digit_index, TNode< UintPtrT > digit)
 
TNode< WordTLoadBigIntBitfield (TNode< BigInt > bigint)
 
TNode< UintPtrTLoadBigIntDigit (TNode< BigInt > bigint, int digit_index)
 
TNode< StringAllocateSeqOneByteString (uint32_t length, AllocationFlags flags=kNone)
 
TNode< StringAllocateSeqOneByteString (Node *context, TNode< Uint32T > length, AllocationFlags flags=kNone)
 
TNode< StringAllocateSeqTwoByteString (uint32_t length, AllocationFlags flags=kNone)
 
TNode< StringAllocateSeqTwoByteString (Node *context, TNode< Uint32T > length, AllocationFlags flags=kNone)
 
TNode< StringAllocateSlicedOneByteString (TNode< Uint32T > length, TNode< String > parent, TNode< Smi > offset)
 
TNode< StringAllocateSlicedTwoByteString (TNode< Uint32T > length, TNode< String > parent, TNode< Smi > offset)
 
TNode< StringAllocateOneByteConsString (TNode< Uint32T > length, TNode< String > first, TNode< String > second, AllocationFlags flags=kNone)
 
TNode< StringAllocateTwoByteConsString (TNode< Uint32T > length, TNode< String > first, TNode< String > second, AllocationFlags flags=kNone)
 
TNode< StringNewConsString (TNode< Uint32T > length, TNode< String > left, TNode< String > right, AllocationFlags flags=kNone)
 
TNode< NameDictionaryAllocateNameDictionary (int at_least_space_for)
 
TNode< NameDictionaryAllocateNameDictionary (TNode< IntPtrT > at_least_space_for)
 
TNode< NameDictionaryAllocateNameDictionaryWithCapacity (TNode< IntPtrT > capacity)
 
TNode< NameDictionaryCopyNameDictionary (TNode< NameDictionary > dictionary, Label *large_object_fallback)
 
template<typename CollectionType >
NodeAllocateOrderedHashTable ()
 
template<typename CollectionType >
void FindOrderedHashTableEntry (Node *table, Node *hash, const std::function< void(Node *, Label *, Label *)> &key_compare, Variable *entry_start_position, Label *entry_found, Label *not_found)
 
template<typename CollectionType >
TNode< CollectionType > AllocateSmallOrderedHashTable (TNode< IntPtrT > capacity)
 
NodeAllocateStruct (Node *map, AllocationFlags flags=kNone)
 
void InitializeStructBody (Node *object, Node *map, Node *size, int start_offset=Struct::kHeaderSize)
 
NodeAllocateJSObjectFromMap (Node *map, Node *properties=nullptr, Node *elements=nullptr, AllocationFlags flags=kNone, SlackTrackingMode slack_tracking_mode=kNoSlackTracking)
 
void InitializeJSObjectFromMap (Node *object, Node *map, Node *instance_size, Node *properties=nullptr, Node *elements=nullptr, SlackTrackingMode slack_tracking_mode=kNoSlackTracking)
 
void InitializeJSObjectBodyWithSlackTracking (Node *object, Node *map, Node *instance_size)
 
void InitializeJSObjectBodyNoSlackTracking (Node *object, Node *map, Node *instance_size, int start_offset=JSObject::kHeaderSize)
 
TNode< BoolTIsValidFastJSArrayCapacity (Node *capacity, ParameterMode capacity_mode)
 
TNode< JSArrayAllocateUninitializedJSArrayWithoutElements (TNode< Map > array_map, TNode< Smi > length, Node *allocation_site=nullptr)
 
std::pair< TNode< JSArray >, TNode< FixedArrayBase > > AllocateUninitializedJSArrayWithElements (ElementsKind kind, TNode< Map > array_map, TNode< Smi > length, Node *allocation_site, Node *capacity, ParameterMode capacity_mode=INTPTR_PARAMETERS, AllocationFlags allocation_flags=kNone)
 
TNode< JSArrayAllocateJSArray (ElementsKind kind, TNode< Map > array_map, Node *capacity, TNode< Smi > length, Node *allocation_site=nullptr, ParameterMode capacity_mode=INTPTR_PARAMETERS, AllocationFlags allocation_flags=kNone)
 
TNode< JSArrayAllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< Smi > capacity, TNode< Smi > length)
 
TNode< JSArrayAllocateJSArray (ElementsKind kind, TNode< Map > array_map, TNode< IntPtrT > capacity, TNode< Smi > length)
 
NodeCloneFastJSArray (Node *context, Node *array, ParameterMode mode=INTPTR_PARAMETERS, Node *allocation_site=nullptr, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert)
 
NodeExtractFastJSArray (Node *context, Node *array, Node *begin, Node *count, ParameterMode mode=INTPTR_PARAMETERS, Node *capacity=nullptr, Node *allocation_site=nullptr)
 
TNode< FixedArrayBaseAllocateFixedArray (ElementsKind kind, Node *capacity, ParameterMode mode=INTPTR_PARAMETERS, AllocationFlags flags=kNone, SloppyTNode< Map > fixed_array_map=nullptr)
 
TNode< FixedArrayBaseAllocateFixedArray (ElementsKind kind, TNode< IntPtrT > capacity, AllocationFlags flags, SloppyTNode< Map > fixed_array_map=nullptr)
 
TNode< FixedArrayAllocateZeroedFixedArray (TNode< IntPtrT > capacity)
 
TNode< FixedDoubleArrayAllocateZeroedFixedDoubleArray (TNode< IntPtrT > capacity)
 
TNode< FixedArrayAllocateFixedArrayWithHoles (TNode< IntPtrT > capacity, AllocationFlags flags)
 
NodeAllocatePropertyArray (Node *capacity, ParameterMode mode=INTPTR_PARAMETERS, AllocationFlags flags=kNone)
 
TNode< JSArrayIteratorCreateArrayIterator (TNode< Context > context, TNode< Object > object, IterationKind mode)
 
NodeAllocateJSIteratorResult (Node *context, Node *value, Node *done)
 
NodeAllocateJSIteratorResultForEntry (Node *context, Node *key, Node *value)
 
TNode< JSReceiverArraySpeciesCreate (TNode< Context > context, TNode< Object > originalArray, TNode< Number > len)
 
TNode< JSReceiverInternalArrayCreate (TNode< Context > context, TNode< Number > len)
 
void FillFixedArrayWithValue (ElementsKind kind, Node *array, Node *from_index, Node *to_index, RootIndex value_root_index, ParameterMode mode=INTPTR_PARAMETERS)
 
void FillFixedArrayWithSmiZero (TNode< FixedArray > array, TNode< IntPtrT > length)
 
void FillFixedDoubleArrayWithZero (TNode< FixedDoubleArray > array, TNode< IntPtrT > length)
 
void FillPropertyArrayWithUndefined (Node *array, Node *from_index, Node *to_index, ParameterMode mode=INTPTR_PARAMETERS)
 
void CopyPropertyArrayValues (Node *from_array, Node *to_array, Node *length, WriteBarrierMode barrier_mode, ParameterMode mode, DestroySource destroy_source)
 
void CopyFixedArrayElements (ElementsKind kind, Node *from_array, Node *to_array, Node *length, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, ParameterMode mode=INTPTR_PARAMETERS)
 
void CopyFixedArrayElements (ElementsKind from_kind, Node *from_array, ElementsKind to_kind, Node *to_array, Node *element_count, Node *capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, ParameterMode mode=INTPTR_PARAMETERS)
 
void CopyFixedArrayElements (ElementsKind from_kind, Node *from_array, ElementsKind to_kind, Node *to_array, Node *first_element, Node *element_count, Node *capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER, ParameterMode mode=INTPTR_PARAMETERS, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert, TVariable< BoolT > *var_holes_converted=nullptr)
 
void CopyFixedArrayElements (ElementsKind from_kind, TNode< FixedArrayBase > from_array, ElementsKind to_kind, TNode< FixedArrayBase > to_array, TNode< Smi > first_element, TNode< Smi > element_count, TNode< Smi > capacity, WriteBarrierMode barrier_mode=UPDATE_WRITE_BARRIER)
 
void JumpIfPointersFromHereAreInteresting (TNode< Object > object, Label *interesting)
 
void MoveElements (ElementsKind kind, TNode< FixedArrayBase > elements, TNode< IntPtrT > dst_index, TNode< IntPtrT > src_index, TNode< IntPtrT > length)
 
void CopyElements (ElementsKind kind, TNode< FixedArrayBase > dst_elements, TNode< IntPtrT > dst_index, TNode< FixedArrayBase > src_elements, TNode< IntPtrT > src_index, TNode< IntPtrT > length, WriteBarrierMode write_barrier=UPDATE_WRITE_BARRIER)
 
TNode< FixedArrayHeapObjectToFixedArray (TNode< HeapObject > base, Label *cast_fail)
 
TNode< FixedDoubleArrayHeapObjectToFixedDoubleArray (TNode< HeapObject > base, Label *cast_fail)
 
TNode< FixedArrayHeapObjectToSloppyArgumentsElements (TNode< HeapObject > base, Label *cast_fail)
 
TNode< Int32TConvertElementsKindToInt (TNode< Int32T > elements_kind)
 
TNode< FixedArrayBaseExtractFixedArray (Node *source, Node *first, Node *count=nullptr, Node *capacity=nullptr, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, ParameterMode parameter_mode=INTPTR_PARAMETERS, TVariable< BoolT > *var_holes_converted=nullptr, Node *source_elements_kind=nullptr)
 
TNode< FixedArrayBaseExtractFixedArray (TNode< FixedArrayBase > source, TNode< Smi > first, TNode< Smi > count, TNode< Smi > capacity, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays)
 
TNode< FixedArrayExtractToFixedArray (Node *source, Node *first, Node *count, Node *capacity, Node *source_map, ElementsKind from_kind=PACKED_ELEMENTS, AllocationFlags allocation_flags=AllocationFlag::kNone, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, ParameterMode parameter_mode=INTPTR_PARAMETERS, HoleConversionMode convert_holes=HoleConversionMode::kDontConvert, TVariable< BoolT > *var_holes_converted=nullptr, Node *source_runtime_kind=nullptr)
 
TNode< FixedArrayBaseExtractFixedDoubleArrayFillingHoles (Node *source, Node *first, Node *count, Node *capacity, Node *source_map, TVariable< BoolT > *var_holes_converted, AllocationFlags allocation_flags, ExtractFixedArrayFlags extract_flags=ExtractFixedArrayFlag::kAllFixedArrays, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
NodeCloneFixedArray (Node *source, ExtractFixedArrayFlags flags=ExtractFixedArrayFlag::kAllFixedArraysDontCopyCOW)
 
void CopyStringCharacters (Node *from_string, Node *to_string, TNode< IntPtrT > from_index, TNode< IntPtrT > to_index, TNode< IntPtrT > character_count, String::Encoding from_encoding, String::Encoding to_encoding)
 
NodeLoadElementAndPrepareForStore (Node *array, Node *offset, ElementsKind from_kind, ElementsKind to_kind, Label *if_hole)
 
NodeCalculateNewElementsCapacity (Node *old_capacity, ParameterMode mode=INTPTR_PARAMETERS)
 
TNode< SmiCalculateNewElementsCapacity (TNode< Smi > old_capacity)
 
NodeTryGrowElementsCapacity (Node *object, Node *elements, ElementsKind kind, Node *key, Label *bailout)
 
NodeTryGrowElementsCapacity (Node *object, Node *elements, ElementsKind kind, Node *key, Node *capacity, ParameterMode mode, Label *bailout)
 
NodeGrowElementsCapacity (Node *object, Node *elements, ElementsKind from_kind, ElementsKind to_kind, Node *capacity, Node *new_capacity, ParameterMode mode, Label *bailout)
 
void PossiblyGrowElementsCapacity (ParameterMode mode, ElementsKind kind, Node *array, Node *length, Variable *var_elements, Node *growth, Label *bailout)
 
void InitializeAllocationMemento (Node *base_allocation, Node *base_allocation_size, Node *allocation_site)
 
NodeTryTaggedToFloat64 (Node *value, Label *if_valueisnotnumber)
 
NodeTruncateTaggedToFloat64 (Node *context, Node *value)
 
NodeTruncateTaggedToWord32 (Node *context, Node *value)
 
void TaggedToWord32OrBigInt (Node *context, Node *value, Label *if_number, Variable *var_word32, Label *if_bigint, Variable *var_bigint)
 
void TaggedToWord32OrBigIntWithFeedback (Node *context, Node *value, Label *if_number, Variable *var_word32, Label *if_bigint, Variable *var_bigint, Variable *var_feedback)
 
NodeTruncateHeapNumberValueToWord32 (Node *object)
 
void TryHeapNumberToSmi (TNode< HeapNumber > number, TVariable< Smi > &output, Label *if_smi)
 
void TryFloat64ToSmi (TNode< Float64T > number, TVariable< Smi > &output, Label *if_smi)
 
TNode< NumberChangeFloat64ToTagged (SloppyTNode< Float64T > value)
 
TNode< NumberChangeInt32ToTagged (SloppyTNode< Int32T > value)
 
TNode< NumberChangeUint32ToTagged (SloppyTNode< Uint32T > value)
 
TNode< NumberChangeUintPtrToTagged (TNode< UintPtrT > value)
 
TNode< Uint32TChangeNumberToUint32 (TNode< Number > value)
 
TNode< Float64TChangeNumberToFloat64 (SloppyTNode< Number > value)
 
TNode< UintPtrTChangeNonnegativeNumberToUintPtr (TNode< Number > value)
 
void TaggedToNumeric (Node *context, Node *value, Label *done, Variable *var_numeric)
 
void TaggedToNumericWithFeedback (Node *context, Node *value, Label *done, Variable *var_numeric, Variable *var_feedback)
 
TNode< WordTTimesPointerSize (SloppyTNode< WordT > value)
 
TNode< IntPtrTTimesPointerSize (TNode< IntPtrT > value)
 
TNode< UintPtrTTimesPointerSize (TNode< UintPtrT > value)
 
TNode< WordTTimesDoubleSize (SloppyTNode< WordT > value)
 
TNode< UintPtrTTimesDoubleSize (TNode< UintPtrT > value)
 
TNode< IntPtrTTimesDoubleSize (TNode< IntPtrT > value)
 
TNode< StringToThisString (Node *context, Node *value, char const *method_name)
 
NodeToThisValue (Node *context, Node *value, PrimitiveType primitive_type, char const *method_name)
 
NodeThrowIfNotInstanceType (Node *context, Node *value, InstanceType instance_type, char const *method_name)
 
NodeThrowIfNotJSReceiver (Node *context, Node *value, MessageTemplate msg_template, const char *method_name=nullptr)
 
void ThrowRangeError (Node *context, MessageTemplate message, Node *arg0=nullptr, Node *arg1=nullptr, Node *arg2=nullptr)
 
void ThrowTypeError (Node *context, MessageTemplate message, char const *arg0=nullptr, char const *arg1=nullptr)
 
void ThrowTypeError (Node *context, MessageTemplate message, Node *arg0, Node *arg1=nullptr, Node *arg2=nullptr)
 
TNode< BoolTInstanceTypeEqual (SloppyTNode< Int32T > instance_type, int type)
 
TNode< BoolTIsAccessorInfo (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsAccessorPair (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsAllocationSite (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsAnyHeapNumber (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsNoElementsProtectorCellInvalid ()
 
TNode< BoolTIsArrayIteratorProtectorCellInvalid ()
 
TNode< BoolTIsBigIntInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsBigInt (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsBoolean (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsCallableMap (SloppyTNode< Map > map)
 
TNode< BoolTIsCallable (SloppyTNode< HeapObject > object)
 
TNode< BoolTTaggedIsCallable (TNode< Object > object)
 
TNode< BoolTIsCell (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsCode (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsConsStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsConstructorMap (SloppyTNode< Map > map)
 
TNode< BoolTIsConstructor (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsDeprecatedMap (SloppyTNode< Map > map)
 
TNode< BoolTIsNameDictionary (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsGlobalDictionary (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsExtensibleMap (SloppyTNode< Map > map)
 
TNode< BoolTIsExtensibleNonPrototypeMap (TNode< Map > map)
 
TNode< BoolTIsExternalStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsFeedbackCell (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsFeedbackVector (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsContext (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsFixedArray (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsFixedArraySubclass (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsFixedArrayWithKind (SloppyTNode< HeapObject > object, ElementsKind kind)
 
TNode< BoolTIsFixedArrayWithKindOrEmpty (SloppyTNode< HeapObject > object, ElementsKind kind)
 
TNode< BoolTIsFixedDoubleArray (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsFixedTypedArray (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsFunctionWithPrototypeSlotMap (SloppyTNode< Map > map)
 
TNode< BoolTIsHashTable (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsEphemeronHashTable (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsHeapNumber (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsHeapNumberInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsOddball (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsOddballInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsIndirectStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSArrayBuffer (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSDataView (TNode< HeapObject > object)
 
TNode< BoolTIsJSArrayInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSArrayMap (SloppyTNode< Map > map)
 
TNode< BoolTIsJSArray (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSArrayIterator (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSAsyncGeneratorObject (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSFunctionInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsAllocationSiteInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSFunctionMap (SloppyTNode< Map > map)
 
TNode< BoolTIsJSFunction (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSGeneratorObject (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSGlobalProxyInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSGlobalProxy (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSObjectInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSObjectMap (SloppyTNode< Map > map)
 
TNode< BoolTIsJSObject (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSPromiseMap (SloppyTNode< Map > map)
 
TNode< BoolTIsJSPromise (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSProxy (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSReceiverInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSReceiverMap (SloppyTNode< Map > map)
 
TNode< BoolTIsJSReceiver (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSRegExp (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSTypedArray (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsJSValueInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsJSValueMap (SloppyTNode< Map > map)
 
TNode< BoolTIsJSValue (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsMap (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsMutableHeapNumber (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsName (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsNameInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsNativeContext (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsNullOrJSReceiver (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsNullOrUndefined (SloppyTNode< Object > object)
 
TNode< BoolTIsNumberDictionary (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsOneByteStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTHasOnlyOneByteChars (TNode< Int32T > instance_type)
 
TNode< BoolTIsPrimitiveInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsPrivateSymbol (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsPromiseCapability (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsPropertyArray (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsPropertyCell (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsPrototypeInitialArrayPrototype (SloppyTNode< Context > context, SloppyTNode< Map > map)
 
TNode< BoolTIsPrototypeTypedArrayPrototype (SloppyTNode< Context > context, SloppyTNode< Map > map)
 
TNode< BoolTIsFastAliasedArgumentsMap (TNode< Context > context, TNode< Map > map)
 
TNode< BoolTIsSlowAliasedArgumentsMap (TNode< Context > context, TNode< Map > map)
 
TNode< BoolTIsSloppyArgumentsMap (TNode< Context > context, TNode< Map > map)
 
TNode< BoolTIsStrictArgumentsMap (TNode< Context > context, TNode< Map > map)
 
TNode< BoolTIsSequentialStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsUncachedExternalStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsSpecialReceiverInstanceType (TNode< Int32T > instance_type)
 
TNode< BoolTIsCustomElementsReceiverInstanceType (TNode< Int32T > instance_type)
 
TNode< BoolTIsSpecialReceiverMap (SloppyTNode< Map > map)
 
TNode< BoolTIsSimpleObjectMap (TNode< Map > map)
 
TNode< BoolTIsStringInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsString (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsSymbolInstanceType (SloppyTNode< Int32T > instance_type)
 
TNode< BoolTIsSymbol (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsUndetectableMap (SloppyTNode< Map > map)
 
TNode< BoolTIsNotWeakFixedArraySubclass (SloppyTNode< HeapObject > object)
 
TNode< BoolTIsZeroOrContext (SloppyTNode< Object > object)
 
NodeIsSharedFunctionInfo (Node *object)
 
TNode< BoolTIsPromiseResolveProtectorCellInvalid ()
 
TNode< BoolTIsPromiseThenProtectorCellInvalid ()
 
TNode< BoolTIsArraySpeciesProtectorCellInvalid ()
 
TNode< BoolTIsTypedArraySpeciesProtectorCellInvalid ()
 
TNode< BoolTIsRegExpSpeciesProtectorCellInvalid ()
 
TNode< BoolTIsPromiseSpeciesProtectorCellInvalid ()
 
TNode< BoolTIsNumber (SloppyTNode< Object > object)
 
TNode< BoolTIsNumeric (SloppyTNode< Object > object)
 
TNode< BoolTIsNumberNormalized (SloppyTNode< Number > number)
 
TNode< BoolTIsNumberPositive (SloppyTNode< Number > number)
 
TNode< BoolTIsHeapNumberPositive (TNode< HeapNumber > number)
 
TNode< BoolTIsNumberNonNegativeSafeInteger (TNode< Number > number)
 
TNode< BoolTIsInteger (TNode< Object > number)
 
TNode< BoolTIsInteger (TNode< HeapNumber > number)
 
TNode< BoolTIsSafeInteger (TNode< Object > number)
 
TNode< BoolTIsSafeInteger (TNode< HeapNumber > number)
 
TNode< BoolTIsHeapNumberUint32 (TNode< HeapNumber > number)
 
TNode< BoolTIsNumberArrayIndex (TNode< Number > number)
 
NodeFixedArraySizeDoesntFitInNewSpace (Node *element_count, int base_size=FixedArray::kHeaderSize, ParameterMode mode=INTPTR_PARAMETERS)
 
TNode< BoolTElementsKindEqual (TNode< Int32T > a, TNode< Int32T > b)
 
bool ElementsKindEqual (ElementsKind a, ElementsKind b)
 
NodeIsFastElementsKind (Node *elements_kind)
 
bool IsFastElementsKind (ElementsKind kind)
 
TNode< BoolTIsDictionaryElementsKind (TNode< Int32T > elements_kind)
 
TNode< BoolTIsDoubleElementsKind (TNode< Int32T > elements_kind)
 
bool IsDoubleElementsKind (ElementsKind kind)
 
NodeIsFastSmiOrTaggedElementsKind (Node *elements_kind)
 
NodeIsFastSmiElementsKind (Node *elements_kind)
 
NodeIsHoleyFastElementsKind (Node *elements_kind)
 
NodeIsElementsKindGreaterThan (Node *target_kind, ElementsKind reference_kind)
 
TNode< BoolTIsElementsKindLessThanOrEqual (TNode< Int32T > target_kind, ElementsKind reference_kind)
 
TNode< Int32TStringCharCodeAt (SloppyTNode< String > string, SloppyTNode< IntPtrT > index)
 
TNode< StringStringFromSingleCharCode (TNode< Int32T > code)
 
TNode< StringSubString (TNode< String > string, TNode< IntPtrT > from, TNode< IntPtrT > to)
 
TNode< StringStringAdd (Node *context, TNode< String > first, TNode< String > second, AllocationFlags flags=kNone)
 
void BranchIfCanDerefIndirectString (Node *string, Node *instance_type, Label *can_deref, Label *cannot_deref)
 
void DerefIndirectString (Variable *var_string, Node *instance_type)
 
void MaybeDerefIndirectString (Variable *var_string, Node *instance_type, Label *did_deref, Label *cannot_deref)
 
void MaybeDerefIndirectStrings (Variable *var_left, Node *left_instance_type, Variable *var_right, Node *right_instance_type, Label *did_something)
 
NodeDerefIndirectString (TNode< String > string, TNode< Int32T > instance_type, Label *cannot_deref)
 
TNode< StringStringFromSingleCodePoint (TNode< Int32T > codepoint, UnicodeEncoding encoding)
 
TNode< NumberStringToNumber (TNode< String > input)
 
TNode< StringNumberToString (TNode< Number > input)
 
TNode< NumberNonNumberToNumber (SloppyTNode< Context > context, SloppyTNode< HeapObject > input, BigIntHandling bigint_handling=BigIntHandling::kThrow)
 
TNode< NumericNonNumberToNumeric (SloppyTNode< Context > context, SloppyTNode< HeapObject > input)
 
TNode< NumberToNumber (SloppyTNode< Context > context, SloppyTNode< Object > input, BigIntHandling bigint_handling=BigIntHandling::kThrow)
 
TNode< NumberToNumber_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
TNode< BigIntToBigInt (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
TNode< NumberToUint32 (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
TNode< StringToString (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
TNode< StringToString_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
NodeJSReceiverToPrimitive (Node *context, Node *input)
 
TNode< JSReceiverToObject (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
TNode< JSReceiverToObject_Inline (TNode< Context > context, TNode< Object > input)
 
TNode< SmiToSmiIndex (TNode< Object > input, TNode< Context > context, Label *range_error)
 
TNode< SmiToSmiLength (TNode< Object > input, TNode< Context > context, Label *range_error)
 
TNode< NumberToLength_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input)
 
TNode< NumberToInteger_Inline (SloppyTNode< Context > context, SloppyTNode< Object > input, ToIntegerTruncationMode mode=kNoTruncation)
 
TNode< NumberToInteger (SloppyTNode< Context > context, SloppyTNode< Object > input, ToIntegerTruncationMode mode=kNoTruncation)
 
template<typename BitField >
TNode< Uint32TDecodeWord32 (SloppyTNode< Word32T > word32)
 
template<typename BitField >
TNode< UintPtrTDecodeWord (SloppyTNode< WordT > word)
 
template<typename BitField >
TNode< UintPtrTDecodeWordFromWord32 (SloppyTNode< Word32T > word32)
 
template<typename BitField >
TNode< Uint32TDecodeWord32FromWord (SloppyTNode< WordT > word)
 
TNode< Uint32TDecodeWord32 (SloppyTNode< Word32T > word32, uint32_t shift, uint32_t mask)
 
TNode< UintPtrTDecodeWord (SloppyTNode< WordT > word, uint32_t shift, uint32_t mask)
 
template<typename BitField >
TNode< WordTUpdateWord (TNode< WordT > word, TNode< WordT > value)
 
TNode< WordTUpdateWord (TNode< WordT > word, TNode< WordT > value, uint32_t shift, uint32_t mask)
 
template<typename T >
TNode< BoolTIsSetWord32 (SloppyTNode< Word32T > word32)
 
TNode< BoolTIsSetWord32 (SloppyTNode< Word32T > word32, uint32_t mask)
 
TNode< BoolTIsNotSetWord32 (SloppyTNode< Word32T > word32, uint32_t mask)
 
TNode< BoolTIsAllSetWord32 (SloppyTNode< Word32T > word32, uint32_t mask)
 
template<typename T >
TNode< BoolTIsSetWord (SloppyTNode< WordT > word)
 
TNode< BoolTIsSetWord (SloppyTNode< WordT > word, uint32_t mask)
 
TNode< BoolTIsSetSmi (SloppyTNode< Smi > smi, int untagged_mask)
 
template<typename T >
TNode< BoolTIsClearWord32 (SloppyTNode< Word32T > word32)
 
TNode< BoolTIsClearWord32 (SloppyTNode< Word32T > word32, uint32_t mask)
 
template<typename T >
TNode< BoolTIsClearWord (SloppyTNode< WordT > word)
 
TNode< BoolTIsClearWord (SloppyTNode< WordT > word, uint32_t mask)
 
void SetCounter (StatsCounter *counter, int value)
 
void IncrementCounter (StatsCounter *counter, int delta)
 
void DecrementCounter (StatsCounter *counter, int delta)
 
void Increment (Variable *variable, int value=1, ParameterMode mode=INTPTR_PARAMETERS)
 
void Decrement (Variable *variable, int value=1, ParameterMode mode=INTPTR_PARAMETERS)
 
void Use (Label *label)
 
void TryToName (Node *key, Label *if_keyisindex, Variable *var_index, Label *if_keyisunique, Variable *var_unique, Label *if_bailout, Label *if_notinternalized=nullptr)
 
void TryInternalizeString (Node *string, Label *if_index, Variable *var_index, Label *if_internalized, Variable *var_internalized, Label *if_not_internalized, Label *if_bailout)
 
template<typename Dictionary >
TNode< IntPtrTEntryToIndex (TNode< IntPtrT > entry, int field_index)
 
template<typename Dictionary >
TNode< IntPtrTEntryToIndex (TNode< IntPtrT > entry)
 
template<class ContainerType >
TNode< Uint32TLoadDetailsByKeyIndex (Node *container, Node *key_index)
 
template<class ContainerType >
TNode< ObjectLoadValueByKeyIndex (Node *container, Node *key_index)
 
template<class ContainerType >
void StoreDetailsByKeyIndex (TNode< ContainerType > container, TNode< IntPtrT > key_index, TNode< Smi > details)
 
template<class ContainerType >
void StoreValueByKeyIndex (TNode< ContainerType > container, TNode< IntPtrT > key_index, TNode< Object > value, WriteBarrierMode write_barrier=UPDATE_WRITE_BARRIER)
 
TNode< IntPtrTHashTableComputeCapacity (TNode< IntPtrT > at_least_space_for)
 
template<class Dictionary >
TNode< SmiGetNumberOfElements (TNode< Dictionary > dictionary)
 
TNode< SmiGetNumberDictionaryNumberOfElements (TNode< NumberDictionary > dictionary)
 
template<class Dictionary >
void SetNumberOfElements (TNode< Dictionary > dictionary, TNode< Smi > num_elements_smi)
 
template<class Dictionary >
TNode< SmiGetNumberOfDeletedElements (TNode< Dictionary > dictionary)
 
template<class Dictionary >
void SetNumberOfDeletedElements (TNode< Dictionary > dictionary, TNode< Smi > num_deleted_smi)
 
template<class Dictionary >
TNode< SmiGetCapacity (TNode< Dictionary > dictionary)
 
template<class Dictionary >
TNode< SmiGetNextEnumerationIndex (TNode< Dictionary > dictionary)
 
template<class Dictionary >
void SetNextEnumerationIndex (TNode< Dictionary > dictionary, TNode< Smi > next_enum_index_smi)
 
template<typename Dictionary >
TNode< HeapObjectLoadName (TNode< HeapObject > key)
 
template<typename Dictionary >
void NameDictionaryLookup (TNode< Dictionary > dictionary, TNode< Name > unique_name, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found, int inlined_probes=kInlinedDictionaryProbes, LookupMode mode=kFindExisting)
 
NodeComputeUnseededHash (Node *key)
 
NodeComputeSeededHash (Node *key)
 
void NumberDictionaryLookup (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, Label *if_found, TVariable< IntPtrT > *var_entry, Label *if_not_found)
 
TNode< ObjectBasicLoadNumberDictionaryElement (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, Label *not_data, Label *if_hole)
 
void BasicStoreNumberDictionaryElement (TNode< NumberDictionary > dictionary, TNode< IntPtrT > intptr_index, TNode< Object > value, Label *not_data, Label *if_hole, Label *read_only)
 
template<class Dictionary >
void FindInsertionEntry (TNode< Dictionary > dictionary, TNode< Name > key, TVariable< IntPtrT > *var_key_index)
 
template<class Dictionary >
void InsertEntry (TNode< Dictionary > dictionary, TNode< Name > key, TNode< Object > value, TNode< IntPtrT > index, TNode< Smi > enum_index)
 
template<class Dictionary >
void Add (TNode< Dictionary > dictionary, TNode< Name > key, TNode< Object > value, Label *bailout)
 
void TryHasOwnProperty (Node *object, Node *map, Node *instance_type, Node *unique_name, Label *if_found, Label *if_not_found, Label *if_bailout)
 
void TryGetOwnProperty (Node *context, Node *receiver, Node *object, Node *map, Node *instance_type, Node *unique_name, Label *if_found, Variable *var_value, Label *if_not_found, Label *if_bailout)
 
void TryGetOwnProperty (Node *context, Node *receiver, Node *object, Node *map, Node *instance_type, Node *unique_name, Label *if_found, Variable *var_value, Variable *var_details, Variable *var_raw_value, Label *if_not_found, Label *if_bailout, GetOwnPropertyMode mode)
 
TNode< ObjectGetProperty (SloppyTNode< Context > context, SloppyTNode< Object > receiver, Handle< Name > name)
 
TNode< ObjectGetProperty (SloppyTNode< Context > context, SloppyTNode< Object > receiver, SloppyTNode< Object > name)
 
TNode< ObjectSetPropertyStrict (TNode< Context > context, TNode< Object > receiver, TNode< Object > key, TNode< Object > value)
 
TNode< ObjectSetPropertyInLiteral (TNode< Context > context, TNode< JSObject > receiver, TNode< Object > key, TNode< Object > value)
 
NodeGetMethod (Node *context, Node *object, Handle< Name > name, Label *if_null_or_undefined)
 
template<class... TArgs>
TNode< ObjectCallBuiltin (Builtins::Name id, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
void TailCallBuiltin (Builtins::Name id, SloppyTNode< Object > context, TArgs... args)
 
void LoadPropertyFromFastObject (Node *object, Node *map, TNode< DescriptorArray > descriptors, Node *name_index, Variable *var_details, Variable *var_value)
 
void LoadPropertyFromFastObject (Node *object, Node *map, TNode< DescriptorArray > descriptors, Node *name_index, Node *details, Variable *var_value)
 
void LoadPropertyFromNameDictionary (Node *dictionary, Node *entry, Variable *var_details, Variable *var_value)
 
void LoadPropertyFromGlobalDictionary (Node *dictionary, Node *entry, Variable *var_details, Variable *var_value, Label *if_deleted)
 
void TryLookupProperty (SloppyTNode< JSObject > object, SloppyTNode< Map > map, SloppyTNode< Int32T > instance_type, SloppyTNode< Name > unique_name, Label *if_found_fast, Label *if_found_dict, Label *if_found_global, TVariable< HeapObject > *var_meta_storage, TVariable< IntPtrT > *var_name_index, Label *if_not_found, Label *if_bailout)
 
void TryLookupPropertyInSimpleObject (TNode< JSObject > object, TNode< Map > map, TNode< Name > unique_name, Label *if_found_fast, Label *if_found_dict, TVariable< HeapObject > *var_meta_storage, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
 
void TryLookupElement (Node *object, Node *map, SloppyTNode< Int32T > instance_type, SloppyTNode< IntPtrT > intptr_index, Label *if_found, Label *if_absent, Label *if_not_found, Label *if_bailout)
 
void BranchIfMaybeSpecialIndex (TNode< String > name_string, Label *if_maybe_special_index, Label *if_not_special_index)
 
void TryPrototypeChainLookup (Node *receiver, Node *key, const LookupInHolder &lookup_property_in_holder, const LookupInHolder &lookup_element_in_holder, Label *if_end, Label *if_bailout, Label *if_proxy=nullptr)
 
NodeHasInPrototypeChain (Node *context, Node *object, Node *prototype)
 
NodeOrdinaryHasInstance (Node *context, Node *callable, Node *object)
 
TNode< FeedbackVectorLoadFeedbackVectorForStub ()
 
TNode< FeedbackVectorLoadFeedbackVector (SloppyTNode< JSFunction > closure, Label *if_undefined=nullptr)
 
TNode< ObjectLoadFeedbackVectorUnchecked (SloppyTNode< JSFunction > closure)
 
void UpdateFeedback (Node *feedback, Node *feedback_vector, Node *slot_id)
 
void ReportFeedbackUpdate (SloppyTNode< FeedbackVector > feedback_vector, SloppyTNode< IntPtrT > slot_id, const char *reason)
 
void CombineFeedback (Variable *existing_feedback, int feedback)
 
void CombineFeedback (Variable *existing_feedback, Node *feedback)
 
void OverwriteFeedback (Variable *existing_feedback, int new_feedback)
 
void CheckForAssociatedProtector (Node *name, Label *if_protector)
 
TNode< MapLoadReceiverMap (SloppyTNode< Object > receiver)
 
NodeLoadKeyedSloppyArguments (Node *receiver, Node *key, Label *bailout)
 
void StoreKeyedSloppyArguments (Node *receiver, Node *key, Node *value, Label *bailout)
 
TNode< ContextLoadScriptContext (TNode< Context > context, TNode< IntPtrT > context_index)
 
NodeInt32ToUint8Clamped (Node *int32_value)
 
NodeFloat64ToUint8Clamped (Node *float64_value)
 
NodePrepareValueForWriteToTypedArray (TNode< Object > input, ElementsKind elements_kind, TNode< Context > context)
 
void StoreElement (Node *elements, ElementsKind kind, Node *index, Node *value, ParameterMode mode)
 
void EmitBigTypedArrayElementStore (TNode< JSTypedArray > object, TNode< FixedTypedArrayBase > elements, TNode< IntPtrT > intptr_key, TNode< Object > value, TNode< Context > context, Label *opt_if_neutered)
 
void EmitBigTypedArrayElementStore (TNode< FixedTypedArrayBase > elements, TNode< RawPtrT > backing_store, TNode< IntPtrT > offset, TNode< BigInt > bigint_value)
 
void BigIntToRawBytes (TNode< BigInt > bigint, TVariable< UintPtrT > *var_low, TVariable< UintPtrT > *var_high)
 
void EmitElementStore (Node *object, Node *key, Node *value, ElementsKind elements_kind, KeyedAccessStoreMode store_mode, Label *bailout, Node *context)
 
NodeCheckForCapacityGrow (Node *object, Node *elements, ElementsKind kind, Node *length, Node *key, ParameterMode mode, Label *bailout)
 
NodeCopyElementsOnWrite (Node *object, Node *elements, ElementsKind kind, Node *length, ParameterMode mode, Label *bailout)
 
void TransitionElementsKind (Node *object, Node *map, ElementsKind from_kind, ElementsKind to_kind, Label *bailout)
 
void TrapAllocationMemento (Node *object, Label *memento_found)
 
TNode< IntPtrTPageFromAddress (TNode< IntPtrT > address)
 
TNode< MaybeObjectStoreWeakReferenceInFeedbackVector (SloppyTNode< FeedbackVector > feedback_vector, Node *slot, SloppyTNode< HeapObject > value, int additional_offset=0, ParameterMode parameter_mode=INTPTR_PARAMETERS)
 
TNode< AllocationSiteCreateAllocationSiteInFeedbackVector (SloppyTNode< FeedbackVector > feedback_vector, TNode< Smi > slot)
 
TNode< BoolTNotHasBoilerplate (TNode< Object > maybe_literal_site)
 
TNode< SmiLoadTransitionInfo (TNode< AllocationSite > allocation_site)
 
TNode< JSObjectLoadBoilerplate (TNode< AllocationSite > allocation_site)
 
TNode< Int32TLoadElementsKind (TNode< AllocationSite > allocation_site)
 
NodeBuildFastLoop (const VariableList &var_list, Node *start_index, Node *end_index, const FastLoopBody &body, int increment, ParameterMode parameter_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)
 
NodeBuildFastLoop (Node *start_index, Node *end_index, const FastLoopBody &body, int increment, ParameterMode parameter_mode, IndexAdvanceMode advance_mode=IndexAdvanceMode::kPre)
 
void BuildFastFixedArrayForEach (const CodeStubAssembler::VariableList &vars, Node *fixed_array, ElementsKind kind, Node *first_element_inclusive, Node *last_element_exclusive, const FastFixedArrayForEachBody &body, ParameterMode mode=INTPTR_PARAMETERS, ForEachDirection direction=ForEachDirection::kReverse)
 
void BuildFastFixedArrayForEach (Node *fixed_array, ElementsKind kind, Node *first_element_inclusive, Node *last_element_exclusive, const FastFixedArrayForEachBody &body, ParameterMode mode=INTPTR_PARAMETERS, ForEachDirection direction=ForEachDirection::kReverse)
 
TNode< IntPtrTGetArrayAllocationSize (Node *element_count, ElementsKind kind, ParameterMode mode, int header_size)
 
TNode< IntPtrTGetFixedArrayAllocationSize (Node *element_count, ElementsKind kind, ParameterMode mode)
 
TNode< IntPtrTGetPropertyArrayAllocationSize (Node *element_count, ParameterMode mode)
 
void GotoIfFixedArraySizeDoesntFitInNewSpace (Node *element_count, Label *doesnt_fit, int base_size, ParameterMode mode)
 
void InitializeFieldsWithRoot (Node *object, Node *start_offset, Node *end_offset, RootIndex root)
 
NodeRelationalComparison (Operation op, Node *left, Node *right, Node *context, Variable *var_type_feedback=nullptr)
 
void BranchIfNumberRelationalComparison (Operation op, Node *left, Node *right, Label *if_true, Label *if_false)
 
void BranchIfNumberEqual (TNode< Number > left, TNode< Number > right, Label *if_true, Label *if_false)
 
void BranchIfNumberNotEqual (TNode< Number > left, TNode< Number > right, Label *if_true, Label *if_false)
 
void BranchIfNumberLessThan (TNode< Number > left, TNode< Number > right, Label *if_true, Label *if_false)
 
void BranchIfNumberLessThanOrEqual (TNode< Number > left, TNode< Number > right, Label *if_true, Label *if_false)
 
void BranchIfNumberGreaterThan (TNode< Number > left, TNode< Number > right, Label *if_true, Label *if_false)
 
void BranchIfNumberGreaterThanOrEqual (TNode< Number > left, TNode< Number > right, Label *if_true, Label *if_false)
 
void BranchIfAccessorPair (Node *value, Label *if_accessor_pair, Label *if_not_accessor_pair)
 
void GotoIfNumberGreaterThanOrEqual (Node *left, Node *right, Label *if_false)
 
NodeEqual (Node *lhs, Node *rhs, Node *context, Variable *var_type_feedback=nullptr)
 
NodeStrictEqual (Node *lhs, Node *rhs, Variable *var_type_feedback=nullptr)
 
void BranchIfSameValue (Node *lhs, Node *rhs, Label *if_true, Label *if_false)
 
TNode< OddballHasProperty (SloppyTNode< Context > context, SloppyTNode< Object > object, SloppyTNode< Object > key, HasPropertyLookupMode mode)
 
TNode< OddballHasProperty_Inline (TNode< Context > context, TNode< JSReceiver > object, TNode< Object > key)
 
NodeTypeof (Node *value)
 
TNode< ObjectGetSuperConstructor (SloppyTNode< Context > context, SloppyTNode< JSFunction > active_function)
 
TNode< JSReceiverSpeciesConstructor (SloppyTNode< Context > context, SloppyTNode< Object > object, SloppyTNode< JSReceiver > default_constructor)
 
NodeInstanceOf (Node *object, Node *callable, Node *context)
 
NodeIsDebugActive ()
 
TNode< BoolTIsRuntimeCallStatsEnabled ()
 
TNode< Uint32TLoadJSArrayBufferBitField (TNode< JSArrayBuffer > array_buffer)
 
TNode< RawPtrTLoadJSArrayBufferBackingStore (TNode< JSArrayBuffer > array_buffer)
 
NodeIsDetachedBuffer (Node *buffer)
 
void ThrowIfArrayBufferIsDetached (SloppyTNode< Context > context, TNode< JSArrayBuffer > array_buffer, const char *method_name)
 
TNode< JSArrayBufferLoadJSArrayBufferViewBuffer (TNode< JSArrayBufferView > array_buffer_view)
 
TNode< UintPtrTLoadJSArrayBufferViewByteLength (TNode< JSArrayBufferView > array_buffer_view)
 
TNode< UintPtrTLoadJSArrayBufferViewByteOffset (TNode< JSArrayBufferView > array_buffer_view)
 
void ThrowIfArrayBufferViewBufferIsDetached (SloppyTNode< Context > context, TNode< JSArrayBufferView > array_buffer_view, const char *method_name)
 
TNode< SmiLoadJSTypedArrayLength (TNode< JSTypedArray > typed_array)
 
TNode< IntPtrTElementOffsetFromIndex (Node *index, ElementsKind kind, ParameterMode mode, int base_size=0)
 
TNode< BoolTIsOffsetInBounds (SloppyTNode< IntPtrT > offset, SloppyTNode< IntPtrT > length, int header_size, ElementsKind kind=HOLEY_ELEMENTS)
 
TNode< CodeLoadBuiltin (TNode< Smi > builtin_id)
 
TNode< CodeGetSharedFunctionInfoCode (SloppyTNode< SharedFunctionInfo > shared_info, Label *if_compile_lazy=nullptr)
 
NodeAllocateFunctionWithMapAndContext (Node *map, Node *shared_info, Node *context)
 
NodeIsPromiseHookEnabled ()
 
NodeHasAsyncEventDelegate ()
 
NodeIsPromiseHookEnabledOrHasAsyncEventDelegate ()
 
NodeIsPromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate ()
 
NodeMarkerIsFrameType (Node *marker_or_function, StackFrame::Type frame_type)
 
NodeMarkerIsNotFrameType (Node *marker_or_function, StackFrame::Type frame_type)
 
void CheckPrototypeEnumCache (Node *receiver, Node *receiver_map, Label *if_fast, Label *if_slow)
 
NodeCheckEnumCache (Node *receiver, Label *if_empty, Label *if_runtime)
 
TNode< IntPtrTGetArgumentsLength (CodeStubArguments *args)
 
TNode< ObjectGetArgumentValue (CodeStubArguments *args, TNode< IntPtrT > index)
 
void Print (const char *s)
 
void Print (const char *prefix, Node *tagged_value)
 
void Print (SloppyTNode< Object > tagged_value)
 
void Print (TNode< MaybeObject > tagged_value)
 
template<class... TArgs>
NodeMakeTypeError (MessageTemplate message, Node *context, TArgs... args)
 
void Abort (AbortReason reason)
 
bool ConstexprBoolNot (bool value)
 
bool ConstexprInt31Equal (int31_t a, int31_t b)
 
uint32_t ConstexprUint32Add (uint32_t a, uint32_t b)
 
void PerformStackCheck (TNode< Context > context)
 
void SetPropertyLength (TNode< Context > context, TNode< Object > array, TNode< Number > length)
 
void GotoIfInitialPrototypePropertyModified (TNode< Map > object_map, TNode< Map > initial_prototype_map, int descfriptor, RootIndex field_name_root_index, Label *if_modified)
 
void GotoIfInitialPrototypePropertiesModified (TNode< Map > object_map, TNode< Map > initial_prototype_map, Vector< DescriptorIndexAndName > properties, Label *if_modified)
 
void DescriptorLookup (SloppyTNode< Name > unique_name, SloppyTNode< DescriptorArray > descriptors, SloppyTNode< Uint32T > bitfield3, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
 
void TransitionLookup (SloppyTNode< Name > unique_name, SloppyTNode< TransitionArray > transitions, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
 
template<typename Array >
void Lookup (TNode< Name > unique_name, TNode< Array > array, TNode< Uint32T > number_of_valid_entries, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
 
template<typename Array >
void LookupLinear (TNode< Name > unique_name, TNode< Array > array, TNode< Uint32T > number_of_valid_entries, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
 
template<typename Array >
void LookupBinary (TNode< Name > unique_name, TNode< Array > array, TNode< Uint32T > number_of_valid_entries, Label *if_found, TVariable< IntPtrT > *var_name_index, Label *if_not_found)
 
template<typename Array >
TNode< IntPtrTEntryIndexToIndex (TNode< Uint32T > entry_index)
 
template<typename Array >
TNode< IntPtrTToKeyIndex (TNode< Uint32T > entry_index)
 
template<typename Array >
TNode< NameGetKey (TNode< Array > array, TNode< Uint32T > entry_index)
 
TNode< Uint32TDescriptorArrayGetDetails (TNode< DescriptorArray > descriptors, TNode< Uint32T > descriptor_number)
 
void DescriptorArrayForEach (VariableList &variable_list, TNode< Uint32T > start_descriptor, TNode< Uint32T > end_descriptor, const ForEachDescriptorBodyFunction &body)
 
TNode< NameLoadKeyByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)
 
TNode< Uint32TLoadDetailsByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)
 
TNode< ObjectLoadValueByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)
 
TNode< MaybeObjectLoadFieldTypeByKeyIndex (TNode< DescriptorArray > container, TNode< IntPtrT > key_index)
 
TNode< IntPtrTDescriptorEntryToIndex (TNode< IntPtrT > descriptor)
 
TNode< NameLoadKeyByDescriptorEntry (TNode< DescriptorArray > descriptors, TNode< IntPtrT > descriptor)
 
TNode< NameLoadKeyByDescriptorEntry (TNode< DescriptorArray > descriptors, int descriptor)
 
TNode< Uint32TLoadDetailsByDescriptorEntry (TNode< DescriptorArray > descriptors, TNode< IntPtrT > descriptor)
 
TNode< Uint32TLoadDetailsByDescriptorEntry (TNode< DescriptorArray > descriptors, int descriptor)
 
TNode< ObjectLoadValueByDescriptorEntry (TNode< DescriptorArray > descriptors, int descriptor)
 
TNode< MaybeObjectLoadFieldTypeByDescriptorEntry (TNode< DescriptorArray > descriptors, TNode< IntPtrT > descriptor)
 
void ForEachEnumerableOwnProperty (TNode< Context > context, TNode< Map > map, TNode< JSObject > object, const ForEachKeyValueFunction &body, Label *bailout)
 
TNode< ObjectCallGetterIfAccessor (Node *value, Node *details, Node *context, Node *receiver, Label *if_bailout, GetOwnPropertyMode mode=kCallJSGetter)
 
TNode< IntPtrTTryToIntptr (Node *key, Label *miss)
 
void BranchIfPrototypesHaveNoElements (Node *receiver_map, Label *definitely_no_elements, Label *possibly_elements)
 
void InitializeFunctionContext (Node *native_context, Node *context, int slots)
 
TNode< JSArrayArrayCreate (TNode< Context > context, TNode< Number > length)
 
TNode< ObjectCloneIfMutablePrimitive (TNode< Object > object)
 
template<>
TNode< IntPtrTLoadArrayLength (TNode< FixedArray > array)
 
template<>
TNode< IntPtrTLoadArrayLength (TNode< WeakFixedArray > array)
 
template<>
TNode< IntPtrTLoadArrayLength (TNode< PropertyArray > array)
 
template<>
TNode< IntPtrTLoadArrayLength (TNode< DescriptorArray > array)
 
template<>
TNode< IntPtrTLoadArrayLength (TNode< TransitionArray > array)
 
template<>
TNode< HeapObjectLoadName (TNode< HeapObject > key)
 
template<>
TNode< HeapObjectLoadName (TNode< HeapObject > key)
 
template<>
void FindInsertionEntry (TNode< NameDictionary > dictionary, TNode< Name > key, TVariable< IntPtrT > *var_key_index)
 
template<>
void InsertEntry (TNode< NameDictionary > dictionary, TNode< Name > name, TNode< Object > value, TNode< IntPtrT > index, TNode< Smi > enum_index)
 
template<>
void InsertEntry (TNode< GlobalDictionary > dictionary, TNode< Name > key, TNode< Object > value, TNode< IntPtrT > index, TNode< Smi > enum_index)
 
- Public Member Functions inherited from v8::internal::compiler::CodeAssembler
 CodeAssembler (CodeAssemblerState *state)
 
bool Is64 () const
 
bool IsFloat64RoundUpSupported () const
 
bool IsFloat64RoundDownSupported () const
 
bool IsFloat64RoundTiesEvenSupported () const
 
bool IsFloat64RoundTruncateSupported () const
 
bool IsInt32AbsWithOverflowSupported () const
 
bool IsInt64AbsWithOverflowSupported () const
 
bool IsIntPtrAbsWithOverflowSupported () const
 
template<class T >
TNode< TUncheckedCast (Node *value)
 
template<class T , class U >
TNode< TUncheckedCast (TNode< U > value)
 
template<class T >
TNode< TReinterpretCast (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< Int32TInt32Constant (int32_t value)
 
TNode< Int64TInt64Constant (int64_t value)
 
TNode< IntPtrTIntPtrConstant (intptr_t value)
 
TNode< Uint32TUint32Constant (uint32_t value)
 
TNode< UintPtrTUintPtrConstant (uintptr_t value)
 
TNode< NumberNumberConstant (double value)
 
TNode< SmiSmiConstant (Smi value)
 
TNode< SmiSmiConstant (int value)
 
template<typename E , typename = typename std::enable_if<std::is_enum<E>::value>::type>
TNode< SmiSmiConstant (E value)
 
TNode< HeapObjectUntypedHeapConstant (Handle< HeapObject > object)
 
template<class Type >
TNode< TypeHeapConstant (Handle< Type > object)
 
TNode< StringStringConstant (const char *str)
 
TNode< OddballBooleanConstant (bool value)
 
TNode< ExternalReferenceExternalConstant (ExternalReference address)
 
TNode< Float64TFloat64Constant (double value)
 
TNode< HeapNumberNaNConstant ()
 
TNode< BoolTInt32TrueConstant ()
 
TNode< BoolTInt32FalseConstant ()
 
TNode< BoolTBoolConstant (bool value)
 
bool ToInt32Constant (Node *node, int32_t &out_value)
 
bool ToInt64Constant (Node *node, int64_t &out_value)
 
bool ToSmiConstant (Node *node, Smi *out_value)
 
bool ToIntPtrConstant (Node *node, intptr_t &out_value)
 
bool IsUndefinedConstant (TNode< Object > node)
 
bool IsNullConstant (TNode< Object > node)
 
TNode< Int32TSigned (TNode< Word32T > x)
 
TNode< IntPtrTSigned (TNode< WordT > x)
 
TNode< Uint32TUnsigned (TNode< Word32T > x)
 
TNode< UintPtrTUnsigned (TNode< WordT > x)
 
NodeParameter (int value)
 
TNode< ContextGetJSContextParameter ()
 
void Return (SloppyTNode< Object > value)
 
void Return (SloppyTNode< Object > value1, SloppyTNode< Object > value2)
 
void Return (SloppyTNode< Object > value1, SloppyTNode< Object > value2, SloppyTNode< Object > value3)
 
void PopAndReturn (Node *pop, Node *value)
 
void ReturnIf (Node *condition, Node *value)
 
void ReturnRaw (Node *value)
 
void DebugAbort (Node *message)
 
void DebugBreak ()
 
void Unreachable ()
 
void Comment (const char *format,...)
 
void Bind (Label *label)
 
void Goto (Label *label)
 
void GotoIf (SloppyTNode< IntegralT > condition, Label *true_label)
 
void GotoIfNot (SloppyTNode< IntegralT > condition, Label *false_label)
 
void Branch (SloppyTNode< IntegralT > condition, Label *true_label, Label *false_label)
 
template<class T >
TNode< TUninitialized ()
 
template<class... T>
void Bind (CodeAssemblerParameterizedLabel< T... > *label, TNode< T > *... phis)
 
template<class... T, class... Args>
void Branch (TNode< BoolT > condition, CodeAssemblerParameterizedLabel< T... > *if_true, CodeAssemblerParameterizedLabel< T... > *if_false, Args... args)
 
template<class... T, class... Args>
void Goto (CodeAssemblerParameterizedLabel< T... > *label, Args... args)
 
void Branch (TNode< BoolT > condition, const std::function< void()> &true_body, const std::function< void()> &false_body)
 
void Branch (TNode< BoolT > condition, Label *true_label, const std::function< void()> &false_body)
 
void Branch (TNode< BoolT > condition, const std::function< void()> &true_body, Label *false_label)
 
void Switch (Node *index, Label *default_label, const int32_t *case_values, Label **case_labels, size_t case_count)
 
NodeLoadFramePointer ()
 
NodeLoadParentFramePointer ()
 
NodeLoadStackPointer ()
 
TNode< ObjectTaggedPoisonOnSpeculation (SloppyTNode< Object > value)
 
TNode< WordTWordPoisonOnSpeculation (SloppyTNode< WordT > value)
 
NodeLoad (MachineType rep, Node *base, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
template<class Type >
TNode< TypeLoad (MachineType rep, TNode< RawPtr< Type >> base)
 
NodeLoad (MachineType rep, Node *base, Node *offset, LoadSensitivity needs_poisoning=LoadSensitivity::kSafe)
 
NodeAtomicLoad (MachineType rep, Node *base, Node *offset)
 
TNode< ObjectLoadRoot (RootIndex root_index)
 
NodeStore (Node *base, Node *value)
 
NodeStore (Node *base, Node *offset, Node *value)
 
NodeStoreWithMapWriteBarrier (Node *base, Node *offset, Node *value)
 
NodeStoreNoWriteBarrier (MachineRepresentation rep, Node *base, Node *value)
 
NodeStoreNoWriteBarrier (MachineRepresentation rep, Node *base, Node *offset, Node *value)
 
NodeAtomicStore (MachineRepresentation rep, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeAtomicExchange (MachineType type, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeAtomicCompareExchange (MachineType type, Node *base, Node *offset, Node *old_value, Node *new_value, Node *old_value_high=nullptr, Node *new_value_high=nullptr)
 
NodeAtomicAdd (MachineType type, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeAtomicSub (MachineType type, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeAtomicAnd (MachineType type, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeAtomicOr (MachineType type, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeAtomicXor (MachineType type, Node *base, Node *offset, Node *value, Node *value_high=nullptr)
 
NodeStoreRoot (RootIndex root_index, Node *value)
 
TNode< IntPtrTWordShr (TNode< IntPtrT > left, TNode< IntegralT > right)
 
TNode< IntPtrTWordSar (TNode< IntPtrT > left, TNode< IntegralT > right)
 
TNode< IntPtrTWordAnd (TNode< IntPtrT > left, TNode< IntPtrT > right)
 
template<class Left , class Right , class = typename std::enable_if< (std::is_base_of<Object, Left>::value || std::is_base_of<ObjectPtr, Left>::value) && (std::is_base_of<Object, Right>::value || std::is_base_of<ObjectPtr, Right>::value)>::type>
TNode< BoolTWordEqual (TNode< Left > left, TNode< Right > right)
 
TNode< BoolTWordEqual (TNode< Object > left, Node *right)
 
TNode< BoolTWordEqual (Node *left, TNode< Object > right)
 
template<class Left , class Right , class = typename std::enable_if< (std::is_base_of<Object, Left>::value || std::is_base_of<ObjectPtr, Left>::value) && (std::is_base_of<Object, Right>::value || std::is_base_of<ObjectPtr, Right>::value)>::type>
TNode< BoolTWordNotEqual (TNode< Left > left, TNode< Right > right)
 
TNode< BoolTWordNotEqual (TNode< Object > left, Node *right)
 
TNode< BoolTWordNotEqual (Node *left, TNode< Object > right)
 
TNode< BoolTIntPtrEqual (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< BoolTWordEqual (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< BoolTWordNotEqual (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< BoolTWord32Equal (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< BoolTWord32NotEqual (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< BoolTWord64Equal (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< BoolTWord64NotEqual (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< Int32TInt32Add (TNode< Int32T > left, TNode< Int32T > right)
 
TNode< Uint32TUint32Add (TNode< Uint32T > left, TNode< Uint32T > right)
 
TNode< WordTIntPtrAdd (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< IntPtrTIntPtrDiv (TNode< IntPtrT > left, TNode< IntPtrT > right)
 
TNode< WordTIntPtrSub (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< WordTIntPtrMul (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< IntPtrTIntPtrAdd (TNode< IntPtrT > left, TNode< IntPtrT > right)
 
TNode< IntPtrTIntPtrSub (TNode< IntPtrT > left, TNode< IntPtrT > right)
 
TNode< IntPtrTIntPtrMul (TNode< IntPtrT > left, TNode< IntPtrT > right)
 
TNode< UintPtrTUintPtrAdd (TNode< UintPtrT > left, TNode< UintPtrT > right)
 
TNode< UintPtrTUintPtrSub (TNode< UintPtrT > left, TNode< UintPtrT > right)
 
TNode< WordTWordShl (SloppyTNode< WordT > value, int shift)
 
TNode< WordTWordShr (SloppyTNode< WordT > value, int shift)
 
TNode< WordTWordSar (SloppyTNode< WordT > value, int shift)
 
TNode< IntPtrTWordShr (TNode< IntPtrT > value, int shift)
 
TNode< IntPtrTWordSar (TNode< IntPtrT > value, int shift)
 
TNode< Word32TWord32Shr (SloppyTNode< Word32T > value, int shift)
 
TNode< WordTWordOr (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< WordTWordAnd (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< WordTWordXor (SloppyTNode< WordT > left, SloppyTNode< WordT > right)
 
TNode< WordTWordShl (SloppyTNode< WordT > left, SloppyTNode< IntegralT > right)
 
TNode< WordTWordShr (SloppyTNode< WordT > left, SloppyTNode< IntegralT > right)
 
TNode< WordTWordSar (SloppyTNode< WordT > left, SloppyTNode< IntegralT > right)
 
TNode< Word32TWord32Or (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< Word32TWord32And (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< Word32TWord32Xor (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< Word32TWord32Shl (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< Word32TWord32Shr (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< Word32TWord32Sar (SloppyTNode< Word32T > left, SloppyTNode< Word32T > right)
 
TNode< Word64TWord64Or (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< Word64TWord64And (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< Word64TWord64Xor (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< Word64TWord64Shl (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< Word64TWord64Shr (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< Word64TWord64Sar (SloppyTNode< Word64T > left, SloppyTNode< Word64T > right)
 
TNode< UintPtrTChangeFloat64ToUintPtr (SloppyTNode< Float64T > value)
 
TNode< Float64TChangeUintPtrToFloat64 (TNode< UintPtrT > value)
 
NodeRoundIntPtrToFloat64 (Node *value)
 
TNode< UintPtrTChangeUint32ToWord (SloppyTNode< Word32T > value)
 
TNode< IntPtrTChangeInt32ToIntPtr (SloppyTNode< Word32T > value)
 
NodeRetain (Node *value)
 
NodeProjection (int index, Node *value)
 
template<int index, class T1 , class T2 >
TNode< typename std::tuple_element< index, std::tuple< T1, T2 > >::typeProjection (TNode< PairT< T1, T2 >> value)
 
template<class... TArgs>
TNode< ObjectCallRuntime (Runtime::FunctionId function, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
TNode< ObjectCallRuntimeWithCEntry (Runtime::FunctionId function, TNode< Code > centry, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
void TailCallRuntime (Runtime::FunctionId function, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
void TailCallRuntime (Runtime::FunctionId function, TNode< Int32T > arity, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
void TailCallRuntimeWithCEntry (Runtime::FunctionId function, TNode< Code > centry, TNode< Object > context, TArgs... args)
 
template<class T = Object, class... TArgs>
TNode< TCallStub (Callable const &callable, SloppyTNode< Object > context, TArgs... args)
 
template<class T = Object, class... TArgs>
TNode< TCallStub (const CallInterfaceDescriptor &descriptor, SloppyTNode< Code > target, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
NodeCallStubR (const CallInterfaceDescriptor &descriptor, size_t result_size, SloppyTNode< Code > target, SloppyTNode< Object > context, TArgs... args)
 
NodeCallStubN (const CallInterfaceDescriptor &descriptor, size_t result_size, int input_count, Node *const *inputs)
 
template<class... TArgs>
void TailCallStub (Callable const &callable, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
void TailCallStub (const CallInterfaceDescriptor &descriptor, SloppyTNode< Code > target, SloppyTNode< Object > context, TArgs... args)
 
template<class... TArgs>
NodeTailCallBytecodeDispatch (const CallInterfaceDescriptor &descriptor, Node *target, TArgs... args)
 
template<class... TArgs>
NodeTailCallStubThenBytecodeDispatch (const CallInterfaceDescriptor &descriptor, Node *target, Node *context, TArgs... args)
 
TNode< ObjectTailCallJSCode (TNode< Code > code, TNode< Context > context, TNode< JSFunction > function, TNode< Object > new_target, TNode< Int32T > arg_count)
 
template<class... TArgs>
NodeCallJS (Callable const &callable, Node *context, Node *function, Node *receiver, TArgs... args)
 
template<class... TArgs>
NodeConstructJS (Callable const &callable, Node *context, Node *new_target, TArgs... args)
 
NodeCallCFunctionN (Signature< MachineType > *signature, int input_count, Node *const *inputs)
 
NodeCallCFunction1 (MachineType return_type, MachineType arg0_type, Node *function, Node *arg0)
 
NodeCallCFunction1WithCallerSavedRegisters (MachineType return_type, MachineType arg0_type, Node *function, Node *arg0, SaveFPRegsMode mode)
 
NodeCallCFunction2 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, Node *function, Node *arg0, Node *arg1)
 
NodeCallCFunction3 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, Node *function, Node *arg0, Node *arg1, Node *arg2)
 
NodeCallCFunction3WithCallerSavedRegisters (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, Node *function, Node *arg0, Node *arg1, Node *arg2, SaveFPRegsMode mode)
 
NodeCallCFunction4 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, Node *function, Node *arg0, Node *arg1, Node *arg2, Node *arg3)
 
NodeCallCFunction5 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, MachineType arg4_type, Node *function, Node *arg0, Node *arg1, Node *arg2, Node *arg3, Node *arg4)
 
NodeCallCFunction6 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, MachineType arg4_type, MachineType arg5_type, Node *function, Node *arg0, Node *arg1, Node *arg2, Node *arg3, Node *arg4, Node *arg5)
 
NodeCallCFunction9 (MachineType return_type, MachineType arg0_type, MachineType arg1_type, MachineType arg2_type, MachineType arg3_type, MachineType arg4_type, MachineType arg5_type, MachineType arg6_type, MachineType arg7_type, MachineType arg8_type, Node *function, Node *arg0, Node *arg1, Node *arg2, Node *arg3, Node *arg4, Node *arg5, Node *arg6, Node *arg7, Node *arg8)
 
void GotoIfException (Node *node, Label *if_exception, Variable *exception_var=nullptr)
 
Factoryfactory () const
 
Isolateisolate () const
 
Zonezone () const
 
CodeAssemblerStatestate ()
 
void BreakOnNode (int node_id)
 
bool UnalignedLoadSupported (MachineRepresentation rep) const
 
bool UnalignedStoreSupported (MachineRepresentation rep) const
 
bool IsExceptionHandlerActive () const
 

Protected Types

enum  ICMode { kNonGlobalIC, kGlobalIC }
 
enum  ElementSupport { kOnlyProperties, kSupportElements }
 
enum  StoreTransitionMapFlags { kCheckPrototypeValidity = 1 << 0, kValidateTransitionHandler = 1 << 1, kStoreTransitionMapFlagsMask }
 

Protected Member Functions

void HandleStoreICHandlerCase (const StoreICParameters *p, TNode< MaybeObject > handler, Label *miss, ICMode ic_mode, ElementSupport support_elements=kOnlyProperties)
 
void HandleStoreICTransitionMapHandlerCase (const StoreICParameters *p, TNode< Map > transition_map, Label *miss, StoreTransitionMapFlags flags)
 
void JumpIfDataProperty (Node *details, Label *writable, Label *readonly)
 
void BranchIfStrictMode (Node *vector, Node *slot, Label *if_strict)
 
void InvalidateValidityCellIfPrototype (Node *map, Node *bitfield2=nullptr)
 
void OverwriteExistingFastDataProperty (Node *object, Node *object_map, Node *descriptors, Node *descriptor_name_index, Node *details, Node *value, Label *slow, bool do_transitioning_store)
 
void CheckFieldType (TNode< DescriptorArray > descriptors, Node *name_index, Node *representation, Node *value, Label *bailout)
 
- Protected Member Functions inherited from v8::internal::compiler::CodeAssembler
void RegisterCallGenerationCallbacks (const CodeAssemblerCallback &call_prologue, const CodeAssemblerCallback &call_epilogue)
 
void UnregisterCallGenerationCallbacks ()
 
bool Word32ShiftIsSafe () const
 
PoisoningMitigationLevel poisoning_level () const
 
bool IsJSFunctionCall () const
 

Additional Inherited Members

- Static Public Member Functions inherited from v8::internal::compiler::CodeAssembler
static Handle< CodeGenerateCode (CodeAssemblerState *state, const AssemblerOptions &options)
 
- Public Attributes inherited from v8::internal::CodeStubAssembler
 IntPtrGreaterThanOrEqual
 
 IntPtrLessThanOrEqual
 
Int32LessThanOrEqual TNode< Smib
 
- Static Public Attributes inherited from v8::internal::CodeStubAssembler
static const int kInlinedDictionaryProbes = 4
 
- Static Public Attributes inherited from v8::internal::compiler::CodeAssembler
static constexpr int kTargetParameterIndex = -1
 

Detailed Description

Definition at line 19 of file accessor-assembler.h.


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