Lines Matching refs:value
259 Object value = from.ValueAt(entry);
260 DCHECK(!value.IsTheHole(isolate));
261 to.set(i + to_start, value, write_barrier_mode);
308 Handle<Object> value =
310 to->set(i + to_start, *value, UPDATE_WRITE_BARRIER);
499 Handle<Object> value, size_t start_from,
501 bool search_for_hole = value->IsUndefined(isolate);
512 if (value->SameValueZero(*element_k)) return Just(true);
519 Handle<Object> value, size_t start_from,
530 if (value->StrictEquals(*element_k)) return Just<int64_t>(k);
650 void Set(Handle<JSObject> holder, InternalIndex entry, Object value) final {
651 Subclass::SetImpl(holder, entry, value);
655 InternalIndex entry, Handle<Object> value,
657 Subclass::ReconfigureImpl(object, store, entry, value, attributes);
662 Handle<Object> value,
667 Maybe<bool> Add(Handle<JSObject> object, uint32_t index, Handle<Object> value,
669 return Subclass::AddImpl(object, index, value, attributes, new_capacity);
673 Handle<Object> value,
1083 Handle<Object> value;
1085 value = Subclass::GetInternalImpl(object, entry);
1090 isolate, value, Object::GetProperty(&it), Nothing<bool>());
1092 if (get_entries) value = MakeEntryPair(isolate, index, value);
1093 values_or_entries->set(count++, *value);
1114 Handle<Object> value;
1116 ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, value, Object::GetProperty(&it),
1119 if (get_entries) value = MakeEntryPair(isolate, index, value);
1120 values_or_entries->set(count++, *value);
1295 Handle<Object> value, size_t start_from,
1297 return IncludesValueSlowPath(isolate, receiver, value, start_from, length);
1301 Handle<Object> value, size_t start_from,
1303 return Subclass::IncludesValueImpl(isolate, receiver, value, start_from,
1309 Handle<Object> value,
1311 return IndexOfValueSlowPath(isolate, receiver, value, start_from, length);
1315 Handle<Object> value, size_t start_from,
1317 return Subclass::IndexOfValueImpl(isolate, receiver, value, start_from,
1322 Handle<Object> value,
1328 Handle<Object> value,
1330 return Subclass::LastIndexOfValueImpl(receiver, value, start_from);
1509 Object value) {
1510 SetImpl(holder->elements(), entry, value);
1514 Object value) {
1515 NumberDictionary::cast(backing_store).ValueAtPut(entry, value);
1520 Handle<Object> value,
1524 dictionary.ValueAtPut(entry, *value);
1534 Handle<Object> value,
1545 object->GetIsolate(), dictionary, index, value, details);
1672 Object value = dictionary->ValueAt(isolate, i);
1673 DCHECK(!value.IsTheHole(isolate));
1674 DCHECK(!value.IsAccessorPair());
1675 DCHECK(!value.IsAccessorInfo());
1676 RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert));
1682 Handle<Object> value, size_t start_from,
1708 if (value->SameValueZero(element_k)) found = true;
1718 Handle<Object> value, size_t start_from,
1721 bool search_for_hole = value->IsUndefined(isolate);
1726 isolate, receiver, value, start_from, length, &result)) {
1749 if (value->SameValueZero(element_k)) return Just(true);
1763 if (value->SameValueZero(*element_k)) return Just(true);
1767 return IncludesValueSlowPath(isolate, receiver, value, k + 1,
1785 return accessor->IncludesValue(isolate, receiver, value, k + 1,
1799 Handle<Object> value,
1821 if (value->StrictEquals(element_k)) {
1837 if (value->StrictEquals(*element_k)) return Just<int64_t>(k);
1841 return IndexOfValueSlowPath(isolate, receiver, value, k + 1,
1851 return IndexOfValueSlowPath(isolate, receiver, value, k + 1,
1922 Handle<Object> value =
1925 NumberDictionary::Add(isolate, dictionary, i, value, details);
2030 Handle<Object> value,
2036 value, attributes);
2040 Handle<Object> value,
2061 Subclass::SetImpl(object, InternalIndex(index), *value);
2245 Object value = *search_value;
2251 if (value == undefined && elements_length < length) return Just(true);
2253 DCHECK_NE(value, undefined);
2260 if (!value.IsNumber()) {
2261 if (value == undefined) {
2292 // Search for non-number, non-Undefined value, with either
2298 // Search for non-number, non-Undefined value with either
2307 if (value.SameValueZero(element_k)) return Just(true);
2312 if (!value.IsNaN()) {
2313 double search_number = value.Number();
2385 Handle<Object> value;
2386 value = Subclass::GetImpl(isolate, *elements, entry);
2387 if (value->IsName()) {
2388 value = isolate->factory()->InternalizeName(Handle<Name>::cast(value));
2390 result->set(i, *value);
2485 Object value) {
2486 SetImpl(holder->elements(), entry, value);
2490 Object value) {
2491 FixedArray::cast(backing_store).set(entry.as_int(), value);
2495 Object value, WriteBarrierMode mode) {
2496 FixedArray::cast(backing_store).set(entry.as_int(), value, mode);
2570 Handle<Object> value = Subclass::GetImpl(isolate, *elements, entry);
2571 value = MakeEntryPair(isolate, index, value);
2572 values_or_entries->set(count++, *value);
2582 Object value = GetRaw(elements, entry);
2583 values_or_entries->set(count++, value);
2597 Object value = *search_value;
2604 if (!value.IsNumber() && !IsObjectElementsKind(Subclass::kind()) &&
2609 if (value.IsNaN()) return Just<int64_t>(-1);
2619 if (value.StrictEquals(elements.get(static_cast<uint32_t>(k)))) {
2654 Handle<Object> value,
2752 Handle<Object> value,
2822 Object value) {
2827 Object value) {
2832 Object value, WriteBarrierMode mode) {
2865 Handle<Object> value,
2879 Handle<Object> value,
2911 Object value) {
2912 SetImpl(holder->elements(), entry, value);
2916 Object value) {
2917 FixedDoubleArray::cast(backing_store).set(entry.as_int(), value.Number());
2921 Object value, WriteBarrierMode mode) {
2922 FixedDoubleArray::cast(backing_store).set(entry.as_int(), value.Number());
2983 Handle<Object> value = Subclass::GetImpl(isolate, *elements, entry);
2985 value = MakeEntryPair(isolate, index, value);
2987 values_or_entries->set(count++, *value);
3000 Object value = *search_value;
3006 if (!value.IsNumber()) {
3009 if (value.IsNaN()) {
3012 double numeric_search_value = value.Number();
3052 static ElementType FromScalar(int value) {
3053 return static_cast<ElementType>(value);
3055 static ElementType FromScalar(uint32_t value) {
3056 return static_cast<ElementType>(value);
3058 static ElementType FromScalar(double value) {
3059 return FromScalar(DoubleToInt32(value));
3061 static ElementType FromScalar(int64_t value) { UNREACHABLE(); }
3062 static ElementType FromScalar(uint64_t value) { UNREACHABLE(); }
3065 static ElementType FromObject(Object value, bool* lossless = nullptr) {
3066 if (value.IsSmi()) {
3067 return FromScalar(Smi::ToInt(value));
3068 } else if (value.IsHeapNumber()) {
3069 return FromScalar(HeapNumber::cast(value).value());
3073 DCHECK(value.IsUndefined());
3074 return FromScalar(Oddball::cast(value).to_number_raw());
3077 static ElementType FromHandle(Handle<Object> value,
3079 return FromObject(*value, lossless);
3082 // Conversion of scalar value to handlified object.
3083 static Handle<Object> ToHandle(Isolate* isolate, ElementType value);
3086 Object value) {
3092 SetImpl(entry_ptr, FromObject(value), is_shared);
3095 static void SetImpl(ElementType* data_ptr, ElementType value,
3102 base::WriteUnalignedValue(reinterpret_cast<Address>(data_ptr), value);
3115 value, std::memory_order_relaxed);
3133 CHECK_EQ(sizeof(words), sizeof(value));
3134 memcpy(words, &value, sizeof(value));
3271 Handle<Object> value =
3273 RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert));
3287 Handle<Object> value =
3290 value = MakeEntryPair(isolate, index, value);
3292 values_or_entries->set(count++, *value);
3300 Handle<Object> value, size_t start,
3307 ElementType scalar = FromHandle(value);
3331 Handle<Object> value, size_t start_from,
3337 return Just(value->IsUndefined(isolate) && length > start_from);
3343 return Just(value->IsUndefined(isolate) && length > start_from);
3346 if (value->IsUndefined(isolate) && length > new_length) {
3363 if (!value->IsBigInt()) return Just(false);
3365 typed_search_value = FromHandle(value, &lossless);
3368 if (!value->IsNumber()) return Just(false);
3369 double search_value = value->Number();
3387 // Return false if value can't be represented in this space.
3405 Handle<Object> value,
3433 if (!value->IsBigInt()) return Just<int64_t>(-1);
3435 typed_search_value = FromHandle(value, &lossless);
3438 if (!value->IsNumber()) return Just<int64_t>(-1);
3439 double search_value = value->Number();
3450 // Return false if value can't be represented in this ElementsKind.
3468 Handle<Object> value,
3480 if (!value->IsBigInt()) return Just<int64_t>(-1);
3482 typed_search_value = FromHandle(value, &lossless);
3485 if (!value->IsNumber()) return Just<int64_t>(-1);
3486 double search_value = value->Number();
3488 if (std::is_integral<ElementType>::value) {
3497 // Return -1 if value can't be represented in this ElementsKind.
3560 Handle<Object> value =
3562 result->set(i, *value);
3834 // b. Let value be ? Get(src, Pk).
3839 // d. Perform ? IntegerIndexedElementSet(target, targetIndex, value).
3843 // 1. If O.[[ContentType]] is BigInt, let numValue be ? ToBigInt(value).
3847 // 2. Otherwise, let numValue be ? ToNumber(value).
3934 Isolate* isolate, int8_t value) {
3935 return handle(Smi::FromInt(value), isolate);
3941 Isolate* isolate, uint8_t value) {
3942 return handle(Smi::FromInt(value), isolate);
3948 Isolate* isolate, int16_t value) {
3949 return handle(Smi::FromInt(value), isolate);
3955 Isolate* isolate, uint16_t value) {
3956 return handle(Smi::FromInt(value), isolate);
3962 Isolate* isolate, int32_t value) {
3963 return isolate->factory()->NewNumberFromInt(value);
3969 Isolate* isolate, uint32_t value) {
3970 return isolate->factory()->NewNumberFromUint(value);
3975 float TypedElementsAccessor<FLOAT32_ELEMENTS, float>::FromScalar(double value) {
3976 return DoubleToFloat32(value);
3982 Isolate* isolate, float value) {
3983 return isolate->factory()->NewNumber(value);
3989 double value) {
3990 return value;
3996 Isolate* isolate, double value) {
3997 return isolate->factory()->NewNumber(value);
4003 int value) {
4004 if (value < 0x00) return 0x00;
4005 if (value > 0xFF) return 0xFF;
4006 return static_cast<uint8_t>(value);
4012 uint32_t value) {
4015 if (value > 0xFF) return 0xFF;
4016 return static_cast<uint8_t>(value);
4022 double value) {
4024 if (!(value > 0)) return 0;
4025 if (value > 0xFF) return 0xFF;
4026 return static_cast<uint8_t>(lrint(value));
4032 Isolate* isolate, uint8_t value) {
4033 return handle(Smi::FromInt(value), isolate);
4039 int value) {
4046 uint32_t value) {
4053 double value) {
4060 int64_t value) {
4061 return value;
4067 uint64_t value) {
4068 return static_cast<int64_t>(value);
4074 Object value, bool* lossless) {
4075 return BigInt::cast(value).AsInt64(lossless);
4081 Isolate* isolate, int64_t value) {
4082 return BigInt::FromInt64(isolate, value);
4088 int value) {
4095 uint32_t value) {
4102 double value) {
4109 int64_t value) {
4110 return static_cast<uint64_t>(value);
4116 uint64_t value) {
4117 return value;
4123 Object value, bool* lossless) {
4124 return BigInt::cast(value).AsUint64(lossless);
4130 Isolate* isolate, uint64_t value) {
4131 return BigInt::FromUint64(isolate, value);
4137 Isolate* isolate, int8_t value) {
4138 return handle(Smi::FromInt(value), isolate);
4145 uint8_t value) {
4146 return handle(Smi::FromInt(value), isolate);
4153 int16_t value) {
4154 return handle(Smi::FromInt(value), isolate);
4161 uint16_t value) {
4162 return handle(Smi::FromInt(value), isolate);
4169 int32_t value) {
4170 return isolate->factory()->NewNumberFromInt(value);
4177 uint32_t value) {
4178 return isolate->factory()->NewNumberFromUint(value);
4184 double value) {
4185 return DoubleToFloat32(value);
4192 float value) {
4193 return isolate->factory()->NewNumber(value);
4199 double value) {
4200 return value;
4207 double value) {
4208 return isolate->factory()->NewNumber(value);
4214 uint8_t>::FromScalar(int value) {
4215 if (value < 0x00) return 0x00;
4216 if (value > 0xFF) return 0xFF;
4217 return static_cast<uint8_t>(value);
4223 uint8_t>::FromScalar(uint32_t value) {
4226 if (value > 0xFF) return 0xFF;
4227 return static_cast<uint8_t>(value);
4233 uint8_t>::FromScalar(double value) {
4235 if (!(value > 0)) return 0;
4236 if (value > 0xFF) return 0xFF;
4237 return static_cast<uint8_t>(lrint(value));
4244 uint8_t value) {
4245 return handle(Smi::FromInt(value), isolate);
4251 int value) {
4258 uint32_t value) {
4265 double value) {
4272 int64_t value) {
4273 return value;
4279 uint64_t value) {
4280 return static_cast<int64_t>(value);
4286 Object value, bool* lossless) {
4287 return BigInt::cast(value).AsInt64(lossless);
4294 int64_t value) {
4295 return BigInt::FromInt64(isolate, value);
4301 uint64_t>::FromScalar(int value) {
4308 uint64_t>::FromScalar(uint32_t value) {
4315 uint64_t>::FromScalar(double value) {
4322 uint64_t>::FromScalar(int64_t value) {
4323 return static_cast<uint64_t>(value);
4329 uint64_t>::FromScalar(uint64_t value) {
4330 return value;
4336 uint64_t>::FromObject(Object value,
4338 return BigInt::cast(value).AsUint64(lossless);
4345 uint64_t value) {
4346 return BigInt::FromUint64(isolate, value);
4397 Object value) {
4398 SetImpl(holder->elements(), entry, value);
4402 Object value) {
4413 context.set(context_entry, value);
4424 context.set(context_entry, value);
4426 ArgumentsAccessor::SetImpl(arguments, entry.adjust_down(length), value);
4480 Handle<Object> value = GetImpl(isolate, *elements, entry);
4481 RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert));
4616 Handle<Object> value, size_t start_from,
4622 bool search_for_hole = value->IsUndefined(isolate);
4643 if (value->SameValueZero(*element_k)) return Just(true);
4647 return IncludesValueSlowPath(isolate, object, value, k + 1, length);
4649 } else if (value->SameValueZero(*element_k)) {
4658 Handle<Object> value,
4683 if (value->StrictEquals(*element_k)) {
4689 return IndexOfValueSlowPath(isolate, object, value, k + 1, length);
4691 } else if (value->StrictEquals(*element_k)) {
4732 Handle<Object> value,
4747 NumberDictionary::Add(isolate, dictionary, index, value, details);
4757 Handle<Object> value,
4769 context.set(context_entry, *value);
4776 value = isolate->factory()->NewAliasedArgumentsEntry(context_entry);
4784 value, details);
4793 object, arguments, entry.adjust_down(length), value, attributes);
4850 Handle<Object> value,
4865 // sure that there's enough space to store the value. We cannot convert
4870 *value);
4876 Handle<Object> value,
4883 value, attributes);
4987 Object value) {
4993 value);
4997 Handle<Object> value,
5010 BackingStoreAccessor::AddImpl(object, index, value, attributes,
5017 Handle<Object> value,
5024 object, store, entry.adjust_down(length), value, attributes);
5104 DCHECK(js_value.value().IsString());
5105 return String::cast(js_value.value());