Lines Matching defs:value
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) {
341 return Signed(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);
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);
402 TNode<Smi> TaggedToSmi(TNode<Object> value, Label* fail) {
403 GotoIf(TaggedIsNotSmi(value), fail);
404 return UncheckedCast<Smi>(value);
407 TNode<Smi> TaggedToPositiveSmi(TNode<Object> value, Label* fail) {
408 GotoIfNot(TaggedIsPositiveSmi(value), fail);
409 return UncheckedCast<Smi>(value);
412 TNode<String> TaggedToDirectString(TNode<Object> value, Label* fail);
414 TNode<HeapObject> TaggedToHeapObject(TNode<Object> value, Label* fail) {
415 GotoIf(TaggedIsSmi(value), fail);
416 return UncheckedCast<HeapObject>(value);
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);
557 int* value);
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);
586 // Returns true iff the given value fits into smi range and is >= 0.
587 TNode<BoolT> IsValidPositiveSmi(TNode<IntPtrT> value);
589 // Tag an IntPtr as a Smi value.
590 TNode<Smi> SmiTag(TNode<IntPtrT> value);
591 // Untag a Smi value as an IntPtr.
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);
669 // The number of shift bits is |shift % 64| for 64-bits value and |shift %
670 // 32| for 32-bits value. The DCHECK is to ensure valid inputs.
763 TNode<Number> NumberInc(TNode<Number> value);
764 TNode<Number> NumberDec(TNode<Number> value);
767 void GotoIfNotNumber(TNode<Object> value, Label* is_not_number);
768 void GotoIfNumber(TNode<Object> value, Label* is_number);
902 TNode<Object> value);
932 TVARIABLE(T, value);
938 value = true_body();
943 value = false_body();
948 return value.value();
986 TNode<Int32T> TruncateWordToInt32(TNode<WordT> value);
987 TNode<Int32T> TruncateIntPtrToInt32(TNode<IntPtrT> value);
989 // Check a value for smi-ness
993 // Check that the value is a non-negative smi.
997 TNode<BoolT> WordIsPowerOfTwo(TNode<IntPtrT> value);
999 // Check if lower_limit <= value <= higher_limit.
1001 TNode<BoolT> IsInRange(TNode<Word32T> value, U lower_limit, U higher_limit) {
1004 return Uint32LessThanOrEqual(Int32Sub(value, Int32Constant(lower_limit)),
1008 TNode<BoolT> IsInRange(TNode<WordT> value, intptr_t lower_limit,
1011 return UintPtrLessThanOrEqual(IntPtrSub(value, IntPtrConstant(lower_limit)),
1041 void BranchIfFloat64IsNaN(TNode<Float64T> value, Label* if_true,
1043 Branch(Float64Equal(value, value), if_false, if_true);
1046 // Branches to {if_true} if ToBoolean applied to {value} yields true,
1048 void BranchIfToBooleanIsTrue(TNode<Object> value, Label* if_true,
1051 // Branches to {if_false} if ToBoolean applied to {value} yields false,
1053 void BranchIfToBooleanIsFalse(TNode<Object> value, Label* if_false,
1055 BranchIfToBooleanIsTrue(value, if_true, if_false);
1072 // Load a caged pointer value from an object.
1081 // Stored a caged pointer value to an object.
1109 // Initialize an external pointer field in an object with given value.
1125 // Load an external pointer value from an object.
1178 TNode<RawPtrT> value) {
1180 value);
1183 // Load value from current parent frame by given offset in bytes.
1193 Load(MachineTypeOf<T>::value, buffer, IntPtrConstant(offset)));
1208 std::is_convertible<TNode<T>, TNode<Object>>::value &&
1209 std::is_base_of<T, Map>::value,
1214 : MachineTypeOf<T>::value;
1219 std::is_convertible<TNode<T>, TNode<Object>>::value &&
1220 !std::is_base_of<T, Map>::value,
1223 return CAST(LoadFromObject(MachineTypeOf<T>::value, object,
1227 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value,
1231 LoadFromObject(MachineTypeOf<T>::value, object,
1246 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value,
1250 LoadFromObject(MachineTypeOf<T>::value, object,
1273 // Reference is the CSA-equivalent of a Torque reference value, representing
1292 std::is_convertible<TNode<T>, TNode<Object>>::value,
1297 DCHECK((std::is_base_of<T, Map>::value));
1305 LoadFromObject(MachineTypeOf<T>::value, reference.object, offset));
1309 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value ||
1310 std::is_same<T, MaybeObject>::value,
1317 LoadFromObject(MachineTypeOf<T>::value, reference.object, offset));
1320 std::is_convertible<TNode<T>, TNode<Object>>::value ||
1321 std::is_same<T, MaybeObject>::value,
1323 void StoreReference(Reference reference, TNode<T> value) {
1325 DCHECK((std::is_base_of<T, Map>::value));
1326 return StoreMap(CAST(reference.object), ReinterpretCast<Map>(value));
1328 MachineRepresentation rep = MachineRepresentationOf<T>::value;
1330 if (std::is_same<T, Smi>::value) {
1332 } else if (std::is_same<T, Map>::value) {
1338 StoreToObject(rep, reference.object, offset, value, write_barrier);
1341 std::is_convertible<TNode<T>, TNode<UntaggedT>>::value,
1343 void StoreReference(Reference reference, TNode<T> value) {
1347 StoreToObject(MachineRepresentationOf<T>::value, reference.object, offset,
1348 value, StoreToObjectWriteBarrier::kNone);
1358 // Load the floating point value of a HeapNumber.
1440 // Load the Name::hash() value of a name as an uint32 value.
1447 // Load length field of a String object as Smi value.
1449 // Load length field of a String object as intptr_t value.
1451 // Load length field of a String object as uint32_t value.
1453 // Load value field of a JSPrimitiveWrapper object.
1456 // Figures out whether the value of maybe_object is:
1457 // - a SMI (jump to "if_smi", "extracted" will be the SMI value)
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) {
1475 return Word32BinaryNot(IsCleared(value));
1479 TNode<HeapObject> GetHeapObjectAssumeWeak(TNode<MaybeObject> value);
1481 TNode<HeapObject> GetHeapObjectAssumeWeak(TNode<MaybeObject> value,
1494 TNode<MaybeObject> MakeWeak(TNode<HeapObject> value);
1577 // it as a tagged value. Assumes that the |index| passed a length
1597 // Load Float64 value by |base| + |offset| address. If the value is a double
1615 TNode<BigInt> BigIntFromInt64(TNode<IntPtrT> value);
1616 TNode<BigInt> BigIntFromUint64(TNode<UintPtrT> value);
1627 TNode<Object> value);
1634 void GotoIfContextElementEqual(TNode<Object> value,
1637 GotoIf(TaggedEqual(value, LoadContextElement(native_context, slot_index)),
1666 TNode<Word32T> value);
1668 // Store the floating point value of a HeapNumber.
1669 void StoreHeapNumberValue(TNode<HeapNumber> object, TNode<Float64T> value);
1672 void StoreObjectField(TNode<HeapObject> object, int offset, TNode<Smi> value);
1674 TNode<Smi> value);
1676 TNode<Object> value);
1678 TNode<Object> value);
1681 TNode<IntPtrT> offset, TNode<T> value) {
1684 return StoreObjectFieldNoWriteBarrier<T>(object, const_offset, value);
1686 StoreNoWriteBarrier(MachineRepresentationOf<T>::value, object,
1688 value);
1692 TNode<T> value) {
1693 if (CanBeTaggedPointer(MachineRepresentationOf<T>::value)) {
1694 OptimizedStoreFieldAssertNoWriteBarrier(MachineRepresentationOf<T>::value,
1695 object, offset, value);
1697 OptimizedStoreFieldUnsafeNoWriteBarrier(MachineRepresentationOf<T>::value,
1698 object, offset, value);
1703 int offset, TNode<Object> value);
1715 TNode<FixedArray> object, int index, TNode<Object> value,
1718 return StoreFixedArrayElement(object, IntPtrConstant(index), value,
1723 TNode<Smi> value,
1726 TNode<Object>{value},
1732 TNode<FixedArray> array, TNode<TIndex> index, TNode<Object> value,
1737 static_assert(std::is_same<TIndex, Smi>::value ||
1738 std::is_same<TIndex, UintPtrT>::value ||
1739 std::is_same<TIndex, IntPtrT>::value,
1744 StoreFixedArrayOrPropertyArrayElement(array, index, value, barrier_mode,
1750 TNode<Smi> value, int additional_offset = 0) {
1751 static_assert(std::is_same<TIndex, Smi>::value ||
1752 std::is_same<TIndex, IntPtrT>::value,
1754 StoreFixedArrayElement(array, index, TNode<Object>{value},
1761 TNode<FixedArray> object, int index, TNode<Object> value,
1763 return StoreFixedArrayElement(object, IntPtrConstant(index), value,
1768 TNode<Smi> value) {
1769 return StoreFixedArrayElement(object, IntPtrConstant(index), value,
1775 TNode<FixedArray> array, TNode<IntPtrT> index, TNode<Object> value,
1778 return StoreFixedArrayElement(array, index, value, barrier_mode,
1783 TNode<IntPtrT> index, TNode<Smi> value,
1785 return StoreFixedArrayElement(array, index, value,
1791 TNode<IntPtrT> index, TNode<Object> value) {
1792 StoreFixedArrayOrPropertyArrayElement(array, index, value,
1799 TNode<Float64T> value, CheckBounds check_bounds = CheckBounds::kAlways);
1806 TNode<AnyTaggedT> value,
1812 TNode<Object> value);
1816 TNode<Object> value) {
1822 StoreFixedArrayOrPropertyArrayElement(array, index, value,
1836 TNode<Object> value);
1841 // Pushes value onto the end of array.
1843 TNode<Object> value, Label* bailout);
1847 TNode<Object> value);
1853 TNode<Object> value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
1854 TNode<Cell> AllocateSmiCell(int value = 0) {
1855 return AllocateCellWithValue(SmiConstant(value), SKIP_WRITE_BARRIER);
1860 void StoreCellValue(TNode<Cell> cell, TNode<Object> value,
1863 // Allocate a HeapNumber without initializing its value.
1865 // Allocate a HeapNumber with a specific value.
1866 TNode<HeapNumber> AllocateHeapNumberWithValue(TNode<Float64T> value);
1867 TNode<HeapNumber> AllocateHeapNumberWithValue(double value) {
1868 return AllocateHeapNumberWithValue(Float64Constant(value));
2084 TNode<Object> value,
2090 TNode<Object> value);
2343 // converts the value so that it becomes ready for storing to array of
2393 TNode<IntPtrT> TryTaggedToInt32AsIntPtr(TNode<Object> value,
2395 TNode<Float64T> TryTaggedToFloat64(TNode<Object> value,
2398 TNode<Object> value);
2400 TNode<Object> value);
2401 void TaggedToWord32OrBigInt(TNode<Context> context, TNode<Object> value,
2406 TNode<Object> value, Label* if_number,
2416 TNode<Int32T> TruncateNumberToWord32(TNode<Number> value);
2417 // Truncate the floating point value of a HeapNumber to an Int32.
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);
2443 void TaggedToNumeric(TNode<Context> context, TNode<Object> value,
2445 void TaggedToNumericWithFeedback(TNode<Context> context, TNode<Object> value,
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)));
2479 // Throws a TypeError for {method_name} if {value} is not coercible to Object,
2480 // or returns the {value} converted to a String otherwise.
2481 TNode<String> ToThisString(TNode<Context> context, TNode<Object> value,
2483 TNode<String> ToThisString(TNode<Context> context, TNode<Object> value,
2485 return ToThisString(context, value, StringConstant(method_name));
2488 // Throws a TypeError for {method_name} if {value} is neither of the given
2489 // {primitive_type} nor a JSPrimitiveWrapper wrapping a value of
2490 // {primitive_type}, or returns the {value} (or wrapped value) otherwise.
2491 TNode<Object> ToThisValue(TNode<Context> context, TNode<Object> value,
2495 // Throws a TypeError for {method_name} if {value} is not of the given
2497 void ThrowIfNotInstanceType(TNode<Context> context, TNode<Object> value,
2500 // Throws a TypeError for {method_name} if {value} is not a JSReceiver.
2501 void ThrowIfNotJSReceiver(TNode<Context> context, TNode<Object> value,
2504 void ThrowIfNotCallable(TNode<Context> context, TNode<Object> value,
2685 // True iff |number| is either a Smi, or a HeapNumber whose value is not
2694 // True iff {number} represents an integer value.
2702 // True iff {number} represents a valid uint32t value.
2775 // tc39.github.io/proposal-bigint/#sec-number-constructor-number-value.
2813 // Returns a node that contains a decoded (unsigned!) value of a bit
2820 // Returns a node that contains a decoded (unsigned!) value of a bit
2827 // Returns a node that contains a decoded (unsigned!) value of a bit
2834 // Returns a node that contains a decoded (unsigned!) value of a bit
2842 // Decodes an unsigned (!) value from |word32| to an uint32 node.
2846 // Decodes an unsigned (!) value from |word| to a word-size node.
2851 TNode<Word32T> UpdateWord32(TNode<Word32T> word, TNode<Uint32T> value,
2853 return UpdateWord32(word, value, BitField::kShift, BitField::kMask,
2859 TNode<WordT> UpdateWord(TNode<WordT> word, TNode<UintPtrT> value,
2861 return UpdateWord(word, value, BitField::kShift, BitField::kMask,
2867 TNode<Word32T> UpdateWordInWord32(TNode<Word32T> word, TNode<UintPtrT> value,
2871 ChangeUint32ToWord(word), value, starts_as_zero))));
2876 TNode<WordT> UpdateWord32InWord(TNode<WordT> word, TNode<Uint32T> value,
2878 return UpdateWord<BitField>(word, ChangeUint32ToWord(value),
2882 // Returns a node that contains the updated {value} inside {word} starting
2884 TNode<Word32T> UpdateWord32(TNode<Word32T> word, TNode<Uint32T> value,
2888 // Returns a node that contains the updated {value} inside {word} starting
2890 TNode<WordT> UpdateWord(TNode<WordT> word, TNode<UintPtrT> value,
2919 // constant |value|. Avoids a shift compared to using DecodeWord32.
2922 typename BitField::FieldType value) {
2925 return Word32Equal(masked_word32, Int32Constant(BitField::encode(value)));
2929 // given constant |value|. Avoids a shift compared to using DecodeWord32.
2932 typename BitField::FieldType value) {
2933 return Word32BinaryNot(IsEqualInWord32<BitField>(word32, value));
2979 void SetCounter(StatsCounter* counter, int value);
2984 void Increment(TVariable<TIndex>* variable, int value = 1);
2987 void Decrement(TVariable<TIndex>* variable, int value = 1) {
2988 Increment(variable, -value);
3052 // Loads the value for the entry with the given key_index.
3053 // Returns a tagged value.
3064 // Stores the value for the entry with the given key_index.
3068 TNode<Object> value,
3089 STATIC_ASSERT(!(std::is_same<Dictionary, SwissNameDictionary>::value));
3098 STATIC_ASSERT(!(std::is_same<Dictionary, SwissNameDictionary>::value));
3108 STATIC_ASSERT(!(std::is_same<Dictionary, SwissNameDictionary>::value));
3118 STATIC_ASSERT(!(std::is_same<Dictionary, SwissNameDictionary>::value));
3170 TNode<Object> value, TNode<IntPtrT> index,
3174 void Add(TNode<Dictionary> dictionary, TNode<Name> key, TNode<Object> value,
3199 // Tries to get {object}'s own {unique_name} property value. If the property
3201 // field it re-wraps value in an immutable heap number. {unique_name} must be
3228 TNode<Object> value) {
3229 return CallBuiltin(Builtin::kSetProperty, context, receiver, key, value);
3234 TNode<Object> value) {
3236 value);
3325 // index with a simple check, return False. Note that "False" return value
3379 // Load the value from closure's feedback cell.
3440 // Store value to an elements array with given elements kind.
3442 // we pass {value} as BigInt object instead of int64_t. We should
3446 TNode<TIndex> index, TNode<TValue> value);
3456 TNode<Object> value, ElementsKind elements_kind,
3482 TNode<HeapObject> value, int additional_offset = 0);
3610 void BranchIfAccessorPair(TNode<Object> value, Label* if_accessor_pair,
3612 GotoIf(TaggedIsSmi(value), if_not_accessor_pair);
3613 Branch(IsAccessorPair(CAST(value)), if_accessor_pair, if_not_accessor_pair);
3664 TNode<String> Typeof(TNode<Object> value);
3837 bool ConstexprBoolNot(bool value) { return !value; }
4006 std::function<void(TNode<Name> key, TNode<Object> value)>;
4009 // enumerable, and if so, load the value from the receiver and evaluate the
4018 TNode<Object> value, TNode<HeapObject> holder, TNode<Uint32T> details,
4072 // capacity value (prior to the incrementation). Otherwise, goto |bailout|.
4096 TNode<Object> value);
4124 TNode<Object> value,
4153 // Increases the provided capacity to the next valid value, if necessary.
4183 void GenerateEqual_Same(TNode<Object> value, Label* if_equal,
4194 void TaggedToNumeric(TNode<Context> context, TNode<Object> value,
4200 void TaggedToWord32OrBigIntImpl(TNode<Context> context, TNode<Object> value,
4229 TNode<Object> value, WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
4234 TNode<TIndex> index, TNode<BigInt> value);
4238 TNode<TIndex> index, TNode<Word32T> value);
4240 // Store value to an elements array with given elements kind.
4242 // we pass {value} as BigInt object instead of int64_t. We should
4248 TNode<TIndex> index, TNode<TValue> value);
4252 TNode<TIndex> index, TNode<Object> value);
4256 TNode<TIndex> index, TNode<Float64T> value);
4269 TNode<IntPtrT> key, TNode<Object> value,
4277 TNode<Object> value, ElementsKind elements_kind,
4343 void PopAndReturn(TNode<Object> value);
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(); }
4414 // (stored as a root), and the property's expected value (stored on the native