Lines Matching refs:TNode
232 (csa)->Check([&]() -> TNode<BoolT> { return x; }, #x, __FILE__, __LINE__)
268 [&]() -> TNode<BoolT> { \
269 const TNode<Word32T> argc = (csa)->UncheckedParameter<Word32T>( \
323 using LazyNode = std::function<TNode<T>()>;
338 TNode<IntPtrT> ParameterToIntPtr(TNode<Smi> value) { return SmiUntag(value); }
339 TNode<IntPtrT> ParameterToIntPtr(TNode<IntPtrT> value) { return value; }
340 TNode<IntPtrT> ParameterToIntPtr(TNode<UintPtrT> value) {
350 TNode<Smi> ParameterToTagged(TNode<Smi> value) { return value; }
352 TNode<Smi> ParameterToTagged(TNode<IntPtrT> value) { return SmiTag(value); }
355 TNode<TIndex> TaggedToParameter(TNode<Smi> value);
357 bool ToParameterConstant(TNode<Smi> node, intptr_t* out) {
364 bool ToParameterConstant(TNode<IntPtrT> node, intptr_t* out) {
374 TNode<Smi> BIntToSmi(TNode<BInt> source) { return source; }
375 TNode<IntPtrT> BIntToIntPtr(TNode<BInt> source) {
378 TNode<BInt> SmiToBInt(TNode<Smi> source) { return source; }
379 TNode<BInt> IntPtrToBInt(TNode<IntPtrT> source) {
383 TNode<Smi> BIntToSmi(TNode<BInt> source) { return SmiFromIntPtr(source); }
384 TNode<IntPtrT> BIntToIntPtr(TNode<BInt> source) { return source; }
385 TNode<BInt> SmiToBInt(TNode<Smi> source) { return SmiToIntPtr(source); }
386 TNode<BInt> IntPtrToBInt(TNode<IntPtrT> source) { return source; }
391 TNode<IntPtrT> TaggedIndexToIntPtr(TNode<TaggedIndex> value);
392 TNode<TaggedIndex> IntPtrToTaggedIndex(TNode<IntPtrT> value);
394 TNode<Smi> TaggedIndexToSmi(TNode<TaggedIndex> value);
395 TNode<TaggedIndex> SmiToTaggedIndex(TNode<Smi> value);
400 TNode<Smi> NormalizeSmiIndex(TNode<Smi> smi_index);
402 TNode<Smi> TaggedToSmi(TNode<Object> value, Label* fail) {
407 TNode<Smi> TaggedToPositiveSmi(TNode<Object> value, Label* fail) {
412 TNode<String> TaggedToDirectString(TNode<Object> value, Label* fail);
414 TNode<HeapObject> TaggedToHeapObject(TNode<Object> value, Label* fail) {
419 TNode<Uint16T> Uint16Constant(uint16_t t) {
423 TNode<JSDataView> HeapObjectToJSDataView(TNode<HeapObject> heap_object,
429 TNode<JSProxy> HeapObjectToJSProxy(TNode<HeapObject> heap_object,
435 TNode<JSStringIterator> HeapObjectToJSStringIterator(
436 TNode<HeapObject> heap_object, Label* fail) {
441 TNode<JSReceiver> HeapObjectToCallable(TNode<HeapObject> heap_object,
447 TNode<String> HeapObjectToString(TNode<HeapObject> heap_object, Label* fail) {
452 TNode<JSReceiver> HeapObjectToConstructor(TNode<HeapObject> heap_object,
458 TNode<JSFunction> HeapObjectToJSFunctionWithPrototypeSlot(
459 TNode<HeapObject> heap_object, Label* fail) {
465 TNode<T> RunLazy(LazyNode<T> lazy) {
470 TNode<Smi> OpName(TNode<Smi> a, TNode<Smi> b) { return SmiOpName(a, b); } \
471 TNode<IntPtrT> OpName(TNode<IntPtrT> a, TNode<IntPtrT> b) { \
474 TNode<UintPtrT> OpName(TNode<UintPtrT> a, TNode<UintPtrT> b) { \
477 TNode<RawPtrT> OpName(TNode<RawPtrT> a, TNode<RawPtrT> b) { \
487 TNode<BoolT> OpName(TNode<Smi> a, TNode<Smi> b) { return SmiOpName(a, b); } \
488 TNode<BoolT> OpName(TNode<IntPtrT> a, TNode<IntPtrT> b) { \
491 TNode<BoolT> OpName(TNode<UintPtrT> a, TNode<UintPtrT> b) { \
494 TNode<BoolT> OpName(TNode<RawPtrT> a, TNode<RawPtrT> b) { \
515 TNode<BoolT> TaggedEqual(TNode<AnyTaggedT> a, TNode<AnyTaggedT> b) {
524 TNode<BoolT> TaggedNotEqual(TNode<AnyTaggedT> a, TNode<AnyTaggedT> b) {
528 TNode<Smi> NoContextConstant();
531 TNode<std::remove_pointer<std::remove_reference<decltype( \
538 TNode<std::remove_pointer<std::remove_reference<decltype( \
545 TNode<BoolT> Is##name(TNode<Object> value); \
546 TNode<BoolT> IsNot##name(TNode<Object> value);
550 TNode<BInt> BIntConstant(int value);
553 TNode<TIndex> IntPtrOrSmiConstant(int value);
555 bool TryGetIntPtrOrSmiConstantValue(TNode<Smi> maybe_constant, int* value);
556 bool TryGetIntPtrOrSmiConstantValue(TNode<IntPtrT> maybe_constant,
559 TNode<IntPtrT> PopulationCountFallback(TNode<UintPtrT> value);
560 TNode<Int64T> PopulationCount64(TNode<Word64T> value);
561 TNode<Int32T> PopulationCount32(TNode<Word32T> value);
562 TNode<Int64T> CountTrailingZeros64(TNode<Word64T> value);
563 TNode<Int32T> CountTrailingZeros32(TNode<Word32T> value);
564 TNode<Int64T> CountLeadingZeros64(TNode<Word64T> value);
565 TNode<Int32T> CountLeadingZeros32(TNode<Word32T> value);
568 TNode<IntPtrT> IntPtrRoundUpToPowerOfTwo32(TNode<IntPtrT> value);
570 TNode<IntPtrT> IntPtrMax(TNode<IntPtrT> left, TNode<IntPtrT> right);
572 TNode<IntPtrT> IntPtrMin(TNode<IntPtrT> left, TNode<IntPtrT> right);
573 TNode<UintPtrT> UintPtrMin(TNode<UintPtrT> left, TNode<UintPtrT> right);
576 TNode<Float64T> Float64Ceil(TNode<Float64T> x);
577 TNode<Float64T> Float64Floor(TNode<Float64T> x);
578 TNode<Float64T> Float64Round(TNode<Float64T> x);
579 TNode<Float64T> Float64RoundToEven(TNode<Float64T> x);
580 TNode<Float64T> Float64Trunc(TNode<Float64T> x);
582 TNode<Number> NumberMax(TNode<Number> left, TNode<Number> right);
584 TNode<Number> NumberMin(TNode<Number> left, TNode<Number> right);
587 TNode<BoolT> IsValidPositiveSmi(TNode<IntPtrT> value);
590 TNode<Smi> SmiTag(TNode<IntPtrT> value);
592 TNode<IntPtrT> SmiUntag(TNode<Smi> value);
595 TNode<Float64T> SmiToFloat64(TNode<Smi> value);
596 TNode<Smi> SmiFromIntPtr(TNode<IntPtrT> value) { return SmiTag(value); }
597 TNode<Smi> SmiFromInt32(TNode<Int32T> value);
598 TNode<Smi> SmiFromUint32(TNode<Uint32T> value);
599 TNode<IntPtrT> SmiToIntPtr(TNode<Smi> value) { return SmiUntag(value); }
600 TNode<Int32T> SmiToInt32(TNode<Smi> value);
604 TNode<Smi> SmiOpName(TNode<Smi> a, TNode<Smi> b) { \
623 TNode<IntPtrT> TryIntPtrAdd(TNode<IntPtrT> a, TNode<IntPtrT> b,
625 TNode<IntPtrT> TryIntPtrSub(TNode<IntPtrT> a, TNode<IntPtrT> b,
627 TNode<Int32T> TryInt32Mul(TNode<Int32T> a, TNode<Int32T> b,
629 TNode<Smi> TrySmiAdd(TNode<Smi> a, TNode<Smi> b, Label* if_overflow);
630 TNode<Smi> TrySmiSub(TNode<Smi> a, TNode<Smi> b, Label* if_overflow);
631 TNode<Smi> TrySmiAbs(TNode<Smi> a, Label* if_overflow);
633 TNode<Smi> SmiShl(TNode<Smi> a, int shift) {
634 TNode<Smi> result = BitcastWordToTaggedSigned(
644 TNode<Smi> SmiShr(TNode<Smi> a, int shift) {
645 TNode<Smi> result;
668 TNode<Smi> SmiSar(TNode<Smi> a, int shift) {
688 TNode<Smi> WordOrSmiShr(TNode<Smi> a, int shift) { return SmiShr(a, shift); }
690 TNode<IntPtrT> WordOrSmiShr(TNode<IntPtrT> a, int shift) {
695 TNode<BoolT> SmiOpName(TNode<Smi> a, TNode<Smi> b) { \
720 TNode<Smi> SmiMax(TNode<Smi> a, TNode<Smi> b);
721 TNode<Smi> SmiMin(TNode<Smi> a, TNode<Smi> b);
723 TNode<Number> SmiMod(TNode<Smi> a, TNode<Smi> b);
725 TNode<Number> SmiMul(TNode<Smi> a, TNode<Smi> b);
728 TNode<Smi> TrySmiDiv(TNode<Smi> dividend, TNode<Smi> divisor, Label* bailout);
735 TNode<Smi> SmiLexicographicCompare(TNode<Smi> x, TNode<Smi> y);
739 TNode<BoolT> BIntOpName(TNode<BInt> a, TNode<BInt> b) { \
744 TNode<BoolT> BIntOpName(TNode<BInt> a, TNode<BInt> b) { \
763 TNode<Number> NumberInc(TNode<Number> value);
764 TNode<Number> NumberDec(TNode<Number> value);
765 TNode<Number> NumberAdd(TNode<Number> a, TNode<Number> b);
766 TNode<Number> NumberSub(TNode<Number> a, TNode<Number> b);
767 void GotoIfNotNumber(TNode<Object> value, Label* is_not_number);
768 void GotoIfNumber(TNode<Object> value, Label* is_number);
769 TNode<Number> SmiToNumber(TNode<Smi> v) { return v; }
771 TNode<Number> BitwiseOp(TNode<Word32T> left32, TNode<Word32T> right32,
773 TNode<Number> BitwiseSmiOp(TNode<Smi> left32, TNode<Smi> right32,
777 TNode<HeapObject> AllocateInNewSpace(
778 TNode<IntPtrT> size, AllocationFlags flags = AllocationFlag::kNone);
779 TNode<HeapObject> AllocateInNewSpace(
781 TNode<HeapObject> Allocate(TNode<IntPtrT> size,
784 TNode<HeapObject> Allocate(int size,
787 TNode<BoolT> IsRegularHeapObjectSize(TNode<IntPtrT> size);
791 using NodeGenerator = std::function<TNode<T>()>;
792 using ExtraNode = std::pair<TNode<Object>, const char*>;
800 void Dcheck(TNode<Word32T> condition_node, const char* message,
809 void Check(TNode<Word32T> condition_node, const char* message,
816 void FastCheck(TNode<BoolT> condition);
818 TNode<BoolT> IsCodeTMap(TNode<Map> map) {
822 TNode<BoolT> IsCodeT(TNode<HeapObject> object) {
828 TNode<Code> FromCodeT(TNode<CodeT> code) {
836 TNode<Object> o = BitcastWordToTagged(Load<RawPtrT>(
844 TNode<CodeDataContainer> CodeDataContainerFromCodeT(TNode<CodeT> code) {
853 TNode<CodeT> ToCodeT(TNode<Code> code) {
862 TNode<CodeT> ToCodeT(TNode<Code> code,
863 TNode<CodeDataContainer> code_data_container) {
871 TNode<RawPtrT> GetCodeEntry(TNode<CodeT> code);
877 TNode<Object> Call(TNode<Context> context, TNode<Object> callable,
878 TNode<JSReceiver> receiver, TArgs... args) {
884 TNode<Object> Call(TNode<Context> context, TNode<Object> callable,
885 TNode<Object> receiver, TArgs... args) {
895 TNode<Object> CallApiCallback(TNode<Object> context, TNode<RawPtrT> callback,
896 TNode<IntPtrT> argc, TNode<Object> data,
897 TNode<Object> holder, TNode<Object> receiver);
899 TNode<Object> CallApiCallback(TNode<Object> context, TNode<RawPtrT> callback,
900 TNode<IntPtrT> argc, TNode<Object> data,
901 TNode<Object> holder, TNode<Object> receiver,
902 TNode<Object> value);
904 TNode<Object> CallRuntimeNewArray(TNode<Context> context,
905 TNode<Object> receiver,
906 TNode<Object> length,
907 TNode<Object> new_target,
908 TNode<Object> allocation_site);
910 void TailCallRuntimeNewArray(TNode<Context> context, TNode<Object> receiver,
911 TNode<Object> length, TNode<Object> new_target,
912 TNode<Object> allocation_site);
915 TNode<JSReceiver> ConstructWithTarget(TNode<Context> context,
916 TNode<JSReceiver> target,
917 TNode<JSReceiver> new_target,
921 implicit_cast<TNode<Object>>(args)...));
924 TNode<JSReceiver> Construct(TNode<Context> context,
925 TNode<JSReceiver> new_target, TArgs... args) {
930 TNode<T> Select(TNode<BoolT> condition, const NodeGenerator<T>& true_body,
952 TNode<A> SelectConstant(TNode<BoolT> condition, TNode<A> true_value,
953 TNode<A> false_value) {
958 TNode<Int32T> SelectInt32Constant(TNode<BoolT> condition, int true_value,
960 TNode<IntPtrT> SelectIntPtrConstant(TNode<BoolT> condition, int true_value,
962 TNode<Oddball> SelectBooleanConstant(TNode<BoolT> condition);
963 TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, Smi true_value,
965 TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, int true_value,
969 TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, Smi true_value,
973 TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, int true_value,
979 TNode<String> SingleCharacterStringConstant(char const* single_char) {
986 TNode<Int32T> TruncateWordToInt32(TNode<WordT> value);
987 TNode<Int32T> TruncateIntPtrToInt32(TNode<IntPtrT> value);
990 TNode<BoolT> TaggedIsSmi(TNode<MaybeObject> a);
991 TNode<BoolT> TaggedIsNotSmi(TNode<MaybeObject> a);
994 TNode<BoolT> TaggedIsPositiveSmi(TNode<Object> a);
996 TNode<BoolT> WordIsAligned(TNode<WordT> word, size_t alignment);
997 TNode<BoolT> WordIsPowerOfTwo(TNode<IntPtrT> value);
1001 TNode<BoolT> IsInRange(TNode<Word32T> value, U lower_limit, U higher_limit) {
1008 TNode<BoolT> IsInRange(TNode<WordT> value, intptr_t lower_limit,
1022 TNode<T>*... phis) {
1026 void BranchIfSmiEqual(TNode<Smi> a, TNode<Smi> b, Label* if_true,
1031 void BranchIfSmiLessThan(TNode<Smi> a, TNode<Smi> b, Label* if_true,
1036 void BranchIfSmiLessThanOrEqual(TNode<Smi> a, TNode<Smi> b, Label* if_true,
1041 void BranchIfFloat64IsNaN(TNode<Float64T> value, Label* if_true,
1048 void BranchIfToBooleanIsTrue(TNode<Object> value, Label* if_true,
1053 void BranchIfToBooleanIsFalse(TNode<Object> value, Label* if_false,
1058 void BranchIfJSReceiver(TNode<Object> object, Label* if_true,
1073 TNode<RawPtrT> LoadSandboxedPointerFromObject(TNode<HeapObject> object,
1078 TNode<RawPtrT> LoadSandboxedPointerFromObject(TNode<HeapObject> object,
1079 TNode<IntPtrT> offset);
1082 void StoreSandboxedPointerToObject(TNode<HeapObject> object, int offset,
1083 TNode<RawPtrT> pointer) {
1087 void StoreSandboxedPointerToObject(TNode<HeapObject> object,
1088 TNode<IntPtrT> offset,
1089 TNode<RawPtrT> pointer);
1091 TNode<RawPtrT> EmptyBackingStoreBufferConstant();
1098 TNode<ExternalPointerT> ChangeIndexToExternalPointer(TNode<Uint32T> index);
1099 TNode<Uint32T> ChangeExternalPointerToIndex(TNode<ExternalPointerT> pointer);
1103 void InitializeExternalPointerField(TNode<HeapObject> object, int offset) {
1106 void InitializeExternalPointerField(TNode<HeapObject> object,
1107 TNode<IntPtrT> offset);
1110 void InitializeExternalPointerField(TNode<HeapObject> object, int offset,
1111 TNode<RawPtrT> pointer,
1117 void InitializeExternalPointerField(TNode<HeapObject> object,
1118 TNode<IntPtrT> offset,
1119 TNode<RawPtrT> pointer,
1126 TNode<RawPtrT> LoadExternalPointerFromObject(TNode<HeapObject> object,
1132 TNode<RawPtrT> LoadExternalPointerFromObject(TNode<HeapObject> object,
1133 TNode<IntPtrT> offset,
1137 void StoreExternalPointerToObject(TNode<HeapObject> object, int offset,
1138 TNode<RawPtrT> pointer,
1143 void StoreExternalPointerToObject(TNode<HeapObject> object,
1144 TNode<IntPtrT> offset,
1145 TNode<RawPtrT> pointer,
1148 TNode<RawPtrT> LoadForeignForeignAddressPtr(TNode<Foreign> object) {
1153 TNode<RawPtrT> LoadExternalStringResourcePtr(TNode<ExternalString> object) {
1158 TNode<RawPtrT> LoadExternalStringResourceDataPtr(
1159 TNode<ExternalString> object) {
1171 TNode<RawPtrT> LoadJSTypedArrayExternalPointerPtr(
1172 TNode<JSTypedArray> holder) {
1177 void StoreJSTypedArrayExternalPointerPtr(TNode<JSTypedArray> holder,
1178 TNode<RawPtrT> value) {
1184 TNode<Object> LoadFromParentFrame(int offset);
1187 TNode<Object> LoadBufferObject(TNode<RawPtrT> buffer, int offset) {
1191 TNode<T> LoadBufferData(TNode<RawPtrT> buffer, int offset) {
1195 TNode<RawPtrT> LoadBufferPointer(TNode<RawPtrT> buffer, int offset) {
1198 TNode<Smi> LoadBufferSmi(TNode<RawPtrT> buffer, int offset) {
1201 TNode<IntPtrT> LoadBufferIntptr(TNode<RawPtrT> buffer, int offset) {
1204 TNode<Uint8T> LoadUint8Ptr(TNode<RawPtrT> ptr, TNode<IntPtrT> offset);
1208 std::is_convertible<TNode<T>, TNode<Object>>::value &&
1211 TNode<T> LoadObjectField(TNode<HeapObject> object, int offset) {
1219 std::is_convertible<TNode<T>, TNode<Object>>::value &&
1222 TNode<T> LoadObjectField(TNode<HeapObject> object, int offset) {
1227 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value,
1229 TNode<T> LoadObjectField(TNode<HeapObject> object, int offset) {
1234 TNode<Object> LoadObjectField(TNode<HeapObject> object, int offset) {
1239 TNode<Object> LoadObjectField(TNode<HeapObject> object,
1240 TNode<IntPtrT> offset) {
1246 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value,
1248 TNode<T> LoadObjectField(TNode<HeapObject> object, TNode<IntPtrT> offset) {
1254 TNode<IntPtrT> LoadAndUntagObjectField(TNode<HeapObject> object, int offset);
1256 TNode<Int32T> LoadAndUntagToWord32ObjectField(TNode<HeapObject> object,
1259 TNode<MaybeObject> LoadMaybeWeakObjectField(TNode<HeapObject> object,
1264 TNode<Object> LoadConstructorOrBackPointer(TNode<Map> map) {
1269 TNode<Simd128T> LoadSimd128(TNode<IntPtrT> ptr) {
1279 // overloads for TNode<UntaggedT>-convertible types below).
1283 TNode<Object> object;
1284 TNode<IntPtrT> offset;
1286 std::tuple<TNode<Object>, TNode<IntPtrT>> Flatten() const {
1292 std::is_convertible<TNode<T>, TNode<Object>>::value,
1294 TNode<T> LoadReference(Reference reference) {
1296 TNode<Map> map = LoadMap(CAST(reference.object));
1301 TNode<IntPtrT> offset =
1309 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value ||
1312 TNode<T> LoadReference(Reference reference) {
1314 TNode<IntPtrT> offset =
1320 std::is_convertible<TNode<T>, TNode<Object>>::value ||
1323 void StoreReference(Reference reference, TNode<T> value) {
1335 TNode<IntPtrT> offset =
1341 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value,
1343 void StoreReference(Reference reference, TNode<T> value) {
1345 TNode<IntPtrT> offset =
1351 TNode<RawPtrT> GCUnsafeReferenceToRawPtr(TNode<Object> object,
1352 TNode<IntPtrT> offset) {
1359 TNode<Float64T> LoadHeapNumberValue(TNode<HeapObject> object);
1361 TNode<Map> LoadMap(TNode<HeapObject> object);
1363 TNode<Uint16T> LoadInstanceType(TNode<HeapObject> object);
1365 TNode<BoolT> HasInstanceType(TNode<HeapObject> object, InstanceType type);
1366 TNode<BoolT> DoesntHaveInstanceType(TNode<HeapObject> object,
1368 TNode<BoolT> TaggedDoesntHaveInstanceType(TNode<HeapObject> any_tagged,
1371 TNode<Word32T> IsStringWrapperElementsKind(TNode<Map> map);
1372 void GotoIfMapHasSlowProperties(TNode<Map> map, Label* if_slow);
1375 TNode<HeapObject> LoadSlowProperties(TNode<JSReceiver> object);
1376 TNode<HeapObject> LoadFastProperties(TNode<JSReceiver> object);
1378 TNode<FixedArrayBase> LoadElements(TNode<JSObject> object) {
1382 TNode<Object> LoadJSArgumentsObjectLength(TNode<Context> context,
1383 TNode<JSArgumentsObject> array);
1385 TNode<Smi> LoadFastJSArrayLength(TNode<JSArray> array);
1387 TNode<Smi> LoadFixedArrayBaseLength(TNode<FixedArrayBase> array);
1389 TNode<IntPtrT> LoadAndUntagFixedArrayBaseLength(TNode<FixedArrayBase> array);
1391 TNode<Smi> LoadWeakFixedArrayLength(TNode<WeakFixedArray> array);
1392 TNode<IntPtrT> LoadAndUntagWeakFixedArrayLength(TNode<WeakFixedArray> array);
1394 TNode<Int32T> LoadNumberOfDescriptors(TNode<DescriptorArray> array);
1396 TNode<Int32T> LoadNumberOfOwnDescriptors(TNode<Map> map);
1398 TNode<Int32T> LoadMapBitField(TNode<Map> map);
1400 TNode<Int32T> LoadMapBitField2(TNode<Map> map);
1402 TNode<Uint32T> LoadMapBitField3(TNode<Map> map);
1404 TNode<Uint16T> LoadMapInstanceType(TNode<Map> map);
1406 TNode<Int32T> LoadMapElementsKind(TNode<Map> map);
1407 TNode<Int32T> LoadElementsKind(TNode<HeapObject> object);
1409 TNode<DescriptorArray> LoadMapDescriptors(TNode<Map> map);
1411 TNode<HeapObject> LoadMapPrototype(TNode<Map> map);
1413 TNode<IntPtrT> LoadMapInstanceSizeInWords(TNode<Map> map);
1415 TNode<IntPtrT> LoadMapInobjectPropertiesStartInWords(TNode<Map> map);
1417 TNode<IntPtrT> LoadMapConstructorFunctionIndex(TNode<Map> map);
1419 TNode<Object> LoadMapConstructor(TNode<Map> map);
1421 TNode<WordT> LoadMapEnumLength(TNode<Map> map);
1423 TNode<Object> LoadMapBackPointer(TNode<Map> map);
1425 TNode<Uint32T> EnsureOnlyHasSimpleProperties(TNode<Map> map,
1426 TNode<Int32T> instance_type,
1429 TNode<IntPtrT> LoadJSReceiverIdentityHash(TNode<JSReceiver> receiver,
1434 void InitializePropertyArrayLength(TNode<PropertyArray> property_array,
1435 TNode<IntPtrT> length);
1438 TNode<BoolT> IsDictionaryMap(TNode<Map> map);
1443 TNode<Uint32T> LoadNameHash(TNode<Name> name,
1445 TNode<Uint32T> LoadNameHashAssumeComputed(TNode<Name> name);
1448 TNode<Smi> LoadStringLengthAsSmi(TNode<String> string);
1450 TNode<IntPtrT> LoadStringLengthAsWord(TNode<String> string);
1452 TNode<Uint32T> LoadStringLengthAsWord32(TNode<String> string);
1454 TNode<Object> LoadJSPrimitiveWrapperValue(TNode<JSPrimitiveWrapper> object);
1464 void DispatchMaybeObject(TNode<MaybeObject> maybe_object, Label* if_smi,
1468 TNode<BoolT> IsStrong(TNode<MaybeObject> value);
1469 TNode<HeapObject> GetHeapObjectIfStrong(TNode<MaybeObject> value,
1472 TNode<BoolT> IsWeakOrCleared(TNode<MaybeObject> value);
1473 TNode<BoolT> IsCleared(TNode<MaybeObject> value);
1474 TNode<BoolT> IsNotCleared(TNode<MaybeObject> value) {
1479 TNode<HeapObject> GetHeapObjectAssumeWeak(TNode<MaybeObject> value);
1481 TNode<HeapObject> GetHeapObjectAssumeWeak(TNode<MaybeObject> value,
1486 TNode<BoolT> IsWeakReferenceTo(TNode<MaybeObject> maybe_object,
1487 TNode<HeapObject> heap_object);
1491 TNode<BoolT> IsWeakReferenceToObject(TNode<MaybeObject> maybe_object,
1492 TNode<Object> object);
1494 TNode<MaybeObject> MakeWeak(TNode<HeapObject> value);
1496 void FixedArrayBoundsCheck(TNode<FixedArrayBase> array, TNode<Smi> index,
1499 void FixedArrayBoundsCheck(TNode<FixedArrayBase> array, TNode<IntPtrT> index,
1502 void FixedArrayBoundsCheck(TNode<FixedArrayBase> array, TNode<UintPtrT> index,
1510 TNode<IntPtrT> LoadArrayLength(TNode<Array> array);
1515 TNode<TValue> LoadArrayElement(TNode<Array> array, int array_header_size,
1516 TNode<TIndex> index,
1520 TNode<Object> LoadFixedArrayElement(
1521 TNode<FixedArray> object, TNode<TIndex> index, int additional_offset = 0,
1526 TNode<Object> UnsafeLoadFixedArrayElement(TNode<FixedArray> object,
1527 TNode<IntPtrT> index,
1533 TNode<Object> LoadFixedArrayElement(TNode<FixedArray> object, int index,
1540 TNode<Object> UnsafeLoadFixedArrayElement(TNode<FixedArray> object, int index,
1546 TNode<Object> LoadPropertyArrayElement(TNode<PropertyArray> object,
1547 TNode<IntPtrT> index);
1548 TNode<IntPtrT> LoadPropertyArrayLength(TNode<PropertyArray> object);
1554 TNode<Int32T> LoadAndUntagToWord32ArrayElement(TNode<Array> array,
1556 TNode<IntPtrT> index,
1560 TNode<Int32T> LoadAndUntagToWord32FixedArrayElement(
1561 TNode<FixedArray> object, TNode<IntPtrT> index,
1565 TNode<MaybeObject> LoadWeakFixedArrayElement(TNode<WeakFixedArray> object,
1566 TNode<IntPtrT> index,
1570 TNode<Float64T> LoadFixedDoubleArrayElement(
1571 TNode<FixedDoubleArray> object, TNode<IntPtrT> index,
1581 TNode<Object> LoadFixedArrayBaseElementAsTagged(
1582 TNode<FixedArrayBase> elements, TNode<IntPtrT> index,
1583 TNode<Int32T> elements_kind, Label* if_accessor, Label* if_hole);
1587 TNode<MaybeObject> LoadFeedbackVectorSlot(
1588 TNode<FeedbackVector> feedback_vector, TNode<TIndex> slot,
1591 TNode<IntPtrT> LoadFeedbackVectorLength(TNode<FeedbackVector>);
1592 TNode<Float64T> LoadDoubleWithHoleCheck(TNode<FixedDoubleArray> array,
1593 TNode<IntPtrT> index,
1596 TNode<BoolT> IsDoubleHole(TNode<Object> base, TNode<IntPtrT> offset);
1600 TNode<Float64T> LoadDoubleWithHoleCheck(
1601 TNode<Object> base, TNode<IntPtrT> offset, Label* if_hole,
1603 TNode<Numeric> LoadFixedTypedArrayElementAsTagged(TNode<RawPtrT> data_pointer,
1604 TNode<UintPtrT> index,
1606 TNode<Numeric> LoadFixedTypedArrayElementAsTagged(
1607 TNode<RawPtrT> data_pointer, TNode<UintPtrT> index,
1608 TNode<Int32T> elements_kind);
1610 TNode<BigInt> LoadFixedBigInt64ArrayElementAsTagged(
1611 TNode<RawPtrT> data_pointer, TNode<IntPtrT> offset);
1612 TNode<BigInt> LoadFixedBigUint64ArrayElementAsTagged(
1613 TNode<RawPtrT> data_pointer, TNode<IntPtrT> offset);
1615 TNode<BigInt> BigIntFromInt64(TNode<IntPtrT> value);
1616 TNode<BigInt> BigIntFromUint64(TNode<UintPtrT> value);
1618 TNode<BigInt> BigIntFromInt32Pair(TNode<IntPtrT> low, TNode<IntPtrT> high);
1619 TNode<BigInt> BigIntFromUint32Pair(TNode<UintPtrT> low, TNode<UintPtrT> high);
1622 TNode<ScopeInfo> LoadScopeInfo(TNode<Context> context);
1623 TNode<BoolT> LoadScopeInfoHasExtensionField(TNode<ScopeInfo> scope_info);
1626 void StoreContextElementNoWriteBarrier(TNode<Context> context, int slot_index,
1627 TNode<Object> value);
1628 TNode<NativeContext> LoadNativeContext(TNode<Context> context);
1630 TNode<Context> LoadModuleContext(TNode<Context> context);
1632 TNode<Object> GetImportMetaObject(TNode<Context> context);
1634 void GotoIfContextElementEqual(TNode<Object> value,
1635 TNode<NativeContext> native_context,
1642 TNode<Map> LoadObjectFunctionInitialMap(TNode<NativeContext> native_context);
1643 TNode<Map> LoadSlowObjectWithNullPrototypeMap(
1644 TNode<NativeContext> native_context);
1646 TNode<Map> LoadJSArrayElementsMap(ElementsKind kind,
1647 TNode<NativeContext> native_context);
1648 TNode<Map> LoadJSArrayElementsMap(TNode<Int32T> kind,
1649 TNode<NativeContext> native_context);
1651 TNode<BoolT> IsJSFunctionWithPrototypeSlot(TNode<HeapObject> object);
1652 TNode<BoolT> IsGeneratorFunction(TNode<JSFunction> function);
1653 void BranchIfHasPrototypeProperty(TNode<JSFunction> function,
1654 TNode<Int32T> function_map_bit_field,
1656 void GotoIfPrototypeRequiresRuntimeLookup(TNode<JSFunction> function,
1657 TNode<Map> map, Label* runtime);
1659 TNode<HeapObject> LoadJSFunctionPrototype(TNode<JSFunction> function,
1662 TNode<BytecodeArray> LoadSharedFunctionInfoBytecodeArray(
1663 TNode<SharedFunctionInfo> shared);
1665 void StoreObjectByteNoWriteBarrier(TNode<HeapObject> object, int offset,
1666 TNode<Word32T> value);
1669 void StoreHeapNumberValue(TNode<HeapNumber> object, TNode<Float64T> value);
1672 void StoreObjectField(TNode<HeapObject> object, int offset, TNode<Smi> value);
1673 void StoreObjectField(TNode<HeapObject> object, TNode<IntPtrT> offset,
1674 TNode<Smi> value);
1675 void StoreObjectField(TNode<HeapObject> object, int offset,
1676 TNode<Object> value);
1677 void StoreObjectField(TNode<HeapObject> object, TNode<IntPtrT> offset,
1678 TNode<Object> value);
1680 void StoreObjectFieldNoWriteBarrier(TNode<HeapObject> object,
1681 TNode<IntPtrT> offset, TNode<T> value) {
1691 void StoreObjectFieldNoWriteBarrier(TNode<HeapObject> object, int offset,
1692 TNode<T> value) {
1702 void UnsafeStoreObjectFieldNoWriteBarrier(TNode<HeapObject> object,
1703 int offset, TNode<Object> value);
1706 void StoreMap(TNode<HeapObject> object, TNode<Map> map);
1707 void StoreMapNoWriteBarrier(TNode<HeapObject> object,
1709 void StoreMapNoWriteBarrier(TNode<HeapObject> object, TNode<Map> map);
1710 void StoreObjectFieldRoot(TNode<HeapObject> object, int offset,
1715 TNode<FixedArray> object, int index, TNode<Object> value,
1722 void StoreFixedArrayElement(TNode<FixedArray> object, int index,
1723 TNode<Smi> value,
1726 TNode<Object>{value},
1732 TNode<FixedArray> array, TNode<TIndex> index, TNode<Object> value,
1749 void StoreFixedArrayElement(TNode<FixedArray> array, TNode<TIndex> index,
1750 TNode<Smi> value, int additional_offset = 0) {
1754 StoreFixedArrayElement(array, index, TNode<Object>{value},
1761 TNode<FixedArray> object, int index, TNode<Object> value,
1767 void UnsafeStoreFixedArrayElement(TNode<FixedArray> object, int index,
1768 TNode<Smi> value) {
1775 TNode<FixedArray> array, TNode<IntPtrT> index, TNode<Object> value,
1782 void UnsafeStoreFixedArrayElement(TNode<FixedArray> array,
1783 TNode<IntPtrT> index, TNode<Smi> value,
1790 void StorePropertyArrayElement(TNode<PropertyArray> array,
1791 TNode<IntPtrT> index, TNode<Object> value) {
1798 TNode<FixedDoubleArray> object, TNode<TIndex> index,
1799 TNode<Float64T> value, CheckBounds check_bounds = CheckBounds::kAlways);
1801 void StoreDoubleHole(TNode<HeapObject> object, TNode<IntPtrT> offset);
1802 void StoreFixedDoubleArrayHole(TNode<FixedDoubleArray> array,
1803 TNode<IntPtrT> index);
1805 TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
1806 TNode<AnyTaggedT> value,
1810 void StoreJSSharedStructInObjectField(TNode<HeapObject> object,
1811 TNode<IntPtrT> offset,
1812 TNode<Object> value);
1814 void StoreJSSharedStructPropertyArrayElement(TNode<PropertyArray> array,
1815 TNode<IntPtrT> index,
1816 TNode<Object> value) {
1831 TNode<Int32T> EnsureArrayPushable(TNode<Context> context, TNode<Map> map,
1835 TNode<FixedArrayBase> elements, TNode<BInt> index,
1836 TNode<Object> value);
1838 TNode<Smi> BuildAppendJSArray(ElementsKind kind, TNode<JSArray> array,
1842 void BuildAppendJSArray(ElementsKind kind, TNode<JSArray> array,
1843 TNode<Object> value, Label* bailout);
1845 void StoreFieldsNoWriteBarrier(TNode<IntPtrT> start_address,
1846 TNode<IntPtrT> end_address,
1847 TNode<Object> value);
1850 void MakeFixedArrayCOW(TNode<FixedArray> array);
1852 TNode<Cell> AllocateCellWithValue(
1853 TNode<Object> value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
1854 TNode<Cell> AllocateSmiCell(int value = 0) {
1858 TNode<Object> LoadCellValue(TNode<Cell> cell);
1860 void StoreCellValue(TNode<Cell> cell, TNode<Object> value,
1864 TNode<HeapNumber> AllocateHeapNumber();
1866 TNode<HeapNumber> AllocateHeapNumberWithValue(TNode<Float64T> value);
1867 TNode<HeapNumber> AllocateHeapNumberWithValue(double value) {
1873 TNode<BigInt> AllocateBigInt(TNode<IntPtrT> length);
1875 TNode<BigInt> AllocateRawBigInt(TNode<IntPtrT> length);
1876 void StoreBigIntBitfield(TNode<BigInt> bigint, TNode<Word32T> bitfield);
1877 void StoreBigIntDigit(TNode<BigInt> bigint, intptr_t digit_index,
1878 TNode<UintPtrT> digit);
1879 void StoreBigIntDigit(TNode<BigInt> bigint, TNode<IntPtrT> digit_index,
1880 TNode<UintPtrT> digit);
1882 TNode<Word32T> LoadBigIntBitfield(TNode<BigInt> bigint);
1883 TNode<UintPtrT> LoadBigIntDigit(TNode<BigInt> bigint, intptr_t digit_index);
1884 TNode<UintPtrT> LoadBigIntDigit(TNode<BigInt> bigint,
1885 TNode<IntPtrT> digit_index);
1888 TNode<ByteArray> AllocateNonEmptyByteArray(TNode<UintPtrT> length,
1892 TNode<ByteArray> AllocateByteArray(
1893 TNode<UintPtrT> length, AllocationFlags flags = AllocationFlag::kNone);
1896 TNode<String> AllocateSeqOneByteString(
1901 TNode<String> AllocateSeqTwoByteString(
1908 TNode<String> AllocateSlicedOneByteString(TNode<Uint32T> length,
1909 TNode<String> parent,
1910 TNode<Smi> offset);
1913 TNode<String> AllocateSlicedTwoByteString(TNode<Uint32T> length,
1914 TNode<String> parent,
1915 TNode<Smi> offset);
1917 TNode<NameDictionary> AllocateNameDictionary(int at_least_space_for);
1918 TNode<NameDictionary> AllocateNameDictionary(
1919 TNode<IntPtrT> at_least_space_for,
1921 TNode<NameDictionary> AllocateNameDictionaryWithCapacity(
1922 TNode<IntPtrT> capacity, AllocationFlags = AllocationFlag::kNone);
1923 TNode<NameDictionary> CopyNameDictionary(TNode<NameDictionary> dictionary,
1926 TNode<OrderedHashSet> AllocateOrderedHashSet();
1928 TNode<OrderedHashMap> AllocateOrderedHashMap();
1932 TNode<OrderedNameDictionary> AllocateOrderedNameDictionary(
1933 TNode<IntPtrT> capacity);
1934 TNode<OrderedNameDictionary> AllocateOrderedNameDictionary(int capacity);
1936 TNode<JSObject> AllocateJSObjectFromMap(
1937 TNode<Map> map,
1938 base::Optional<TNode<HeapObject>> properties = base::nullopt,
1939 base::Optional<TNode<FixedArray>> elements = base::nullopt,
1944 TNode<HeapObject> object, TNode<Map> map, TNode<IntPtrT> instance_size,
1945 base::Optional<TNode<HeapObject>> properties = base::nullopt,
1946 base::Optional<TNode<FixedArray>> elements = base::nullopt,
1949 void InitializeJSObjectBodyWithSlackTracking(TNode<HeapObject> object,
1950 TNode<Map> map,
1951 TNode<IntPtrT> instance_size);
1953 TNode<HeapObject> object, TNode<Map> map, TNode<IntPtrT> instance_size,
1956 TNode<BoolT> IsValidFastJSArrayCapacity(TNode<IntPtrT> capacity);
1961 std::pair<TNode<JSArray>, TNode<FixedArrayBase>>
1963 ElementsKind kind, TNode<Map> array_map, TNode<Smi> length,
1964 base::Optional<TNode<AllocationSite>> allocation_site,
1965 TNode<IntPtrT> capacity,
1970 TNode<JSArray> AllocateJSArray(
1971 ElementsKind kind, TNode<Map> array_map, TNode<IntPtrT> capacity,
1972 TNode<Smi> length, base::Optional<TNode<AllocationSite>> allocation_site,
1974 TNode<JSArray> AllocateJSArray(
1975 ElementsKind kind, TNode<Map> array_map, TNode<Smi> capacity,
1976 TNode<Smi> length, base::Optional<TNode<AllocationSite>> allocation_site,
1981 TNode<JSArray> AllocateJSArray(
1982 ElementsKind kind, TNode<Map> array_map, TNode<Smi> capacity,
1983 TNode<Smi> length,
1988 TNode<JSArray> AllocateJSArray(
1989 ElementsKind kind, TNode<Map> array_map, TNode<IntPtrT> capacity,
1990 TNode<Smi> length,
1997 TNode<JSArray> AllocateJSArray(
1998 TNode<Map> array_map, TNode<FixedArrayBase> elements, TNode<Smi> length,
1999 base::Optional<TNode<AllocationSite>> allocation_site = base::nullopt,
2013 TNode<JSArray> CloneFastJSArray(
2014 TNode<Context> context, TNode<JSArray> array,
2015 base::Optional<TNode<AllocationSite>> allocation_site = base::nullopt,
2018 TNode<JSArray> ExtractFastJSArray(TNode<Context> context,
2019 TNode<JSArray> array, TNode<BInt> begin,
2020 TNode<BInt> count);
2023 TNode<FixedArrayBase> AllocateFixedArray(
2024 ElementsKind kind, TNode<TIndex> capacity,
2026 base::Optional<TNode<Map>> fixed_array_map = base::nullopt);
2028 TNode<NativeContext> GetCreationContext(TNode<JSReceiver> receiver,
2030 TNode<NativeContext> GetFunctionRealm(TNode<Context> context,
2031 TNode<JSReceiver> receiver,
2033 TNode<Object> GetConstructor(TNode<Map> map);
2035 TNode<Map> GetInstanceTypeMap(InstanceType instance_type);
2037 TNode<FixedArray> AllocateUninitializedFixedArray(intptr_t capacity) {
2042 TNode<FixedArray> AllocateZeroedFixedArray(TNode<IntPtrT> capacity) {
2043 TNode<FixedArray> result = UncheckedCast<FixedArray>(
2050 TNode<FixedDoubleArray> AllocateZeroedFixedDoubleArray(
2051 TNode<IntPtrT> capacity) {
2052 TNode<FixedDoubleArray> result = UncheckedCast<FixedDoubleArray>(
2059 TNode<FixedArray> AllocateFixedArrayWithHoles(TNode<IntPtrT> capacity,
2061 TNode<FixedArray> result = UncheckedCast<FixedArray>(
2068 TNode<FixedDoubleArray> AllocateFixedDoubleArrayWithHoles(
2069 TNode<IntPtrT> capacity, AllocationFlags flags) {
2070 TNode<FixedDoubleArray> result = UncheckedCast<FixedDoubleArray>(
2077 TNode<PropertyArray> AllocatePropertyArray(TNode<IntPtrT> capacity);
2079 TNode<HeapObject> AllocateWasmArray(TNode<IntPtrT> size_in_bytes,
2083 TNode<JSObject> AllocateJSIteratorResult(TNode<Context> context,
2084 TNode<Object> value,
2085 TNode<Oddball> done);
2088 TNode<JSObject> AllocateJSIteratorResultForEntry(TNode<Context> context,
2089 TNode<Object> key,
2090 TNode<Object> value);
2092 TNode<JSReceiver> ArraySpeciesCreate(TNode<Context> context,
2093 TNode<Object> originalArray,
2094 TNode<Number> len);
2097 void FillFixedArrayWithValue(ElementsKind kind, TNode<FixedArrayBase> array,
2098 TNode<TIndex> from_index, TNode<TIndex> to_index,
2102 void FillFixedArrayWithSmiZero(TNode<FixedArray> array,
2103 TNode<IntPtrT> length);
2104 void FillFixedDoubleArrayWithZero(TNode<FixedDoubleArray> array,
2105 TNode<IntPtrT> length);
2107 void FillPropertyArrayWithUndefined(TNode<PropertyArray> array,
2108 TNode<IntPtrT> from_index,
2109 TNode<IntPtrT> to_index);
2115 void IncrementCallCount(TNode<FeedbackVector> feedback_vector,
2116 TNode<UintPtrT> slot_id);
2125 void CopyPropertyArrayValues(TNode<HeapObject> from_array,
2126 TNode<PropertyArray> to_array,
2127 TNode<IntPtrT> length,
2135 ElementsKind kind, TNode<FixedArrayBase> from_array,
2136 TNode<FixedArrayBase> to_array, TNode<TIndex> length,
2148 ElementsKind from_kind, TNode<FixedArrayBase> from_array,
2149 ElementsKind to_kind, TNode<FixedArrayBase> to_array,
2150 TNode<TIndex> element_count, TNode<TIndex> capacity,
2167 ElementsKind from_kind, TNode<FixedArrayBase> from_array,
2168 ElementsKind to_kind, TNode<FixedArrayBase> to_array,
2169 TNode<TIndex> first_element, TNode<TIndex> element_count,
2170 TNode<TIndex> capacity,
2175 void JumpIfPointersFromHereAreInteresting(TNode<Object> object,
2181 void MoveElements(ElementsKind kind, TNode<FixedArrayBase> elements,
2182 TNode<IntPtrT> dst_index, TNode<IntPtrT> src_index,
2183 TNode<IntPtrT> length);
2193 void CopyElements(ElementsKind kind, TNode<FixedArrayBase> dst_elements,
2194 TNode<IntPtrT> dst_index,
2195 TNode<FixedArrayBase> src_elements,
2196 TNode<IntPtrT> src_index, TNode<IntPtrT> length,
2199 TNode<FixedArray> HeapObjectToFixedArray(TNode<HeapObject> base,
2202 TNode<FixedDoubleArray> HeapObjectToFixedDoubleArray(TNode<HeapObject> base,
2215 TNode<Map> GetClassMapConstant() {
2217 return TNode<Map>();
2259 TNode<FixedArrayBase> ExtractFixedArray(
2260 TNode<FixedArrayBase> source, base::Optional<TNode<TIndex>> first,
2261 base::Optional<TNode<TIndex>> count = base::nullopt,
2262 base::Optional<TNode<TIndex>> capacity = base::nullopt,
2266 base::Optional<TNode<Int32T>> source_elements_kind = base::nullopt);
2294 TNode<FixedArray> ExtractToFixedArray(
2295 TNode<FixedArrayBase> source, TNode<TIndex> first, TNode<TIndex> count,
2296 TNode<TIndex> capacity, TNode<Map> source_map, ElementsKind from_kind,
2300 base::Optional<TNode<Int32T>> source_runtime_kind = base::nullopt);
2319 TNode<FixedArrayBase> ExtractFixedDoubleArrayFillingHoles(
2320 TNode<FixedArrayBase> source, TNode<TIndex> first, TNode<TIndex> count,
2321 TNode<TIndex> capacity, TNode<Map> source_map,
2336 TNode<FixedArrayBase> CloneFixedArray(
2337 TNode<FixedArrayBase> source,
2346 TNode<TResult> LoadElementAndPrepareForStore(TNode<FixedArrayBase> array,
2347 TNode<IntPtrT> offset,
2353 TNode<TIndex> CalculateNewElementsCapacity(TNode<TIndex> old_capacity);
2357 TNode<FixedArrayBase> TryGrowElementsCapacity(TNode<HeapObject> object,
2358 TNode<FixedArrayBase> elements,
2360 TNode<Smi> key, Label* bailout);
2366 TNode<FixedArrayBase> TryGrowElementsCapacity(TNode<HeapObject> object,
2367 TNode<FixedArrayBase> elements,
2369 TNode<TIndex> key,
2370 TNode<TIndex> capacity,
2375 TNode<FixedArrayBase> GrowElementsCapacity(
2376 TNode<HeapObject> object, TNode<FixedArrayBase> elements,
2377 ElementsKind from_kind, ElementsKind to_kind, TNode<TIndex> capacity,
2378 TNode<TIndex> new_capacity, Label* bailout);
2383 void PossiblyGrowElementsCapacity(ElementsKind kind, TNode<HeapObject> array,
2384 TNode<BInt> length,
2386 TNode<BInt> growth, Label* bailout);
2389 void InitializeAllocationMemento(TNode<HeapObject> base,
2390 TNode<IntPtrT> base_allocation_size,
2391 TNode<AllocationSite> allocation_site);
2393 TNode<IntPtrT> TryTaggedToInt32AsIntPtr(TNode<Object> value,
2395 TNode<Float64T> TryTaggedToFloat64(TNode<Object> value,
2397 TNode<Float64T> TruncateTaggedToFloat64(TNode<Context> context,
2398 TNode<Object> value);
2399 TNode<Word32T> TruncateTaggedToWord32(TNode<Context> context,
2400 TNode<Object> value);
2401 void TaggedToWord32OrBigInt(TNode<Context> context, TNode<Object> value,
2405 void TaggedToWord32OrBigIntWithFeedback(TNode<Context> context,
2406 TNode<Object> value, Label* if_number,
2412 TNode<Context> context, TNode<HeapObject> pointer, Label* if_number,
2416 TNode<Int32T> TruncateNumberToWord32(TNode<Number> value);
2418 TNode<Int32T> TruncateHeapNumberValueToWord32(TNode<HeapNumber> object);
2421 void TryHeapNumberToSmi(TNode<HeapNumber> number, TVariable<Smi>* output,
2423 void TryFloat32ToSmi(TNode<Float32T> number, TVariable<Smi>* output,
2425 void TryFloat64ToSmi(TNode<Float64T> number, TVariable<Smi>* output,
2427 TNode<Number> ChangeFloat32ToTagged(TNode<Float32T> value);
2428 TNode<Number> ChangeFloat64ToTagged(TNode<Float64T> value);
2429 TNode<Number> ChangeInt32ToTagged(TNode<Int32T> value);
2430 TNode<Number> ChangeInt32ToTaggedNoOverflow(TNode<Int32T> value);
2431 TNode<Number> ChangeUint32ToTagged(TNode<Uint32T> value);
2432 TNode<Number> ChangeUintPtrToTagged(TNode<UintPtrT> value);
2433 TNode<Uint32T> ChangeNumberToUint32(TNode<Number> value);
2434 TNode<Float64T> ChangeNumberToFloat64(TNode<Number> value);
2436 TNode<Int32T> ChangeTaggedNonSmiToInt32(TNode<Context> context,
2437 TNode<HeapObject> input);
2438 TNode<Float64T> ChangeTaggedToFloat64(TNode<Context> context,
2439 TNode<Object> input);
2441 TNode<Int32T> ChangeBoolToInt32(TNode<BoolT> b);
2443 void TaggedToNumeric(TNode<Context> context, TNode<Object> value,
2445 void TaggedToNumericWithFeedback(TNode<Context> context, TNode<Object> value,
2451 void SharedValueBarrier(TNode<Context> context,
2454 TNode<WordT> TimesSystemPointerSize(TNode<WordT> value);
2455 TNode<IntPtrT> TimesSystemPointerSize(TNode<IntPtrT> value) {
2456 return Signed(TimesSystemPointerSize(implicit_cast<TNode<WordT>>(value)));
2458 TNode<UintPtrT> TimesSystemPointerSize(TNode<UintPtrT> value) {
2459 return Unsigned(TimesSystemPointerSize(implicit_cast<TNode<WordT>>(value)));
2462 TNode<WordT> TimesTaggedSize(TNode<WordT> value);
2463 TNode<IntPtrT> TimesTaggedSize(TNode<IntPtrT> value) {
2464 return Signed(TimesTaggedSize(implicit_cast<TNode<WordT>>(value)));
2466 TNode<UintPtrT> TimesTaggedSize(TNode<UintPtrT> value) {
2467 return Unsigned(TimesTaggedSize(implicit_cast<TNode<WordT>>(value)));
2470 TNode<WordT> TimesDoubleSize(TNode<WordT> value);
2471 TNode<UintPtrT> TimesDoubleSize(TNode<UintPtrT> value) {
2472 return Unsigned(TimesDoubleSize(implicit_cast<TNode<WordT>>(value)));
2474 TNode<IntPtrT> TimesDoubleSize(TNode<IntPtrT> value) {
2475 return Signed(TimesDoubleSize(implicit_cast<TNode<WordT>>(value)));
2481 TNode<String> ToThisString(TNode<Context> context, TNode<Object> value,
2482 TNode<String> method_name);
2483 TNode<String> ToThisString(TNode<Context> context, TNode<Object> value,
2491 TNode<Object> ToThisValue(TNode<Context> context, TNode<Object> value,
2497 void ThrowIfNotInstanceType(TNode<Context> context, TNode<Object> value,
2501 void ThrowIfNotJSReceiver(TNode<Context> context, TNode<Object> value,
2504 void ThrowIfNotCallable(TNode<Context> context, TNode<Object> value,
2507 void ThrowRangeError(TNode<Context> context, MessageTemplate message,
2508 base::Optional<TNode<Object>> arg0 = base::nullopt,
2509 base::Optional<TNode<Object>> arg1 = base::nullopt,
2510 base::Optional<TNode<Object>> arg2 = base::nullopt);
2511 void ThrowTypeError(TNode<Context> context, MessageTemplate message,
2513 void ThrowTypeError(TNode<Context> context, MessageTemplate message,
2514 base::Optional<TNode<Object>> arg0,
2515 base::Optional<TNode<Object>> arg1 = base::nullopt,
2516 base::Optional<TNode<Object>> arg2 = base::nullopt);
2518 TNode<HeapObject> GetPendingMessage();
2519 void SetPendingMessage(TNode<HeapObject> message);
2524 TNode<BoolT> InstanceTypeEqual(TNode<Int32T> instance_type, int type);
2525 TNode<BoolT> IsNoElementsProtectorCellInvalid();
2526 TNode<BoolT> IsMegaDOMProtectorCellInvalid();
2527 TNode<BoolT> IsArrayIteratorProtectorCellInvalid();
2528 TNode<BoolT> IsBigIntInstanceType(TNode<Int32T> instance_type);
2529 TNode<BoolT> IsBigInt(TNode<HeapObject> object);
2530 TNode<BoolT> IsBoolean(TNode<HeapObject> object);
2531 TNode<BoolT> IsCallableMap(TNode<Map> map);
2532 TNode<BoolT> IsCallable(TNode<HeapObject> object);
2533 TNode<BoolT> TaggedIsCallable(TNode<Object> object);
2534 TNode<BoolT> IsConsStringInstanceType(TNode<Int32T> instance_type);
2535 TNode<BoolT> IsConstructorMap(TNode<Map> map);
2536 TNode<BoolT> IsConstructor(TNode<HeapObject> object);
2537 TNode<BoolT> IsDeprecatedMap(TNode<Map> map);
2538 TNode<BoolT> IsNameDictionary(TNode<HeapObject> object);
2539 TNode<BoolT> IsOrderedNameDictionary(TNode<HeapObject> object);
2540 TNode<BoolT> IsGlobalDictionary(TNode<HeapObject> object);
2541 TNode<BoolT> IsExtensibleMap(TNode<Map> map);
2542 TNode<BoolT> IsExtensibleNonPrototypeMap(TNode<Map> map);
2543 TNode<BoolT> IsExternalStringInstanceType(TNode<Int32T> instance_type);
2544 TNode<BoolT> IsFixedArray(TNode<HeapObject> object);
2545 TNode<BoolT> IsFixedArraySubclass(TNode<HeapObject> object);
2546 TNode<BoolT> IsFixedArrayWithKind(TNode<HeapObject> object,
2548 TNode<BoolT> IsFixedArrayWithKindOrEmpty(TNode<FixedArrayBase> object,
2550 TNode<BoolT> IsFunctionWithPrototypeSlotMap(TNode<Map> map);
2551 TNode<BoolT> IsHashTable(TNode<HeapObject> object);
2552 TNode<BoolT> IsEphemeronHashTable(TNode<HeapObject> object);
2553 TNode<BoolT> IsHeapNumberInstanceType(TNode<Int32T> instance_type);
2554 TNode<BoolT> IsOddball(TNode<HeapObject> object);
2555 TNode<BoolT> IsOddballInstanceType(TNode<Int32T> instance_type);
2556 TNode<BoolT> IsIndirectStringInstanceType(TNode<Int32T> instance_type);
2557 TNode<BoolT> IsJSArrayBuffer(TNode<HeapObject> object);
2558 TNode<BoolT> IsJSDataView(TNode<HeapObject> object);
2559 TNode<BoolT> IsJSArrayInstanceType(TNode<Int32T> instance_type);
2560 TNode<BoolT> IsJSArrayMap(TNode<Map> map);
2561 TNode<BoolT> IsJSArray(TNode<HeapObject> object);
2562 TNode<BoolT> IsJSArrayIterator(TNode<HeapObject> object);
2563 TNode<BoolT> IsJSAsyncGeneratorObject(TNode<HeapObject> object);
2564 TNode<BoolT> IsFunctionInstanceType(TNode<Int32T> instance_type);
2565 TNode<BoolT> IsJSFunctionInstanceType(TNode<Int32T> instance_type);
2566 TNode<BoolT> IsJSFunctionMap(TNode<Map> map);
2567 TNode<BoolT> IsJSFunction(TNode<HeapObject> object);
2568 TNode<BoolT> IsJSBoundFunction(TNode<HeapObject> object);
2569 TNode<BoolT> IsJSGeneratorObject(TNode<HeapObject> object);
2570 TNode<BoolT> IsJSGlobalProxyInstanceType(TNode<Int32T> instance_type);
2571 TNode<BoolT> IsJSGlobalProxyMap(TNode<Map> map);
2572 TNode<BoolT> IsJSGlobalProxy(TNode<HeapObject> object);
2573 TNode<BoolT> IsJSObjectInstanceType(TNode<Int32T> instance_type);
2574 TNode<BoolT> IsJSObjectMap(TNode<Map> map);
2575 TNode<BoolT> IsJSObject(TNode<HeapObject> object);
2576 TNode<BoolT> IsJSApiObjectInstanceType(TNode<Int32T> instance_type);
2577 TNode<BoolT> IsJSApiObjectMap(TNode<Map> map);
2578 TNode<BoolT> IsJSApiObject(TNode<HeapObject> object);
2579 TNode<BoolT> IsJSFinalizationRegistryMap(TNode<Map> map);
2580 TNode<BoolT> IsJSFinalizationRegistry(TNode<HeapObject> object);
2581 TNode<BoolT> IsJSPromiseMap(TNode<Map> map);
2582 TNode<BoolT> IsJSPromise(TNode<HeapObject> object);
2583 TNode<BoolT> IsJSProxy(TNode<HeapObject> object);
2584 TNode<BoolT> IsJSStringIterator(TNode<HeapObject> object);
2585 TNode<BoolT> IsJSRegExpStringIterator(TNode<HeapObject> object);
2586 TNode<BoolT> IsJSReceiverInstanceType(TNode<Int32T> instance_type);
2587 TNode<BoolT> IsJSReceiverMap(TNode<Map> map);
2588 TNode<BoolT> IsJSReceiver(TNode<HeapObject> object);
2589 TNode<BoolT> IsJSRegExp(TNode<HeapObject> object);
2590 TNode<BoolT> IsJSTypedArrayInstanceType(TNode<Int32T> instance_type);
2591 TNode<BoolT> IsJSTypedArrayMap(TNode<Map> map);
2592 TNode<BoolT> IsJSTypedArray(TNode<HeapObject> object);
2593 TNode<BoolT> IsJSGeneratorMap(TNode<Map> map);
2594 TNode<BoolT> IsJSPrimitiveWrapperInstanceType(TNode<Int32T> instance_type);
2595 TNode<BoolT> IsJSPrimitiveWrapperMap(TNode<Map> map);
2596 TNode<BoolT> IsJSPrimitiveWrapper(TNode<HeapObject> object);
2597 TNode<BoolT> IsJSSharedStructInstanceType(TNode<Int32T> instance_type);
2598 TNode<BoolT> IsJSSharedStructMap(TNode<Map> map);
2599 TNode<BoolT> IsJSSharedStruct(TNode<HeapObject> object);
2600 TNode<BoolT> IsJSSharedStruct(TNode<Object> object);
2601 TNode<BoolT> IsJSWrappedFunction(TNode<HeapObject> object);
2602 TNode<BoolT> IsMap(TNode<HeapObject> object);
2603 TNode<BoolT> IsName(TNode<HeapObject> object);
2604 TNode<BoolT> IsNameInstanceType(TNode<Int32T> instance_type);
2605 TNode<BoolT> IsNullOrJSReceiver(TNode<HeapObject> object);
2606 TNode<BoolT> IsNullOrUndefined(TNode<Object> object);
2607 TNode<BoolT> IsNumberDictionary(TNode<HeapObject> object);
2608 TNode<BoolT> IsOneByteStringInstanceType(TNode<Int32T> instance_type);
2609 TNode<BoolT> IsSeqOneByteStringInstanceType(TNode<Int32T> instance_type);
2610 TNode<BoolT> IsPrimitiveInstanceType(TNode<Int32T> instance_type);
2611 TNode<BoolT> IsPrivateName(TNode<Symbol> symbol);
2612 TNode<BoolT> IsPropertyArray(TNode<HeapObject> object);
2613 TNode<BoolT> IsPropertyCell(TNode<HeapObject> object);
2614 TNode<BoolT> IsPromiseReactionJobTask(TNode<HeapObject> object);
2615 TNode<BoolT> IsPrototypeInitialArrayPrototype(TNode<Context> context,
2616 TNode<Map> map);
2617 TNode<BoolT> IsPrototypeTypedArrayPrototype(TNode<Context> context,
2618 TNode<Map> map);
2620 TNode<BoolT> IsFastAliasedArgumentsMap(TNode<Context> context,
2621 TNode<Map> map);
2622 TNode<BoolT> IsSlowAliasedArgumentsMap(TNode<Context> context,
2623 TNode<Map> map);
2624 TNode<BoolT> IsSloppyArgumentsMap(TNode<Context> context, TNode<Map> map);
2625 TNode<BoolT> IsStrictArgumentsMap(TNode<Context> context, TNode<Map> map);
2627 TNode<BoolT> IsSequentialStringInstanceType(TNode<Int32T> instance_type);
2628 TNode<BoolT> IsUncachedExternalStringInstanceType(
2629 TNode<Int32T> instance_type);
2630 TNode<BoolT> IsSpecialReceiverInstanceType(TNode<Int32T> instance_type);
2631 TNode<BoolT> IsCustomElementsReceiverInstanceType(
2632 TNode<Int32T> instance_type);
2633 TNode<BoolT> IsSpecialReceiverMap(TNode<Map> map);
2634 TNode<BoolT> IsStringInstanceType(TNode<Int32T> instance_type);
2635 TNode<BoolT> IsString(TNode<HeapObject> object);
2636 TNode<BoolT> IsSeqOneByteString(TNode<HeapObject> object);
2637 TNode<BoolT> IsSwissNameDictionary(TNode<HeapObject> object);
2639 TNode<BoolT> IsSymbolInstanceType(TNode<Int32T> instance_type);
2640 TNode<BoolT> IsInternalizedStringInstanceType(TNode<Int32T> instance_type);
2641 TNode<BoolT> IsSharedStringInstanceType(TNode<Int32T> instance_type);
2642 TNode<BoolT> IsTemporalInstantInstanceType(TNode<Int32T> instance_type);
2643 TNode<BoolT> IsUniqueName(TNode<HeapObject> object);
2644 TNode<BoolT> IsUniqueNameNoIndex(TNode<HeapObject> object);
2645 TNode<BoolT> IsUniqueNameNoCachedIndex(TNode<HeapObject> object);
2646 TNode<BoolT> IsUndetectableMap(TNode<Map> map);
2647 TNode<BoolT> IsNotWeakFixedArraySubclass(TNode<HeapObject> object);
2648 TNode<BoolT> IsZeroOrContext(TNode<Object> object);
2650 TNode<BoolT> IsPromiseResolveProtectorCellInvalid();
2651 TNode<BoolT> IsPromiseThenProtectorCellInvalid();
2652 TNode<BoolT> IsArraySpeciesProtectorCellInvalid();
2653 TNode<BoolT> IsIsConcatSpreadableProtectorCellInvalid();
2654 TNode<BoolT> IsTypedArraySpeciesProtectorCellInvalid();
2655 TNode<BoolT> IsRegExpSpeciesProtectorCellInvalid();
2656 TNode<BoolT> IsPromiseSpeciesProtectorCellInvalid();
2658 TNode<IntPtrT> LoadBasicMemoryChunkFlags(TNode<HeapObject> object);
2660 TNode<BoolT> LoadRuntimeFlag(ExternalReference address_of_flag) {
2661 TNode<Word32T> flag_value = UncheckedCast<Word32T>(
2667 TNode<BoolT> IsMockArrayBufferAllocatorFlag() {
2672 TNode<BoolT> HasBuiltinSubclassingFlag() {
2677 TNode<BoolT> HasSharedStringTableFlag() {
2683 TNode<BoolT> IsNumeric(TNode<Object> object);
2687 TNode<BoolT> IsNumberNormalized(TNode<Number> number);
2688 TNode<BoolT> IsNumberPositive(TNode<Number> number);
2689 TNode<BoolT> IsHeapNumberPositive(TNode<HeapNumber> number);
2692 TNode<BoolT> IsNumberNonNegativeSafeInteger(TNode<Number> number);
2695 TNode<BoolT> IsInteger(TNode<Object> number);
2696 TNode<BoolT> IsInteger(TNode<HeapNumber> number);
2699 TNode<BoolT> IsSafeInteger(TNode<Object> number);
2700 TNode<BoolT> IsSafeInteger(TNode<HeapNumber> number);
2703 TNode<BoolT> IsHeapNumberUint32(TNode<HeapNumber> number);
2707 TNode<BoolT> IsNumberArrayIndex(TNode<Number> number);
2710 TNode<BoolT> FixedArraySizeDoesntFitInNewSpace(TNode<TIndex> element_count,
2713 TNode<BoolT> IsMetaMap(TNode<HeapObject> o) { return IsMapMap(o); }
2716 TNode<BoolT> ElementsKindEqual(TNode<Int32T> a, TNode<Int32T> b) {
2720 TNode<BoolT> IsFastElementsKind(TNode<Int32T> elements_kind);
2724 TNode<BoolT> IsFastOrNonExtensibleOrSealedElementsKind(
2725 TNode<Int32T> elements_kind);
2727 TNode<BoolT> IsDictionaryElementsKind(TNode<Int32T> elements_kind) {
2730 TNode<BoolT> IsDoubleElementsKind(TNode<Int32T> elements_kind);
2734 TNode<BoolT> IsFastSmiOrTaggedElementsKind(TNode<Int32T> elements_kind);
2735 TNode<BoolT> IsFastSmiElementsKind(TNode<Int32T> elements_kind);
2736 TNode<BoolT> IsHoleyFastElementsKind(TNode<Int32T> elements_kind);
2737 TNode<BoolT> IsHoleyFastElementsKindForRead(TNode<Int32T> elements_kind);
2738 TNode<BoolT> IsElementsKindGreaterThan(TNode<Int32T> target_kind,
2740 TNode<BoolT> IsElementsKindGreaterThanOrEqual(TNode<Int32T> target_kind,
2742 TNode<BoolT> IsElementsKindLessThanOrEqual(TNode<Int32T> target_kind,
2745 TNode<BoolT> IsElementsKindInRange(TNode<Int32T> target_kind,
2753 TNode<Uint16T> StringCharCodeAt(TNode<String> string, TNode<UintPtrT> index);
2755 TNode<String> StringFromSingleCharCode(TNode<Int32T> code);
2760 TNode<Number> StringToNumber(TNode<String> input);
2762 TNode<String> NumberToString(TNode<Number> input);
2763 TNode<String> NumberToString(TNode<Number> input, Label* bailout);
2766 TNode<Number> NonNumberToNumber(
2767 TNode<Context> context, TNode<HeapObject> input,
2770 TNode<Numeric> NonNumberToNumeric(TNode<Context> context,
2771 TNode<HeapObject> input);
2776 TNode<Number> ToNumber(
2777 TNode<Context> context, TNode<Object> input,
2779 TNode<Number> ToNumber_Inline(TNode<Context> context, TNode<Object> input);
2780 TNode<Numeric> ToNumberOrNumeric(
2781 LazyNode<Context> context, TNode<Object> input,
2786 TNode<Number> PlainPrimitiveToNumber(TNode<Object> input);
2790 TNode<BigInt> ToBigInt(TNode<Context> context, TNode<Object> input);
2795 TNode<Number> ToUint32(TNode<Context> context, TNode<Object> input);
2798 TNode<String> ToString_Inline(TNode<Context> context, TNode<Object> input);
2800 TNode<JSReceiver> ToObject(TNode<Context> context, TNode<Object> input);
2804 TNode<JSReceiver> ToObject_Inline(TNode<Context> context,
2805 TNode<Object> input);
2808 TNode<Number> ToLength_Inline(TNode<Context> context, TNode<Object> input);
2810 TNode<Object> OrdinaryToPrimitive(TNode<Context> context, TNode<Object> input,
2816 TNode<Uint32T> DecodeWord32(TNode<Word32T> word32) {
2823 TNode<UintPtrT> DecodeWord(TNode<WordT> word) {
2830 TNode<UintPtrT> DecodeWordFromWord32(TNode<Word32T> word32) {
2837 TNode<Uint32T> DecodeWord32FromWord(TNode<WordT> word) {
2843 TNode<Uint32T> DecodeWord32(TNode<Word32T> word32, uint32_t shift,
2847 TNode<UintPtrT> DecodeWord(TNode<WordT> word, uint32_t shift, uintptr_t mask);
2851 TNode<Word32T> UpdateWord32(TNode<Word32T> word, TNode<Uint32T> value,
2859 TNode<WordT> UpdateWord(TNode<WordT> word, TNode<UintPtrT> value,
2867 TNode<Word32T> UpdateWordInWord32(TNode<Word32T> word, TNode<UintPtrT> value,
2876 TNode<WordT> UpdateWord32InWord(TNode<WordT> word, TNode<Uint32T> value,
2884 TNode<Word32T> UpdateWord32(TNode<Word32T> word, TNode<Uint32T> value,
2890 TNode<WordT> UpdateWord(TNode<WordT> word, TNode<UintPtrT> value,
2896 TNode<BoolT> IsSetWord32(TNode<Word32T> word32) {
2901 TNode<BoolT> IsSetWord32(TNode<Word32T> word32, uint32_t mask) {
2907 TNode<BoolT> IsNotSetWord32(TNode<Word32T> word32, uint32_t mask) {
2913 TNode<BoolT> IsAllSetWord32(TNode<Word32T> word32, uint32_t mask) {
2914 TNode<Int32T> const_mask = Int32Constant(mask);
2921 TNode<BoolT> IsEqualInWord32(TNode<Word32T> word32,
2923 TNode<Word32T> masked_word32 =
2931 TNode<BoolT> IsNotEqualInWord32(TNode<Word32T> word32,
2938 TNode<BoolT> IsSetWord(TNode<WordT> word) {
2943 TNode<BoolT> IsSetWord(TNode<WordT> word, uint32_t mask) {
2949 TNode<BoolT> IsSetSmi(TNode<Smi> smi, int untagged_mask) {
2958 TNode<BoolT> IsClearWord32(TNode<Word32T> word32) {
2963 TNode<BoolT> IsClearWord32(TNode<Word32T> word32, uint32_t mask) {
2970 TNode<BoolT> IsClearWord(TNode<WordT> word) {
2975 TNode<BoolT> IsClearWord(TNode<WordT> word, uint32_t mask) {
3002 void TryToName(TNode<Object> key, Label* if_keyisindex,
3008 void StringWriteToFlatOneByte(TNode<String> source, TNode<RawPtrT> sink,
3009 TNode<Int32T> start, TNode<Int32T> length);
3010 void StringWriteToFlatTwoByte(TNode<String> source, TNode<RawPtrT> sink,
3011 TNode<Int32T> start, TNode<Int32T> length);
3014 TNode<RawPtr<Uint8T>> ExternalOneByteStringGetChars(
3015 TNode<ExternalOneByteString> string);
3016 TNode<RawPtr<Uint16T>> ExternalTwoByteStringGetChars(
3017 TNode<ExternalTwoByteString> string);
3019 TNode<RawPtr<Uint8T>> IntlAsciiCollationWeightsL1();
3020 TNode<RawPtr<Uint8T>> IntlAsciiCollationWeightsL3();
3031 void TryInternalizeString(TNode<String> string, Label* if_index,
3040 TNode<IntPtrT> EntryToIndex(TNode<IntPtrT> entry, int field_index);
3042 TNode<IntPtrT> EntryToIndex(TNode<IntPtrT> entry) {
3049 TNode<Uint32T> LoadDetailsByKeyIndex(TNode<ContainerType> container,
3050 TNode<IntPtrT> key_index);
3055 TNode<Object> LoadValueByKeyIndex(TNode<ContainerType> container,
3056 TNode<IntPtrT> key_index);
3061 void StoreDetailsByKeyIndex(TNode<ContainerType> container,
3062 TNode<IntPtrT> key_index, TNode<Smi> details);
3067 TNode<ContainerType> container, TNode<IntPtrT> key_index,
3068 TNode<Object> value,
3072 TNode<IntPtrT> HashTableComputeCapacity(TNode<IntPtrT> at_least_space_for);
3074 TNode<IntPtrT> NameToIndexHashTableLookup(TNode<NameToIndexHashTable> table,
3075 TNode<Name> name, Label* not_found);
3078 TNode<Smi> GetNumberOfElements(TNode<Dictionary> dictionary);
3080 TNode<Smi> GetNumberDictionaryNumberOfElements(
3081 TNode<NumberDictionary> dictionary) {
3086 void SetNumberOfElements(TNode<Dictionary> dictionary,
3087 TNode<Smi> num_elements_smi) {
3096 TNode<Smi> GetNumberOfDeletedElements(TNode<Dictionary> dictionary) {
3105 void SetNumberOfDeletedElements(TNode<Dictionary> dictionary,
3106 TNode<Smi> num_deleted_smi) {
3116 TNode<Smi> GetCapacity(TNode<Dictionary> dictionary) {
3125 TNode<Smi> GetNextEnumerationIndex(TNode<Dictionary> dictionary) {
3131 void SetNextEnumerationIndex(TNode<Dictionary> dictionary,
3132 TNode<Smi> next_enum_index_smi) {
3144 TNode<HeapObject> LoadName(TNode<HeapObject> key);
3147 void NameDictionaryLookup(TNode<Dictionary> dictionary,
3148 TNode<Name> unique_name, Label* if_found,
3153 TNode<Word32T> ComputeSeededHash(TNode<IntPtrT> key);
3155 void NumberDictionaryLookup(TNode<NumberDictionary> dictionary,
3156 TNode<IntPtrT> intptr_index, Label* if_found,
3160 TNode<Object> BasicLoadNumberDictionaryElement(
3161 TNode<NumberDictionary> dictionary, TNode<IntPtrT> intptr_index,
3165 void FindInsertionEntry(TNode<Dictionary> dictionary, TNode<Name> key,
3169 void InsertEntry(TNode<Dictionary> dictionary, TNode<Name> key,
3170 TNode<Object> value, TNode<IntPtrT> index,
3171 TNode<Smi> enum_index);
3174 void Add(TNode<Dictionary> dictionary, TNode<Name> key, TNode<Object> value,
3178 void TryHasOwnProperty(TNode<HeapObject> object, TNode<Map> map,
3179 TNode<Int32T> instance_type, TNode<Name> unique_name,
3203 void TryGetOwnProperty(TNode<Context> context, TNode<Object> receiver,
3204 TNode<JSReceiver> object, TNode<Map> map,
3205 TNode<Int32T> instance_type, TNode<Name> unique_name,
3208 void TryGetOwnProperty(TNode<Context> context, TNode<Object> receiver,
3209 TNode<JSReceiver> object, TNode<Map> map,
3210 TNode<Int32T> instance_type, TNode<Name> unique_name,
3216 TNode<Object> GetProperty(TNode<Context> context, TNode<Object> receiver,
3221 TNode<Object> GetProperty(TNode<Context> context, TNode<Object> receiver,
3222 TNode<Object> name) {
3226 TNode<Object> SetPropertyStrict(TNode<Context> context,
3227 TNode<Object> receiver, TNode<Object> key,
3228 TNode<Object> value) {
3232 TNode<Object> CreateDataProperty(TNode<Context> context,
3233 TNode<JSObject> receiver, TNode<Object> key,
3234 TNode<Object> value) {
3239 TNode<Object> GetMethod(TNode<Context> context, TNode<Object> object,
3242 TNode<Object> GetIteratorMethod(TNode<Context> context,
3243 TNode<HeapObject> heap_obj,
3246 TNode<Object> CreateAsyncFromSyncIterator(TNode<Context> context,
3247 TNode<Object> sync_iterator);
3250 TNode<Object> CallBuiltin(Builtin id, TNode<Object> context, TArgs... args) {
3256 void TailCallBuiltin(Builtin id, TNode<Object> context, TArgs... args) {
3260 void LoadPropertyFromFastObject(TNode<HeapObject> object, TNode<Map> map,
3261 TNode<DescriptorArray> descriptors,
3262 TNode<IntPtrT> name_index,
3266 void LoadPropertyFromFastObject(TNode<HeapObject> object, TNode<Map> map,
3267 TNode<DescriptorArray> descriptors,
3268 TNode<IntPtrT> name_index, TNode<Uint32T>,
3272 void LoadPropertyFromDictionary(TNode<Dictionary> dictionary,
3273 TNode<IntPtrT> name_index,
3276 void LoadPropertyFromGlobalDictionary(TNode<GlobalDictionary> dictionary,
3277 TNode<IntPtrT> name_index,
3294 void TryLookupProperty(TNode<HeapObject> object, TNode<Map> map,
3295 TNode<Int32T> instance_type, TNode<Name> unique_name,
3306 void TryLookupPropertyInSimpleObject(TNode<JSObject> object, TNode<Map> map,
3307 TNode<Name> unique_name,
3317 void TryLookupElement(TNode<HeapObject> object, TNode<Map> map,
3318 TNode<Int32T> instance_type,
3319 TNode<IntPtrT> intptr_index, Label* if_found,
3328 void BranchIfMaybeSpecialIndex(TNode<String> name_string,
3335 TNode<HeapObject> receiver, TNode<HeapObject> holder, TNode<Map> map,
3336 TNode<Int32T> instance_type, TNode<Name> key, Label* next_holder,
3342 TNode<HeapObject> receiver, TNode<HeapObject> holder, TNode<Map> map,
3343 TNode<Int32T> instance_type, TNode<IntPtrT> key, Label* next_holder,
3354 TNode<Object> receiver, TNode<Object> object, TNode<Object> key,
3363 TNode<Oddball> HasInPrototypeChain(TNode<Context> context,
3364 TNode<HeapObject> object,
3365 TNode<Object> prototype);
3367 TNode<Oddball> OrdinaryHasInstance(TNode<Context> context,
3368 TNode<Object> callable,
3369 TNode<Object> object);
3372 TNode<FeedbackVector> LoadFeedbackVectorForStub();
3373 TNode<FeedbackVector> LoadFeedbackVectorFromBaseline();
3374 TNode<Context> LoadContextFromBaseline();
3377 TNode<FeedbackVector> LoadFeedbackVectorForStubWithTrampoline();
3380 TNode<HeapObject> LoadFeedbackCellValue(TNode<JSFunction> closure);
3385 TNode<HeapObject> LoadFeedbackVector(TNode<JSFunction> closure);
3391 TNode<ClosureFeedbackCellArray> LoadClosureFeedbackArray(
3392 TNode<JSFunction> closure);
3398 void UpdateFeedback(TNode<Smi> feedback,
3399 TNode<HeapObject> maybe_feedback_vector,
3400 TNode<UintPtrT> slot_id, UpdateFeedbackMode mode);
3401 void UpdateFeedback(TNode<Smi> feedback,
3402 TNode<FeedbackVector> feedback_vector,
3403 TNode<UintPtrT> slot_id);
3404 void MaybeUpdateFeedback(TNode<Smi> feedback,
3405 TNode<HeapObject> maybe_feedback_vector,
3406 TNode<UintPtrT> slot_id);
3410 void ReportFeedbackUpdate(TNode<FeedbackVector> feedback_vector,
3411 TNode<UintPtrT> slot_id, const char* reason);
3416 void CombineFeedback(TVariable<Smi>* existing_feedback, TNode<Smi> feedback);
3424 void CheckForAssociatedProtector(TNode<Name> name, Label* if_protector);
3426 TNode<Map> LoadReceiverMap(TNode<Object> receiver);
3429 TNode<Context> LoadScriptContext(TNode<Context> context,
3430 TNode<IntPtrT> context_index);
3432 TNode<Uint8T> Int32ToUint8Clamped(TNode<Int32T> int32_value);
3433 TNode<Uint8T> Float64ToUint8Clamped(TNode<Float64T> float64_value);
3436 TNode<T> PrepareValueForWriteToTypedArray(TNode<Object> input,
3438 TNode<Context> context);
3445 void StoreElement(TNode<RawPtrT> elements, ElementsKind kind,
3446 TNode<TIndex> index, TNode<TValue> value);
3452 void BigIntToRawBytes(TNode<BigInt> bigint, TVariable<UintPtrT>* var_low,
3455 void EmitElementStore(TNode<JSObject> object, TNode<Object> key,
3456 TNode<Object> value, ElementsKind elements_kind,
3458 TNode<Context> context,
3461 TNode<FixedArrayBase> CheckForCapacityGrow(
3462 TNode<JSObject> object, TNode<FixedArrayBase> elements, ElementsKind kind,
3463 TNode<UintPtrT> length, TNode<IntPtrT> key, Label* bailout);
3465 TNode<FixedArrayBase> CopyElementsOnWrite(TNode<HeapObject> object,
3466 TNode<FixedArrayBase> elements,
3468 TNode<IntPtrT> length,
3471 void TransitionElementsKind(TNode<JSObject> object, TNode<Map> map,
3475 void TrapAllocationMemento(TNode<JSObject> object, Label* memento_found);
3477 TNode<IntPtrT> PageFromAddress(TNode<IntPtrT> address);
3480 TNode<MaybeObject> StoreWeakReferenceInFeedbackVector(
3481 TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
3482 TNode<HeapObject> value, int additional_offset = 0);
3485 TNode<AllocationSite> CreateAllocationSiteInFeedbackVector(
3486 TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot);
3488 TNode<BoolT> HasBoilerplate(TNode<Object> maybe_literal_site);
3489 TNode<Smi> LoadTransitionInfo(TNode<AllocationSite> allocation_site);
3490 TNode<JSObject> LoadBoilerplate(TNode<AllocationSite> allocation_site);
3491 TNode<Int32T> LoadElementsKind(TNode<AllocationSite> allocation_site);
3496 using FastLoopBody = std::function<void(TNode<TIndex> index)>;
3499 TNode<TIndex> BuildFastLoop(
3500 const VariableList& var_list, TNode<TIndex> start_index,
3501 TNode<TIndex> end_index, const FastLoopBody<TIndex>& body, int increment,
3505 TNode<TIndex> BuildFastLoop(
3506 TNode<TIndex> start_index, TNode<TIndex> end_index,
3516 std::function<void(TNode<HeapObject> array, TNode<IntPtrT> offset)>;
3520 TNode<UnionT<UnionT<FixedArray, PropertyArray>, HeapObject>> array,
3521 ElementsKind kind, TNode<TIndex> first_element_inclusive,
3522 TNode<TIndex> last_element_exclusive, const FastArrayForEachBody& body,
3526 TNode<IntPtrT> GetArrayAllocationSize(TNode<TIndex> element_count,
3532 TNode<IntPtrT> GetFixedArrayAllocationSize(TNode<TIndex> element_count,
3537 TNode<IntPtrT> GetPropertyArrayAllocationSize(TNode<IntPtrT> element_count) {
3543 void GotoIfFixedArraySizeDoesntFitInNewSpace(TNode<TIndex> element_count,
3547 void InitializeFieldsWithRoot(TNode<HeapObject> object,
3548 TNode<IntPtrT> start_offset,
3549 TNode<IntPtrT> end_offset, RootIndex root);
3555 TNode<Context> GotoIfHasContextExtensionUpToDepth(TNode<Context> context,
3556 TNode<Uint32T> depth,
3559 TNode<Oddball> RelationalComparison(
3560 Operation op, TNode<Object> left, TNode<Object> right,
3561 TNode<Context> context, TVariable<Smi>* var_type_feedback = nullptr) {
3566 TNode<Oddball> RelationalComparison(
3567 Operation op, TNode<Object> left, TNode<Object> right,
3571 void BranchIfNumberRelationalComparison(Operation op, TNode<Number> left,
3572 TNode<Number> right, Label* if_true,
3575 void BranchIfNumberEqual(TNode<Number> left, TNode<Number> right,
3581 void BranchIfNumberNotEqual(TNode<Number> left, TNode<Number> right,
3586 void BranchIfNumberLessThan(TNode<Number> left, TNode<Number> right,
3592 void BranchIfNumberLessThanOrEqual(TNode<Number> left, TNode<Number> right,
3598 void BranchIfNumberGreaterThan(TNode<Number> left, TNode<Number> right,
3604 void BranchIfNumberGreaterThanOrEqual(TNode<Number> left, TNode<Number> right,
3610 void BranchIfAccessorPair(TNode<Object> value, Label* if_accessor_pair,
3616 void GotoIfNumberGreaterThanOrEqual(TNode<Number> left, TNode<Number> right,
3619 TNode<Oddball> Equal(TNode<Object> lhs, TNode<Object> rhs,
3620 TNode<Context> context,
3625 TNode<Oddball> Equal(TNode<Object> lhs, TNode<Object> rhs,
3629 TNode<Oddball> StrictEqual(TNode<Object> lhs, TNode<Object> rhs,
3636 void BranchIfSameValue(TNode<Object> lhs, TNode<Object> rhs, Label* if_true,
3641 void BranchIfSameNumberValue(TNode<Float64T> lhs_value,
3642 TNode<Float64T> rhs_value, Label* if_true,
3647 TNode<Oddball> HasProperty(TNode<Context> context, TNode<Object> object,
3648 TNode<Object> key, HasPropertyLookupMode mode);
3651 TNode<Oddball> HasProperty_Inline(TNode<Context> context,
3652 TNode<JSReceiver> object,
3653 TNode<Object> key) {
3658 void ForInPrepare(TNode<HeapObject> enumerator, TNode<UintPtrT> slot,
3659 TNode<HeapObject> maybe_feedback_vector,
3660 TNode<FixedArray>* cache_array_out,
3661 TNode<Smi>* cache_length_out,
3664 TNode<String> Typeof(TNode<Object> value);
3666 TNode<HeapObject> GetSuperConstructor(TNode<JSFunction> active_function);
3668 TNode<JSReceiver> SpeciesConstructor(TNode<Context> context,
3669 TNode<Object> object,
3670 TNode<JSReceiver> default_constructor);
3672 TNode<Oddball> InstanceOf(TNode<Object> object, TNode<Object> callable,
3673 TNode<Context> context);
3676 TNode<BoolT> IsDebugActive();
3677 TNode<BoolT> IsSideEffectFreeDebuggingActive();
3680 TNode<RawPtrT> LoadJSArrayBufferBackingStorePtr(
3681 TNode<JSArrayBuffer> array_buffer);
3682 void ThrowIfArrayBufferIsDetached(TNode<Context> context,
3683 TNode<JSArrayBuffer> array_buffer,
3687 TNode<JSArrayBuffer> LoadJSArrayBufferViewBuffer(
3688 TNode<JSArrayBufferView> array_buffer_view);
3689 TNode<UintPtrT> LoadJSArrayBufferViewByteLength(
3690 TNode<JSArrayBufferView> array_buffer_view);
3692 TNode<UintPtrT> LoadJSArrayBufferViewByteOffset(
3693 TNode<JSArrayBufferView> array_buffer_view);
3695 TNode<Context> context, TNode<JSArrayBufferView> array_buffer_view,
3699 TNode<UintPtrT> LoadJSTypedArrayLengthAndCheckDetached(
3700 TNode<JSTypedArray> typed_array, Label* detached);
3703 TNode<UintPtrT> LoadVariableLengthJSTypedArrayLength(
3704 TNode<JSTypedArray> array, TNode<JSArrayBuffer> buffer,
3708 TNode<UintPtrT> LoadVariableLengthJSTypedArrayByteLength(
3709 TNode<Context> context, TNode<JSTypedArray> array,
3710 TNode<JSArrayBuffer> buffer);
3711 TNode<UintPtrT> LoadVariableLengthJSArrayBufferViewByteLength(
3712 TNode<JSArrayBufferView> array, TNode<JSArrayBuffer> buffer,
3716 TNode<JSArrayBufferView> array_buffer_view, Label* detached_or_oob,
3719 TNode<BoolT> IsJSArrayBufferViewDetachedOrOutOfBoundsBoolean(
3720 TNode<JSArrayBufferView> array_buffer_view);
3722 void CheckJSTypedArrayIndex(TNode<UintPtrT> index,
3723 TNode<JSTypedArray> typed_array,
3726 TNode<IntPtrT> RabGsabElementsKindToElementByteSize(
3727 TNode<Int32T> elementsKind);
3728 TNode<RawPtrT> LoadJSTypedArrayDataPtr(TNode<JSTypedArray> typed_array);
3729 TNode<JSArrayBuffer> GetTypedArrayBuffer(TNode<Context> context,
3730 TNode<JSTypedArray> array);
3733 TNode<IntPtrT> ElementOffsetFromIndex(TNode<TIndex> index, ElementsKind kind,
3737 TNode<BoolT> IsOffsetInBounds(TNode<IntPtrT> offset, TNode<IntPtrT> length,
3742 TNode<CodeT> LoadBuiltin(TNode<Smi> builtin_id);
3750 TNode<CodeT> GetSharedFunctionInfoCode(
3751 TNode<SharedFunctionInfo> shared_info,
3755 TNode<JSFunction> AllocateFunctionWithMapAndContext(
3756 TNode<Map> map, TNode<SharedFunctionInfo> shared_info,
3757 TNode<Context> context);
3760 TNode<Uint32T> PromiseHookFlags();
3761 TNode<BoolT> HasAsyncEventDelegate();
3763 TNode<BoolT> IsContextPromiseHookEnabled(TNode<Uint32T> flags);
3765 TNode<BoolT> IsIsolatePromiseHookEnabled(TNode<Uint32T> flags);
3766 TNode<BoolT> IsAnyPromiseHookEnabled(TNode<Uint32T> flags);
3767 TNode<BoolT> IsAnyPromiseHookEnabled() {
3770 TNode<BoolT> IsIsolatePromiseHookEnabledOrHasAsyncEventDelegate(
3771 TNode<Uint32T> flags);
3772 TNode<BoolT> IsIsolatePromiseHookEnabledOrHasAsyncEventDelegate() {
3776 TNode<BoolT>
3778 TNode<Uint32T> flags);
3779 TNode<BoolT>
3785 TNode<BoolT> NeedsAnyPromiseHooks(TNode<Uint32T> flags);
3786 TNode<BoolT> NeedsAnyPromiseHooks() {
3791 void CheckPrototypeEnumCache(TNode<JSReceiver> receiver,
3792 TNode<Map> receiver_map, Label* if_fast,
3794 TNode<Map> CheckEnumCache(TNode<JSReceiver> receiver, Label* if_empty,
3797 TNode<Object> GetArgumentValue(TorqueStructArguments args,
3798 TNode<IntPtrT> index);
3806 TNode<RawPtrT> frame, TNode<IntPtrT> argc,
3810 inline TNode<Int32T> JSParameterCount(int argc_without_receiver) {
3813 inline TNode<Word32T> JSParameterCount(TNode<Word32T> argc_without_receiver) {
3819 void Print(const char* prefix, TNode<MaybeObject> tagged_value);
3820 void Print(TNode<MaybeObject> tagged_value) {
3825 TNode<HeapObject> MakeTypeError(MessageTemplate message,
3826 TNode<Context> context, TArgs... args) {
3919 void PerformStackCheck(TNode<Context> context);
3921 void SetPropertyLength(TNode<Context> context, TNode<Object> array,
3922 TNode<Number> length);
3925 void DescriptorLookup(TNode<Name> unique_name,
3926 TNode<DescriptorArray> descriptors,
3927 TNode<Uint32T> bitfield3, Label* if_found,
3934 void TransitionLookup(TNode<Name> unique_name,
3935 TNode<TransitionArray> transitions, Label* if_found,
3941 void Lookup(TNode<Name> unique_name, TNode<Array> array,
3942 TNode<Uint32T> number_of_valid_entries, Label* if_found,
3947 void LookupLinear(TNode<Name> unique_name, TNode<Array> array,
3948 TNode<Uint32T> number_of_valid_entries, Label* if_found,
3953 void LookupBinary(TNode<Name> unique_name, TNode<Array> array,
3954 TNode<Uint32T> number_of_valid_entries, Label* if_found,
3959 TNode<IntPtrT> EntryIndexToIndex(TNode<Uint32T> entry_index);
3963 TNode<IntPtrT> ToKeyIndex(TNode<Uint32T> entry_index);
3967 TNode<Name> GetKey(TNode<Array> array, TNode<Uint32T> entry_index);
3970 TNode<Uint32T> DescriptorArrayGetDetails(TNode<DescriptorArray> descriptors,
3971 TNode<Uint32T> descriptor_number);
3974 std::function<void(TNode<IntPtrT> descriptor_key_index)>;
3978 TNode<Name> LoadKeyByKeyIndex(TNode<DescriptorArray> container,
3979 TNode<IntPtrT> key_index);
3980 TNode<Uint32T> LoadDetailsByKeyIndex(TNode<DescriptorArray> container,
3981 TNode<IntPtrT> key_index);
3982 TNode<Object> LoadValueByKeyIndex(TNode<DescriptorArray> container,
3983 TNode<IntPtrT> key_index);
3984 TNode<MaybeObject> LoadFieldTypeByKeyIndex(TNode<DescriptorArray> container,
3985 TNode<IntPtrT> key_index);
3987 TNode<IntPtrT> DescriptorEntryToIndex(TNode<IntPtrT> descriptor);
3990 TNode<Name> LoadKeyByDescriptorEntry(TNode<DescriptorArray> descriptors,
3991 TNode<IntPtrT> descriptor);
3992 TNode<Name> LoadKeyByDescriptorEntry(TNode<DescriptorArray> descriptors,
3994 TNode<Uint32T> LoadDetailsByDescriptorEntry(
3995 TNode<DescriptorArray> descriptors, TNode<IntPtrT> descriptor);
3996 TNode<Uint32T> LoadDetailsByDescriptorEntry(
3997 TNode<DescriptorArray> descriptors, int descriptor);
3998 TNode<Object> LoadValueByDescriptorEntry(TNode<DescriptorArray> descriptors,
3999 TNode<IntPtrT> descriptor);
4000 TNode<Object> LoadValueByDescriptorEntry(TNode<DescriptorArray> descriptors,
4002 TNode<MaybeObject> LoadFieldTypeByDescriptorEntry(
4003 TNode<DescriptorArray> descriptors, TNode<IntPtrT> descriptor);
4006 std::function<void(TNode<Name> key, TNode<Object> value)>;
4011 void ForEachEnumerableOwnProperty(TNode<Context> context, TNode<Map> map,
4012 TNode<JSObject> object,
4017 TNode<Object> CallGetterIfAccessor(
4018 TNode<Object> value, TNode<HeapObject> holder, TNode<Uint32T> details,
4019 TNode<Context> context, TNode<Object> receiver, TNode<Object> name,
4023 TNode<IntPtrT> TryToIntptr(TNode<Object> key, Label* if_not_intptr,
4026 TNode<JSArray> ArrayCreate(TNode<Context> context, TNode<Number> length);
4030 TNode<Object> CloneIfMutablePrimitive(TNode<Object> object);
4032 TNode<Smi> RefillMathRandom(TNode<NativeContext> native_context);
4035 TNode<JSFinalizationRegistry> finalization_registry,
4036 TNode<WeakCell> weak_cell);
4038 TNode<IntPtrT> FeedbackIteratorEntrySize() {
4042 TNode<IntPtrT> FeedbackIteratorHandlerOffset() {
4046 TNode<SwissNameDictionary> AllocateSwissNameDictionary(
4047 TNode<IntPtrT> at_least_space_for);
4048 TNode<SwissNameDictionary> AllocateSwissNameDictionary(
4051 TNode<SwissNameDictionary> AllocateSwissNameDictionaryWithCapacity(
4052 TNode<IntPtrT> capacity);
4055 TNode<IntPtrT> SwissNameDictionaryOffsetIntoDataTableMT(
4056 TNode<SwissNameDictionary> dict, TNode<IntPtrT> index, int field_index);
4059 TNode<IntPtrT> SwissNameDictionaryOffsetIntoPropertyDetailsTableMT(
4060 TNode<SwissNameDictionary> dict, TNode<IntPtrT> capacity,
4061 TNode<IntPtrT> index);
4063 TNode<IntPtrT> LoadSwissNameDictionaryNumberOfElements(
4064 TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity);
4066 TNode<IntPtrT> LoadSwissNameDictionaryNumberOfDeletedElements(
4067 TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity);
4073 TNode<Uint32T> SwissNameDictionaryIncreaseElementCountOrBailout(
4074 TNode<ByteArray> meta_table, TNode<IntPtrT> capacity,
4075 TNode<Uint32T> max_usable_capacity, Label* bailout);
4080 TNode<Uint32T> SwissNameDictionaryUpdateCountsForDeletion(
4081 TNode<ByteArray> meta_table, TNode<IntPtrT> capacity);
4083 void StoreSwissNameDictionaryCapacity(TNode<SwissNameDictionary> table,
4084 TNode<Int32T> capacity);
4087 TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity,
4088 TNode<IntPtrT> enum_index, TNode<Int32T> entry);
4090 TNode<Name> LoadSwissNameDictionaryKey(TNode<SwissNameDictionary> dict,
4091 TNode<IntPtrT> entry);
4093 void StoreSwissNameDictionaryKeyAndValue(TNode<SwissNameDictionary> dict,
4094 TNode<IntPtrT> entry,
4095 TNode<Object> key,
4096 TNode<Object> value);
4100 void SwissNameDictionarySetCtrl(TNode<SwissNameDictionary> table,
4101 TNode<IntPtrT> capacity, TNode<IntPtrT> entry,
4102 TNode<Uint8T> ctrl);
4104 TNode<Uint64T> LoadSwissNameDictionaryCtrlTableGroup(TNode<IntPtrT> address);
4106 TNode<Uint8T> LoadSwissNameDictionaryPropertyDetails(
4107 TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity,
4108 TNode<IntPtrT> entry);
4110 void StoreSwissNameDictionaryPropertyDetails(TNode<SwissNameDictionary> table,
4111 TNode<IntPtrT> capacity,
4112 TNode<IntPtrT> entry,
4113 TNode<Uint8T> details);
4115 TNode<SwissNameDictionary> CopySwissNameDictionary(
4116 TNode<SwissNameDictionary> original);
4118 void SwissNameDictionaryFindEntry(TNode<SwissNameDictionary> table,
4119 TNode<Name> key, Label* found,
4123 void SwissNameDictionaryAdd(TNode<SwissNameDictionary> table, TNode<Name> key,
4124 TNode<Object> value,
4125 TNode<Uint8T> property_details,
4133 TNode<HeapObject> AllocateRawDoubleAligned(TNode<IntPtrT> size_in_bytes,
4135 TNode<RawPtrT> top_address,
4136 TNode<RawPtrT> limit_address);
4137 TNode<HeapObject> AllocateRawUnaligned(TNode<IntPtrT> size_in_bytes,
4139 TNode<RawPtrT> top_address,
4140 TNode<RawPtrT> limit_address);
4141 TNode<HeapObject> AllocateRaw(TNode<IntPtrT> size_in_bytes,
4143 TNode<RawPtrT> top_address,
4144 TNode<RawPtrT> limit_address);
4148 TNode<JSArray> AllocateUninitializedJSArray(
4149 TNode<Map> array_map, TNode<Smi> length,
4150 base::Optional<TNode<AllocationSite>> allocation_site,
4151 TNode<IntPtrT> size_in_bytes);
4155 TNode<CollectionType> AllocateOrderedHashTable(TNode<IntPtrT> capacity);
4159 TNode<CollectionType> AllocateOrderedHashTableWithCapacity(
4160 TNode<IntPtrT> capacity);
4162 TNode<IntPtrT> SmiShiftBitsConstant() {
4165 TNode<Int32T> SmiShiftBitsConstant32() {
4169 TNode<String> AllocateSlicedString(RootIndex map_root_index,
4170 TNode<Uint32T> length,
4171 TNode<String> parent, TNode<Smi> offset);
4175 TNode<Uint32T> NumberOfEntries(TNode<Array> array);
4179 TNode<Uint32T> GetSortedKeyIndex(TNode<Array> descriptors,
4180 TNode<Uint32T> entry_index);
4182 TNode<Smi> CollectFeedbackForString(TNode<Int32T> instance_type);
4183 void GenerateEqual_Same(TNode<Object> value, Label* if_equal,
4190 TNode<Numeric> NonNumberToNumberOrNumeric(
4191 TNode<Context> context, TNode<HeapObject> input, Object::Conversion mode,
4194 void TaggedToNumeric(TNode<Context> context, TNode<Object> value,
4200 void TaggedToWord32OrBigIntImpl(TNode<Context> context, TNode<Object> value,
4210 TNode<T> LoadDescriptorArrayElement(TNode<DescriptorArray> object,
4211 TNode<IntPtrT> index,
4218 TNode<Object> LoadRoot(RootIndex root_index) {
4222 TNode<AnyTaggedT> LoadRootMapWord(RootIndex root_index) {
4228 TNode<UnionT<FixedArray, PropertyArray>> array, TNode<TIndex> index,
4229 TNode<Object> value, WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
4233 void StoreElementTypedArrayBigInt(TNode<RawPtrT> elements, ElementsKind kind,
4234 TNode<TIndex> index, TNode<BigInt> value);
4237 void StoreElementTypedArrayWord32(TNode<RawPtrT> elements, ElementsKind kind,
4238 TNode<TIndex> index, TNode<Word32T> value);
4247 void StoreElementTypedArray(TNode<TArray> elements, ElementsKind kind,
4248 TNode<TIndex> index, TNode<TValue> value);
4251 void StoreElement(TNode<FixedArrayBase> elements, ElementsKind kind,
4252 TNode<TIndex> index, TNode<Object> value);
4255 void StoreElement(TNode<FixedArrayBase> elements, ElementsKind kind,
4256 TNode<TIndex> index, TNode<Float64T> value);
4261 void TryPlainPrimitiveNonNumberToNumber(TNode<HeapObject> input,
4265 void DcheckHasValidMap(TNode<HeapObject> object);
4268 void EmitElementStoreTypedArray(TNode<JSTypedArray> typed_array,
4269 TNode<IntPtrT> key, TNode<Object> value,
4272 Label* bailout, TNode<Context> context,
4277 TNode<Object> value, ElementsKind elements_kind,
4278 TNode<TValue> converted_value, TVariable<Object>* maybe_converted_value);
4285 CodeStubArguments(CodeStubAssembler* assembler, TNode<IntPtrT> argc)
4286 : CodeStubArguments(assembler, argc, TNode<RawPtrT>()) {}
4287 CodeStubArguments(CodeStubAssembler* assembler, TNode<Int32T> argc)
4289 CodeStubArguments(CodeStubAssembler* assembler, TNode<IntPtrT> argc,
4290 TNode<RawPtrT> fp);
4301 TNode<Object> GetReceiver() const;
4305 void SetReceiver(TNode<Object> object) const;
4308 TNode<RawPtrT> AtIndexPtr(TNode<IntPtrT> index) const;
4311 TNode<Object> AtIndex(TNode<IntPtrT> index) const;
4312 TNode<Object> AtIndex(int index) const;
4315 TNode<IntPtrT> GetLengthWithoutReceiver() const;
4317 TNode<IntPtrT> GetLengthWithReceiver() const;
4323 TNode<Object> GetOptionalArgumentValue(TNode<IntPtrT> index,
4324 TNode<Object> default_value);
4325 TNode<Object> GetOptionalArgumentValue(TNode<IntPtrT> index) {
4328 TNode<Object> GetOptionalArgumentValue(int index) {
4333 using ForEachBodyFunction = std::function<void(TNode<Object> arg)>;
4334 void ForEach(const ForEachBodyFunction& body, TNode<IntPtrT> first = {},
4335 TNode<IntPtrT> last = {}) const {
4340 const ForEachBodyFunction& body, TNode<IntPtrT> first = {},
4341 TNode<IntPtrT> last = {}) const;
4343 void PopAndReturn(TNode<Object> value);
4347 TNode<IntPtrT> argc_;
4348 TNode<RawPtrT> base_;
4349 TNode<RawPtrT> fp_;
4363 TNode<String> string, Flags flags = Flags());
4369 TNode<String> TryToDirect(Label* if_bailout);
4373 TNode<RawPtrT> PointerToData(Label* if_bailout) {
4379 TNode<RawPtrT> PointerToString(Label* if_bailout) {
4383 TNode<String> string() { return var_string_.value(); }
4384 TNode<Int32T> instance_type() { return var_instance_type_.value(); }
4385 TNode<IntPtrT> offset() { return var_offset_.value(); }
4386 TNode<Word32T> is_external() { return var_is_external_.value(); }
4389 TNode<RawPtrT> TryToSequential(StringPointerKind ptr_kind, Label* if_bailout);
4423 TNode<NativeContext> native_context,
4424 TNode<Map> initial_prototype_map,
4427 void CheckAndBranch(TNode<HeapObject> prototype, Label* if_unmodified,
4432 const TNode<NativeContext> native_context_;
4433 const TNode<Map> initial_prototype_map_;
4446 inline TNode<Map> CodeStubAssembler::GetClassMapConstant<class_name>() { \