Lines Matching refs:value
34 constexpr MachineType MachineTypeOf<Smi>::value;
35 constexpr MachineType MachineTypeOf<Object>::value;
36 constexpr MachineType MachineTypeOf<MaybeObject>::value;
40 static_assert(std::is_convertible<TNode<Number>, TNode<Object>>::value,
43 std::is_convertible<TNode<Number>, TNode<UnionT<Smi, HeapObject>>>::value,
46 !std::is_convertible<TNode<UnionT<Smi, HeapObject>>, TNode<Number>>::value,
256 TNode<Int32T> CodeAssembler::Int32Constant(int32_t value) {
257 return UncheckedCast<Int32T>(jsgraph()->Int32Constant(value));
260 TNode<Int64T> CodeAssembler::Int64Constant(int64_t value) {
261 return UncheckedCast<Int64T>(jsgraph()->Int64Constant(value));
264 TNode<IntPtrT> CodeAssembler::IntPtrConstant(intptr_t value) {
265 return UncheckedCast<IntPtrT>(jsgraph()->IntPtrConstant(value));
268 TNode<TaggedIndex> CodeAssembler::TaggedIndexConstant(intptr_t value) {
269 DCHECK(TaggedIndex::IsValid(value));
270 return UncheckedCast<TaggedIndex>(raw_assembler()->IntPtrConstant(value));
273 TNode<Number> CodeAssembler::NumberConstant(double value) {
275 if (DoubleToSmiInteger(value, &smi_value)) {
283 isolate()->factory()->NewHeapNumberForCodeAssembler(value)));
287 TNode<Smi> CodeAssembler::SmiConstant(Smi value) {
289 IntPtrConstant(static_cast<intptr_t>(value.ptr()))));
292 TNode<Smi> CodeAssembler::SmiConstant(int value) {
293 return SmiConstant(Smi::FromInt(value));
307 TNode<Oddball> CodeAssembler::BooleanConstant(bool value) {
308 Handle<Object> object = isolate()->factory()->ToBoolean(value);
319 TNode<Float32T> CodeAssembler::Float32Constant(double value) {
320 return UncheckedCast<Float32T>(jsgraph()->Float32Constant(value));
323 TNode<Float64T> CodeAssembler::Float64Constant(double value) {
324 return UncheckedCast<Float64T>(jsgraph()->Float64Constant(value));
372 intptr_t value = m.ResolvedValue();
373 // Make sure that the value is actually a smi
374 CHECK_EQ(0, value & ((static_cast<intptr_t>(1) << kSmiShiftSize) - 1));
375 *out_value = Smi(static_cast<Address>(value));
424 void CodeAssembler::Return(TNode<Object> value) {
427 return raw_assembler()->Return(value);
446 void CodeAssembler::Return(TNode<Int32T> value) {
450 return raw_assembler()->Return(value);
453 void CodeAssembler::Return(TNode<Uint32T> value) {
457 return raw_assembler()->Return(value);
460 void CodeAssembler::Return(TNode<WordT> value) {
465 return raw_assembler()->Return(value);
468 void CodeAssembler::Return(TNode<Float32T> value) {
472 return raw_assembler()->Return(value);
475 void CodeAssembler::Return(TNode<Float64T> value) {
479 return raw_assembler()->Return(value);
502 void CodeAssembler::PopAndReturn(Node* pop, Node* value) {
504 return raw_assembler()->PopAndReturn(pop, value);
507 void CodeAssembler::ReturnIf(TNode<BoolT> condition, TNode<Object> value) {
511 Return(value);
531 void CodeAssembler::StaticAssert(TNode<BoolT> value, const char* source) {
532 raw_assembler()->StaticAssert(value, source);
576 TNode<WordT> CodeAssembler::WordShl(TNode<WordT> value, int shift) {
577 return (shift != 0) ? WordShl(value, IntPtrConstant(shift)) : value;
580 TNode<WordT> CodeAssembler::WordShr(TNode<WordT> value, int shift) {
581 return (shift != 0) ? WordShr(value, IntPtrConstant(shift)) : value;
584 TNode<WordT> CodeAssembler::WordSar(TNode<WordT> value, int shift) {
585 return (shift != 0) ? WordSar(value, IntPtrConstant(shift)) : value;
588 TNode<Word32T> CodeAssembler::Word32Shr(TNode<Word32T> value, int shift) {
589 return (shift != 0) ? Word32Shr(value, Int32Constant(shift)) : value;
592 TNode<Word32T> CodeAssembler::Word32Sar(TNode<Word32T> value, int shift) {
593 return (shift != 0) ? Word32Sar(value, Int32Constant(shift)) : value;
614 TNode<UintPtrT> CodeAssembler::ChangeUint32ToWord(TNode<Word32T> value) {
617 raw_assembler()->ChangeUint32ToUint64(value));
619 return ReinterpretCast<UintPtrT>(value);
622 TNode<IntPtrT> CodeAssembler::ChangeInt32ToIntPtr(TNode<Word32T> value) {
624 return UncheckedCast<IntPtrT>(raw_assembler()->ChangeInt32ToInt64(value));
626 return ReinterpretCast<IntPtrT>(value);
629 TNode<IntPtrT> CodeAssembler::ChangeFloat64ToIntPtr(TNode<Float64T> value) {
631 return UncheckedCast<IntPtrT>(raw_assembler()->ChangeFloat64ToInt64(value));
633 return UncheckedCast<IntPtrT>(raw_assembler()->ChangeFloat64ToInt32(value));
636 TNode<UintPtrT> CodeAssembler::ChangeFloat64ToUintPtr(TNode<Float64T> value) {
639 raw_assembler()->ChangeFloat64ToUint64(value));
641 return UncheckedCast<UintPtrT>(raw_assembler()->ChangeFloat64ToUint32(value));
644 TNode<Float64T> CodeAssembler::ChangeUintPtrToFloat64(TNode<UintPtrT> value) {
649 raw_assembler()->RoundUint64ToFloat64(value));
651 return UncheckedCast<Float64T>(raw_assembler()->ChangeUint32ToFloat64(value));
654 TNode<Float64T> CodeAssembler::RoundIntPtrToFloat64(Node* value) {
656 return UncheckedCast<Float64T>(raw_assembler()->RoundInt64ToFloat64(value));
658 return UncheckedCast<Float64T>(raw_assembler()->ChangeInt32ToFloat64(value));
661 TNode<Int32T> CodeAssembler::TruncateFloat32ToInt32(TNode<Float32T> value) {
663 value, TruncateKind::kSetOverflowToMin));
717 Node* CodeAssembler::PackMapWord(Node* value) {
719 BitcastTaggedToWordForTagAndSmiBits(UncheckedCast<AnyTaggedT>(value));
762 void CodeAssembler::Store(Node* base, Node* value) {
763 raw_assembler()->Store(MachineRepresentation::kTagged, base, value,
769 Node* value,
787 raw_assembler()->StoreToObject(rep, object, offset, value,
793 Node* value) {
794 raw_assembler()->OptimizedStoreField(rep, object, offset, value,
800 Node* value) {
801 raw_assembler()->OptimizedStoreField(rep, object, offset, value,
807 Node* value) {
808 raw_assembler()->OptimizedStoreField(rep, object, offset, value,
817 void CodeAssembler::Store(Node* base, Node* offset, Node* value) {
818 // Please use OptimizedStoreMap(base, value) instead.
820 raw_assembler()->Store(MachineRepresentation::kTagged, base, offset, value,
824 void CodeAssembler::StoreEphemeronKey(Node* base, Node* offset, Node* value) {
826 raw_assembler()->Store(MachineRepresentation::kTagged, base, offset, value,
831 Node* value) {
833 rep, base, value,
838 Node* offset, Node* value) {
839 // Please use OptimizedStoreMap(base, value) instead.
842 rep, base, offset, value,
847 Node* base, Node* value) {
848 raw_assembler()->Store(rep, base, value, kNoWriteBarrier);
853 Node* value) {
854 // Please use OptimizedStoreMap(base, value) instead.
856 raw_assembler()->Store(rep, base, offset, value, kNoWriteBarrier);
876 TNode<WordT> offset, TNode<Word32T> value) {
880 base, offset, value);
884 TNode<WordT> offset, TNode<UintPtrT> value,
889 base, offset, value, value_high);
895 TNode<Word32T> value) { \
897 raw_assembler()->Atomic##name(type, base, offset, value)); \
901 TNode<RawPtrT> base, TNode<UintPtrT> offset, TNode<UintPtrT> value, \
904 raw_assembler()->Atomic##name##64(base, offset, value, value_high)); \
907 (TNode<RawPtrT> base, TNode<UintPtrT> offset, TNode<UintPtrT> value, \
911 TNode<UintPtrT> value, TNode<UintPtrT> value_high);
951 void CodeAssembler::StoreRoot(RootIndex root_index, TNode<Object> value) {
956 StoreFullTaggedNoWriteBarrier(isolate_root, IntPtrConstant(offset), value);
959 Node* CodeAssembler::Projection(int index, Node* value) {
960 DCHECK_LT(index, value->op()->ValueOutputCount());
961 return raw_assembler()->Projection(index, value);
1445 void CodeAssemblerVariable::Bind(Node* value) { impl_->value_ = value; }
1447 Node* CodeAssemblerVariable::value() const {
1458 str << "#Accessing variable value outside a block:"
1519 // variable along that path that expects to merge its value into a phi.
1536 // has the same bound value along all paths up until the point you
1537 // bound this label, but then later merged a path with a new value for
1593 for (auto value : i->second) {
1594 DCHECK_NOT_NULL(value);
1595 if (value != shared_value) {
1597 shared_value = value;
1614 << "\n# doesn't have a bound value along all of the paths that "
1633 // Bind all variables to a merge phi, the common value along all paths or
1656 // We use {nullptr} as a sentinel for an uninitialized value.
1671 // We use {nullptr} as a sentinel for an uninitialized value. We must not