Lines Matching refs:index
1189 TNode<FixedDoubleArray> array, TNode<IntPtrT> index, Label* if_hole) {
1190 return LoadFixedDoubleArrayElement(array, index, if_hole);
1579 TNode<Uint32T> index) {
1582 Word32Shl(index, Uint32Constant(kExternalPointerIndexShift));
1605 TNode<Uint32T> index = UncheckedCast<Uint32T>(CallCFunction(
1615 TNode<ExternalPointerT> pointer = ChangeIndexToExternalPointer(index);
1632 TNode<Uint32T> index = ChangeExternalPointerToIndex(encoded);
1636 ChangeUint32ToWord(index), SYSTEM_POINTER_ELEMENTS, 0);
1661 TNode<Uint32T> index = ChangeExternalPointerToIndex(encoded);
1665 ChangeUint32ToWord(index), SYSTEM_POINTER_ELEMENTS, 0);
2261 TNode<FixedArray> object, TNode<TIndex> index, int additional_offset,
2272 FixedArrayBoundsCheck(object, index, additional_offset);
2275 index, additional_offset);
2292 TNode<Smi> index,
2298 bool index_is_constant = TryToSmiConstant(index, &constant_index);
2304 SmiAdd(index, SmiConstant(additional_offset / kTaggedSize));
2310 TNode<IntPtrT> index,
2316 IntPtrAdd(index, IntPtrConstant(additional_offset / kTaggedSize));
2322 TNode<PropertyArray> object, TNode<IntPtrT> index) {
2324 return CAST(LoadArrayElement(object, PropertyArray::kHeaderSize, index,
2547 TNode<RawPtrT> data_pointer, TNode<UintPtrT> index,
2550 ElementOffsetFromIndex(Signed(index), elements_kind, 0);
2580 TNode<RawPtrT> data_pointer, TNode<UintPtrT> index,
2613 var_result = LoadFixedTypedArrayElementAsTagged(data_pointer, index, \
2650 TNode<Array> object, int array_header_size, TNode<IntPtrT> index,
2660 ElementOffsetFromIndex(index, HOLEY_ELEMENTS, header_size);
2671 TNode<FixedArray> object, TNode<IntPtrT> index, int additional_offset) {
2674 index, additional_offset);
2678 TNode<WeakFixedArray> object, TNode<IntPtrT> index, int additional_offset) {
2679 return LoadArrayElement(object, WeakFixedArray::kHeaderSize, index,
2684 TNode<FixedDoubleArray> object, TNode<IntPtrT> index, Label* if_hole,
2688 ElementOffsetFromIndex(index, HOLEY_DOUBLE_ELEMENTS, header_size);
2696 TNode<FixedArrayBase> elements, TNode<IntPtrT> index,
2725 var_result = LoadFixedArrayElement(CAST(elements), index, 0);
2731 var_result = LoadFixedArrayElement(CAST(elements), index);
2738 LoadFixedDoubleArrayElement(CAST(elements), index));
2745 LoadFixedDoubleArrayElement(CAST(elements), index, if_hole));
2752 var_result = BasicLoadNumberDictionaryElement(CAST(elements), index,
3100 "Only Smi, UintPtrT or IntPtrT index is allowed");
3164 TNode<FixedDoubleArray> object, TNode<TIndex> index, TNode<Float64T> value,
3170 "Only Smi, UintPtrT or IntPtrT index is allowed");
3172 FixedArrayBoundsCheck(object, index, 0);
3175 index, PACKED_DOUBLE_ELEMENTS, FixedArray::kHeaderSize - kHeapObjectTag);
3300 TNode<BInt> index,
3309 StoreElement(elements, kind, index, ChangeNumberToFloat64(CAST(value)));
3311 StoreElement(elements, kind, index, value);
4756 TNode<IntPtrT> index) {
4758 index, PACKED_DOUBLE_ELEMENTS, FixedArray::kHeaderSize - kHeapObjectTag);
6737 // Semantics: guaranteed not to be an integer index (i.e. contains non-digit
6754 // index. This returns {true} for strings containing representations of
6758 // check such strings for being within "array index" (uint32_t) range.
7025 TNode<UintPtrT> index) {
7026 CSA_DCHECK(this, UintPtrLessThan(index, LoadStringLengthAsWord(string)));
7036 UintPtrAdd(index, Unsigned(to_direct.offset()));
7060 ChangeUintPtrToTagged(index));
7179 // Sliced string. Fetch parent and correct start index by offset.
7269 // Check if string has a cached array index.
8080 // No cached array index. If the string knows that it contains an index,
8081 // then it must be an uncacheable index. Handle this case in the runtime.
8108 TNode<IntPtrT> index = Signed(
8110 CSA_DCHECK(this, IntPtrLessThan(index, IntPtrConstant(INT_MAX)));
8111 *var_index = index;
8228 TNode<DescriptorArray> object, TNode<IntPtrT> index,
8231 object, DescriptorArray::kHeaderSize, index, additional_offset);
8555 TNode<IntPtrT> index = EntryToIndex<Dictionary>(entry);
8556 *var_name_index = index;
8559 CAST(UnsafeLoadFixedArrayElement(dictionary, index));
8645 TNode<IntPtrT> index = EntryToIndex<NumberDictionary>(entry);
8646 TNode<Object> current = UnsafeLoadFixedArrayElement(dictionary, index);
8687 TNode<IntPtrT> index = EntryToIndex<NumberDictionary>(var_entry.value());
8688 TNode<Uint32T> details = LoadDetailsByKeyIndex(dictionary, index);
8695 return LoadValueByKeyIndex(dictionary, index);
8718 TNode<IntPtrT> index,
8726 TNode<IntPtrT> index, TNode<Smi> enum_index) {
8729 Word32Or(TaggedEqual(LoadFixedArrayElement(dictionary, index),
8731 TaggedEqual(LoadFixedArrayElement(dictionary, index),
8735 StoreFixedArrayElement(dictionary, index, name);
8736 StoreValueByKeyIndex<NameDictionary>(dictionary, index, value);
8744 // We OR over the actual index below, so we expect the initial value to be 0.
8758 StoreDetailsByKeyIndex<NameDictionary>(dictionary, index,
8765 TNode<IntPtrT> index, TNode<Smi> enum_index) {
8913 TNode<Word32T> index = Int32Mul(entry_index, entry_size);
8914 return ChangeInt32ToIntPtr(index);
10083 // out of array index range must be converted to property names.
10100 // If a name is empty or too long, it's not a special index
10109 // to Infinity or NaN, then this is not a special index.
10111 // If the name starts with '-', it can be a negative index.
10118 // that the name is not a special index.
10371 "Only Smi, UintPtrT or IntPtrT index nodes are allowed");
10374 intptr_t index = 0;
10384 index = smi_index.value();
10396 constant_index = TryToIntPtrConstant(intptr_index_node, &index);
10399 constant_index = TryToIntPtrConstant(intptr_index_node, &index);
10402 return IntPtrConstant(base_size + element_size * index);
10706 TNode<TIndex> index,
10712 TNode<IntPtrT> offset = ElementOffsetFromIndex(index, kind, 0);
10741 TNode<UintPtrT> index,
10743 StoreElementTypedArrayBigInt(elements, kind, index, value);
10749 TNode<IntPtrT> index,
10751 StoreElementTypedArrayBigInt(elements, kind, index, value);
10757 TNode<TIndex> index,
10766 TNode<IntPtrT> offset = ElementOffsetFromIndex(index, kind, 0);
10775 TNode<UintPtrT> index,
10777 StoreElementTypedArrayWord32(elements, kind, index, value);
10783 TNode<IntPtrT> index,
10785 StoreElementTypedArrayWord32(elements, kind, index, value);
10791 TNode<TIndex> index,
10808 TNode<IntPtrT> offset = ElementOffsetFromIndex(index, kind, 0);
10816 ElementsKind kind, TNode<TIndex> index,
10823 StoreElementTypedArray(elements, kind, index, value);
10826 StoreFixedArrayElement(CAST(elements), index, smi_value);
10828 StoreFixedArrayElement(CAST(elements), index, value);
10834 ElementsKind kind, TNode<TIndex> index,
10840 StoreFixedDoubleArrayElement(CAST(elements), index, value);
10845 TNode<TIndex> index, TNode<TValue> value) {
10860 StoreElementTypedArray(elements, kind, index, value);
11229 // to a property with a negative integer index.
11750 TNode<IntPtrT> index = IntPtrConstant(i);
11752 index, kind, FixedArray::kHeaderSize - kHeapObjectTag);
11757 TNode<IntPtrT> index = IntPtrConstant(i);
11759 index, kind, FixedArray::kHeaderSize - kHeapObjectTag);
13460 TNode<IntPtrT> index, Label* next_holder, Label* if_bailout) {
13461 TryLookupElement(holder, holder_map, holder_instance_type, index,
14268 TNode<UintPtrT> index, TNode<JSTypedArray> typed_array,
14273 GotoIf(UintPtrGreaterThanOrEqual(index, len), detached_or_out_of_bounds);
14397 TNode<RawPtrT> CodeStubArguments::AtIndexPtr(TNode<IntPtrT> index) const {
14399 assembler_->ElementOffsetFromIndex(index, SYSTEM_POINTER_ELEMENTS, 0);
14403 TNode<Object> CodeStubArguments::AtIndex(TNode<IntPtrT> index) const {
14405 index, GetLengthWithoutReceiver()));
14406 return assembler_->LoadFullTagged(AtIndexPtr(index));
14409 TNode<Object> CodeStubArguments::AtIndex(int index) const {
14410 return AtIndex(assembler_->IntPtrConstant(index));
14423 TNode<IntPtrT> index, TNode<Object> default_value) {
14429 assembler_->UintPtrGreaterThanOrEqual(index, GetLengthWithoutReceiver()),
14431 result = AtIndex(index);
14907 TNode<IntPtrT> index) {
14908 return CodeStubArguments(this, args).GetOptionalArgumentValue(index);
15064 // Cache exhausted, populate the cache. Return value is the new index.
15139 // Assert the descriptor index is in-bounds.
15145 // the descriptor index corresponds to the insertion order in
15186 // If the greatest descriptor index is out of bounds, the map cannot be
15200 // the descriptor index corresponds to the insertion order in
15242 TNode<Uint32T> Load(TNode<ByteArray> meta_table, TNode<IntPtrT> index) {
15243 TNode<IntPtrT> offset = OverallOffset(meta_table, index);
15249 TNode<Uint32T> Load(TNode<ByteArray> meta_table, int index) {
15250 return Load(meta_table, csa.IntPtrConstant(index));
15253 void Store(TNode<ByteArray> meta_table, TNode<IntPtrT> index,
15255 TNode<IntPtrT> offset = OverallOffset(meta_table, index);
15269 void Store(TNode<ByteArray> meta_table, int index, TNode<Uint32T> data) {
15270 Store(meta_table, csa.IntPtrConstant(index), data);
15275 TNode<IntPtrT> index) {
15283 if (csa.TryToIntPtrConstant(index, &constant)) {
15289 csa.IntPtrMul(index, csa.IntPtrConstant(size));
15744 TNode<SwissNameDictionary> dict, TNode<IntPtrT> index, int field_index) {
15748 index,
15762 TNode<IntPtrT> index) {
15787 TNode<IntPtrT> offset_within_details_table = index;