Lines Matching refs:Index
137 int index = 0) {
141 ASSERT(StorageField::is_valid(index));
145 | StorageField::encode(index);
149 ASSERT(index == this->index());
188 int index() { return StorageField::decode(value_); }
197 static bool IsValidIndex(int index) {
198 return StorageField::is_valid(index);
815 inline MaybeObject* GetElement(uint32_t index);
817 inline Object* GetElementNoExceptionThrown(uint32_t index);
818 MaybeObject* GetElementWithReceiver(Object* receiver, uint32_t index);
823 // Tries to convert an object to an array index. Returns true and sets
825 inline bool ToArrayIndex(uint32_t* index);
827 // Returns true if this is a JSValue containing a string and the index is
829 inline bool IsStringObjectWithCharacterAt(uint32_t index);
1062 // |forwarding offset|page offset of map|page index of map|
1397 // Collects elements starting at index 0.
1536 MUST_USE_RESULT MaybeObject* DeleteElement(uint32_t index, DeleteMode mode);
1557 // Tells whether the index'th element is present.
1558 inline bool HasElement(uint32_t index);
1559 bool HasElementWithReceiver(JSObject* receiver, uint32_t index);
1567 // Tells whether the index'th element is present and how it is stored.
1569 // There is no element with given index.
1572 // Element with given index is handled by interceptor.
1575 // Element with given index is character in string.
1578 // Element with given index is stored in fast backing store.
1581 // Element with given index is stored in slow backing store.
1585 LocalElementType HasLocalElement(uint32_t index);
1587 bool HasElementWithInterceptor(JSObject* receiver, uint32_t index);
1588 bool HasElementPostInterceptor(JSObject* receiver, uint32_t index);
1590 MUST_USE_RESULT MaybeObject* SetFastElement(uint32_t index,
1595 // Set the index'th array element.
1597 MUST_USE_RESULT MaybeObject* SetElement(uint32_t index,
1602 // Returns the index'th element.
1603 // The undefined object if index is out of bounds.
1604 MaybeObject* GetElementWithReceiver(Object* receiver, uint32_t index);
1605 MaybeObject* GetElementWithInterceptor(Object* receiver, uint32_t index);
1607 // Get external element value at index if there is one and undefined
1610 MaybeObject* GetExternalElement(uint32_t index);
1623 bool HasRealElementProperty(uint32_t index);
1629 // Get the header size for a JSObject. Used to compute the index of
1634 index);
1635 inline Object* GetInternalField(int index);
1636 inline void SetInternalField(int index, Object* value);
1649 uint32_t index, Object* value, bool* found);
1658 // index.
1659 void GetLocalPropertyNames(FixedArray* storage, int index);
1748 // Access fast-case object properties at index.
1749 inline Object* FastPropertyAt(int index);
1750 inline Object* FastPropertyAtPut(int index, Object* value);
1753 inline int GetInObjectPropertyOffset(int index);
1754 inline Object* InObjectPropertyAt(int index);
1755 inline Object* InObjectPropertyAtPut(int index,
1856 uint32_t index,
1859 uint32_t index,
1863 uint32_t index,
1868 uint32_t index,
1873 MaybeObject* GetElementPostInterceptor(Object* receiver, uint32_t index);
1879 MUST_USE_RESULT MaybeObject* DeleteElementPostInterceptor(uint32_t index,
1881 MUST_USE_RESULT MaybeObject* DeleteElementWithInterceptor(uint32_t index);
1904 uint32_t index,
1929 inline Object* get(int index);
1931 inline void set(int index, Object* value);
1934 inline void set(int index, Smi* value);
1936 inline void set(int index, Object* value, WriteBarrierMode mode);
1939 inline void set_undefined(int index);
1941 inline void set_undefined(Heap* heap, int index);
1942 inline void set_null(int index);
1944 inline void set_null(Heap* heap, int index);
1945 inline void set_the_hole(int index);
1948 inline void set_unchecked(int index, Smi* value);
1949 inline void set_null_unchecked(Heap* heap, int index);
1950 inline void set_unchecked(Heap* heap, int index, Object* value,
1973 static int OffsetOfElementAt(int index) { return SizeFor(index); }
2023 static inline void fast_set(FixedArray* array, int index, Object* value);
2033 // [1]: next enumeration index (Smi), or pointer to small fixed array:
2034 // [0]: next enumeration index (Smi)
2057 Object* index = FixedArray::cast(obj)->get(kEnumCacheBridgeEnumIndex);
2058 return Smi::cast(index)->value();
2062 // Set next enumeration index and flush any enum cache.
2102 inline void CopyFrom(int index, DescriptorArray* src, int src_index);
2107 // or null), its enumeration index is kept as is.
2349 // Returns the index for an entry (of the key)
2557 void CopyKeysTo(FixedArray* storage, int index);
2559 // Accessors for next enumeration index.
2560 void SetNextEnumerationIndex(int index) {
2561 this->fast_set(this, kNextEnumerationIndexIndex, Smi::FromInt(index));
2606 // Generate new enumeration indices to avoid enumeration index overflow.
2681 // elements if an element has been added at an index larger than
2705 // [1]: finger index
2776 inline byte get(int index);
2777 inline void set(int index, byte value);
2780 inline int get_int(int index);
2887 inline uint8_t get(int index);
2888 inline void set(int index, uint8_t value);
2892 Object* SetValue(uint32_t index, Object* value);
2915 inline int8_t get(int index);
2916 inline void set(int index, int8_t value);
2920 MaybeObject* SetValue(uint32_t index, Object* value);
2943 inline uint8_t get(int index);
2944 inline void set(int index, uint8_t value);
2948 MaybeObject* SetValue(uint32_t index, Object* value);
2971 inline int16_t get(int index);
2972 inline void set(int index, int16_t value);
2976 MaybeObject* SetValue(uint32_t index, Object* value);
2999 inline uint16_t get(int index);
3000 inline void set(int index, uint16_t value);
3004 MaybeObject* SetValue(uint32_t index, Object* value);
3027 inline int32_t get(int index);
3028 inline void set(int index, int32_t value);
3032 MaybeObject* SetValue(uint32_t index, Object* value);
3055 inline uint32_t get(int index);
3056 inline void set(int index, uint32_t value);
3060 MaybeObject* SetValue(uint32_t index, Object* value);
3083 inline float get(int index);
3084 inline void set(int index, float value);
3088 MaybeObject* SetValue(uint32_t index, Object* value);
3134 return type::cast(get(k##name##Index)); \
3137 set(k##name##Index, value); \
3202 Smi* AstId(int index) { return Smi::cast(get(index * 2)); }
3203 void SetAstId(int index, Smi* id) { set(index * 2, id); }
3204 Smi* PcAndState(int index) { return Smi::cast(get(1 + index * 2)); }
3205 void SetPcAndState(int index, Smi* offset) { set(1 + index * 2, offset); }
3731 // 0: finger - index of the first free cell in the cache
3769 // Returns the property index for name (only valid for FAST MODE).
3772 // Returns the next free property index (only valid for FAST MODE).
3795 // Returns the non-negative index of the code object if it is in the
3799 // Removes a code object from the code cache at the given index.
3800 void RemoveFromCodeCache(String* name, Code* code, int index);
4335 String* GetThisPropertyAssignmentName(int index);
4336 bool IsThisPropertyAssignmentArgument(int index);
4337 int GetThisPropertyAssignmentArgument(int index);
4338 Object* GetThisPropertyAssignmentConstant(int index);
4970 inline Object* DataAt(int index);
4972 inline void SetDataAt(int index, Object* value);
5097 // Get the internal index of a code object in the cache. Returns -1 if the
5098 // code object is not in that cache. This index can be used to later call
5103 // Remove an object from the cache with the provided internal index.
5104 void RemoveByIndex(Object* name, Code* code, int index);
5169 void RemoveByIndex(int index);
5193 // Add a character to the hash and update the array index calculation.
5196 // Adds a character to the hash but does not update the array index
5198 // that the input is not an array index.
5206 // index.
5318 inline void Set(int index, uint16_t value);
5321 inline uint16_t Get(int index);
5402 uint32_t* index,
5410 inline bool AsArrayIndex(uint32_t* index);
5439 // value into an array index.
5451 // and if it is an array index. The least significant bit indicates
5454 // array index.
5462 // Array index strings this short can keep their index in the hash
5468 // the case for the string '0'. 24 bits are used for the array index value.
5601 bool SlowAsArrayIndex(uint32_t* index);
5629 inline uint16_t SeqAsciiStringGet(int index);
5630 inline void SeqAsciiStringSet(int index, uint16_t value);
5680 inline uint16_t SeqTwoByteStringGet(int index);
5681 inline void SeqTwoByteStringSet(int index, uint16_t value);
5751 uint16_t ConsStringGet(int index);
5818 uint16_t ExternalAsciiStringGet(int index);
5855 uint16_t ExternalTwoByteStringGet(int index);
5911 inline uc32 Get(int index);
6102 MUST_USE_RESULT MaybeObject* JSArrayUpdateLengthFromIndex(uint32_t index,
6148 // This initial map adds in-object properties for "index" and "input"
6528 // Lookup the index in the break_points array for a code position.
