Lines Matching defs:Object
42 // Most object types in the V8 JavaScript are described in this file.
45 // - Object
154 // Formats of Object*:
261 // object using __proto__ or Object.setPrototypeOf.
291 // marking can visit an object twice during a marking phase, so algorithms that
293 // perform an operation on an object once per marking phase: they record the
294 // MarkingParity when they visit an object, and only re-visit the object when it
302 // ICs store extra state in a Code object. The default extra state is
318 // As an example, a JavaScript object is a heap object and its map
333 // Object::IsString.
337 // 'object', whereas JS_FUNCTION_TYPE has typeof 'function'.
497 // A struct is a simple object a set of object-valued fields. Including an
498 // object type in this causes the compiler to generate most of the boilerplate
501 // object verification routines. Easy, no?
527 // We use the full 8 bits of the instance_type field to encode heap object
528 // instance types. The high-order bit (bit 7) is set if the object is not a
534 // Bit 6 indicates that the object is an internalized string (if set) or not.
836 INLINE(static type* cast(Object* object)); \
837 INLINE(static const type* cast(const Object* object));
870 template <class C> inline bool Is(Object* obj);
1025 // Object is the abstract superclass for all classes in the
1026 // object hierarchy.
1027 // Object does not use any virtual functions to avoid the
1029 // Since both Smi and HeapObject are subclasses of Object no
1030 // data members can be present in Object.
1031 class Object {
1069 #define MAYBE_RETURN_NULL(call) MAYBE_RETURN(call, MaybeHandle<Object>())
1077 MUST_USE_RESULT static Maybe<bool> IsArray(Handle<Object> object);
1102 inline bool KeyEquals(Object* other);
1109 inline static Handle<Object> NewStorageFor(Isolate* isolate,
1110 Handle<Object> object,
1113 inline static Handle<Object> WrapForRead(Isolate* isolate,
1114 Handle<Object> object,
1117 // Returns true if the object is of the correct type to be used as a
1126 MUST_USE_RESULT static Maybe<ComparisonResult> Compare(Handle<Object> x,
1127 Handle<Object> y);
1130 MUST_USE_RESULT static Maybe<bool> Equals(Handle<Object> x, Handle<Object> y);
1133 bool StrictEquals(Object* that);
1136 // native_context is used when creating wrapper object.
1138 Isolate* isolate, Handle<Object> object);
1140 Isolate* isolate, Handle<Object> object, Handle<Context> context);
1144 Isolate* isolate, Handle<Object> object);
1148 Handle<Object> input);
1151 MUST_USE_RESULT static inline MaybeHandle<Object> ToPrimitive(
1152 Handle<Object> input, ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
1155 MUST_USE_RESULT static MaybeHandle<Object> ToNumber(Handle<Object> input);
1158 MUST_USE_RESULT static MaybeHandle<Object> ToInteger(Isolate* isolate,
1159 Handle<Object> input);
1162 MUST_USE_RESULT static MaybeHandle<Object> ToInt32(Isolate* isolate,
1163 Handle<Object> input);
1166 MUST_USE_RESULT static MaybeHandle<Object> ToUint32(Isolate* isolate,
1167 Handle<Object> input);
1171 Handle<Object> input);
1174 MUST_USE_RESULT static MaybeHandle<Object> ToPropertyKey(
1175 Isolate* isolate, Handle<Object> value);
1178 MUST_USE_RESULT static MaybeHandle<Object> ToLength(Isolate* isolate,
1179 Handle<Object> input);
1182 MUST_USE_RESULT static MaybeHandle<Object> GetMethod(
1187 Isolate* isolate, Handle<Object> object, ElementTypes element_types);
1190 MUST_USE_RESULT static MaybeHandle<Object> GetLengthFromArrayLike(
1191 Isolate* isolate, Handle<Object> object);
1194 static Handle<String> TypeOf(Isolate* isolate, Handle<Object> object);
1197 MUST_USE_RESULT static MaybeHandle<Object> Multiply(Isolate* isolate,
1198 Handle<Object> lhs,
1199 Handle<Object> rhs);
1200 MUST_USE_RESULT static MaybeHandle<Object> Divide(Isolate* isolate,
1201 Handle<Object> lhs,
1202 Handle<Object> rhs);
1203 MUST_USE_RESULT static MaybeHandle<Object> Modulus(Isolate* isolate,
1204 Handle<Object> lhs,
1205 Handle<Object> rhs);
1208 MUST_USE_RESULT static MaybeHandle<Object> Add(Isolate* isolate,
1209 Handle<Object> lhs,
1210 Handle<Object> rhs);
1211 MUST_USE_RESULT static MaybeHandle<Object> Subtract(Isolate* isolate,
1212 Handle<Object> lhs,
1213 Handle<Object> rhs);
1216 MUST_USE_RESULT static MaybeHandle<Object> ShiftLeft(Isolate* isolate,
1217 Handle<Object> lhs,
1218 Object> rhs);
1219 MUST_USE_RESULT static MaybeHandle<Object> ShiftRight(Isolate* isolate,
1220 Handle<Object> lhs,
1221 Handle<Object> rhs);
1222 MUST_USE_RESULT static MaybeHandle<Object> ShiftRightLogical(
1223 Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs);
1226 MUST_USE_RESULT static inline Maybe<bool> GreaterThan(Handle<Object> x,
1227 Handle<Object> y);
1229 Handle<Object> x, Handle<Object> y);
1230 MUST_USE_RESULT static inline Maybe<bool> LessThan(Handle<Object> x,
1231 Handle<Object> y);
1232 MUST_USE_RESULT static inline Maybe<bool> LessThanOrEqual(Handle<Object> x,
1233 Handle<Object> y);
1236 MUST_USE_RESULT static MaybeHandle<Object> BitwiseAnd(Isolate* isolate,
1237 Handle<Object> lhs,
1238 Handle<Object> rhs);
1239 MUST_USE_RESULT static MaybeHandle<Object> BitwiseOr(Isolate* isolate,
1240 Handle<Object> lhs,
1241 Handle<Object> rhs);
1242 MUST_USE_RESULT static MaybeHandle<Object> BitwiseXor(Isolate* isolate,
1243 Handle<Object> lhs,
1244 Handle<Object> rhs);
1247 MUST_USE_RESULT static MaybeHandle<Object> OrdinaryHasInstance(
1248 Isolate* isolate, Handle<Object> callable, Handle<Object> object);
1251 MUST_USE_RESULT static MaybeHandle<Object> InstanceOf(
1252 Isolate* isolate, Handle<Object> object, Handle<Object> callable);
1254 MUST_USE_RESULT static MaybeHandle<Object> GetProperty(LookupIterator* it);
1264 Handle<Object> value,
1267 MUST_USE_RESULT static MaybeHandle<Object> SetProperty(
1268 Handle<Object> object, Handle<Name> name, Handle<Object> value,
1271 MUST_USE_RESULT static inline MaybeHandle<Object> SetPropertyOrElement(
1272 Handle<Object> object, Handle<Name> name, Handle<Object> value,
1277 LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1280 MUST_USE_RESULT static MaybeHandle<Object> ReadAbsentProperty(
1282 MUST_USE_RESULT static MaybeHandle<Object> ReadAbsentProperty(
1283 Isolate* isolate, Handle<Object> receiver, Handle<Object> name);
1285 Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
1286 Handle<Object> value, ShouldThrow should_throw);
1288 LookupIterator* it, Handle<Object> value, ShouldThrow should_throw);
1290 Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
1291 Handle<Object> value, ShouldThrow should_throw);
1293 Isolate* isolate, Handle<Object> name, Handle<Object> value,
1296 Handle<Object> value);
1298 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
1300 MUST_USE_RESULT static inline MaybeHandle<Object> GetPropertyOrElement(
1301 Handle<Object> object, Handle<Name> name);
1302 MUST_USE_RESULT static inline MaybeHandle<Object> GetPropertyOrElement(
1303 Handle<Object> receiver, Handle<Name> name, Handle<JSReceiver> holder);
1304 MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1305 Handle<Object> object, Handle<Name> name);
1307 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithAccessor(
1310 LookupIterator* it, Handle<Object> value, ShouldThrow should_throw);
1312 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithDefinedGetter(
1313 Handle<Object> receiver,
1316 Handle<Object> receiver, Handle<JSReceiver> setter, Handle<Object> value,
1319 MUST_USE_RESULT static inline MaybeHandle<Object> GetElement(
1320 Isolate* isolate, Handle<Object> object, uint32_t index);
1322 MUST_USE_RESULT static inline MaybeHandle<Object> SetElement(
1323 Isolate* isolate, Handle<Object> object, uint32_t index,
1324 Handle<Object> value, LanguageMode language_mode);
1326 // Returns the permanent hash code associated with this object. May return
1328 Object* GetHash();
1330 // Returns the permanent hash code associated with this object depending on
1331 // the actual object type. May create and store a hash code if needed and none
1333 static Smi* GetOrCreateHash(Isolate* isolate, Handle<Object> object);
1335 // Checks whether this object has the same value as the given one. This
1338 bool SameValue(Object* other);
1340 // Checks whether this object has the same value as the given one.
1344 bool SameValueZero(Object* other);
1347 MUST_USE_RESULT static MaybeHandle<Object> ArraySpeciesConstructor(
1348 Isolate* isolate, Handle<Object> original_array);
1350 // Tries to convert an object to an array length. Returns true and sets the
1354 // Tries to convert an object to an array index. Returns true and sets the
1359 DECLARE_VERIFIER(Object)
1361 // Verify a pointer is a valid object pointer.
1362 static void VerifyPointer(Object* p);
1367 // ES6 19.1.3.6 Object.prototype.toString
1369 Isolate* isolate, Handle<Object> object);
1371 // Prints this object without details.
1374 // Prints this object without details to a message accumulator.
1379 DECLARE_CAST(Object)
1382 static const int kHeaderSize = 0; // Object does not take up any space.
1388 // Prints this object with details.
1399 // Return the map of the root of object's prototype chain.
1405 LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1409 Handle<Object> input);
1411 DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
1416 bool Object::IsSmi() const { return HAS_SMI_TAG(this); }
1417 bool Object::IsHeapObject() const { return Internals::HasHeapObjectTag(this); }
1421 explicit Brief(const Object* const v) : value(v) {}
1422 const Object* value;
1435 class Smi: public Object {
1440 // Convert a value to a Smi object.
1477 // value in a heap object's first word.
1490 // contains a forwarding address (a heap object pointer in the to space).
1494 // when all map words are heap object pointers, i.e. not during a full GC).
1498 static inline MapWord FromForwardingAddress(HeapObject* object);
1523 class HeapObject: public Object {
1525 // [map]: Contains a map which contains the object's reflective
1529 // The no-write-barrier version. This is OK if the object is white and in
1530 // new space, or if the value is an immortal immutable object, like the maps
1543 // During garbage collection, the map word of a heap object does not
1548 // The Heap the object was allocated in. Used also to access Isolate.
1579 // Iterates over pointers contained in the object (including the Map).
1587 // Iterates over all pointers contained in the object except the
1588 // first map pointer. The object type is given in the first
1590 // object, and so is safe to call while the map pointer is modified.
1603 // Returns true if the object contains a tagged value at given offset.
1605 // of the object or to the map word, the result is UNDEFINED (!!!).
1608 // Returns the heap object's size in bytes
1611 // Given a heap object's map pointer, returns the heap size in bytes
1616 // Returns the field at offset in obj, as a read/write Object* reference.
1620 static inline Object
1622 // Adds the |code| object related to |name| to the code cache of this map. If
1624 // onto the object.
1625 static void UpdateMapCodeCache(Handle<HeapObject> object,
1633 // object as a sign that they are not going to use this function
1650 // Verify a pointer is a valid HeapObject pointer that points to object
1652 static void VerifyHeapPointer(Object* p);
1658 // First field in a heap object is map.
1659 static const int kMapOffset = Object::kHeaderSize;
1828 // Deletes an existing named property in a normalized object.
1829 static void DeleteNormalizedProperty(Handle<JSReceiver> object,
1835 MUST_USE_RESULT static MaybeHandle<Object> ToPrimitive(
1838 MUST_USE_RESULT static MaybeHandle<Object> OrdinaryToPrimitive(
1844 static inline MaybeHandle<Object> GetPrototype(Isolate* isolate,
1848 Isolate* isolate, Handle<JSReceiver> object, Handle<Object> proto);
1853 Handle<JSReceiver> object, Handle<Name> name);
1855 Handle<JSReceiver> object, uint32_t index);
1858 Handle<JSReceiver> object, Handle<Name> name);
1860 Handle<JSReceiver> object, uint32_t index);
1862 MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1864 MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1866 MUST_USE_RESULT static inline MaybeHandle<Object> GetElement(
1871 Handle<JSReceiver> object, Handle<Name> name,
1874 Handle<JSReceiver> object, Handle<Name> name,
1879 Handle<JSReceiver> object, uint32_t index,
1882 MUST_USE_RESULT static Object* DefineProperty(Isolate* isolate,
1883 Handle<Object> object,
1884 Handle<Object> name,
1885 Handle<Object> attributes);
1886 MUST_USE_RESULT static MaybeHandle<Object> DefineProperties(
1887 Isolate* isolate, Handle<Object> object, Handle<Object> properties);
1891 Isolate* isolate, Handle<JSReceiver> object, Handle<Object> key,
1896 LookupIterator* it, Handle<Object> value, ShouldThrow should_throw);
1900 Isolate* isolate, Handle<JSObject> object, Handle<Object> key,
1918 Isolate* isolate, Handle<JSReceiver> object, Handle<Object> key,
1928 Handle<JSReceiver> object, IntegrityLevel lvl, ShouldThrow should_throw);
1933 Handle<JSReceiver> object, IntegrityLevel lvl);
1937 Handle<JSReceiver> object, ShouldThrow should_throw);
1939 MUST_USE_RESULT static Maybe<bool> IsExtensible(Handle<JSReceiver> object);
1945 // function that was used to instantiate the object).
1951 Handle<JSReceiver> object, Handle<Name> name);
1953 GetOwnPropertyAttributes(Handle<JSReceiver> object, Handle<Name> name);
1955 GetOwnPropertyAttributes(Handle<JSReceiver> object, uint32_t index);
1958 Handle<JSReceiver> object, uint32_t index);
1960 GetOwnElementAttributes(Handle<JSReceiver> object, uint32_t index);
1965 // Set the object's prototype (only JSReceiver and null are allowed values).
1966 MUST_USE_RESULT static Maybe<bool> SetPrototype(Handle<JSReceiver> object,
1967 Handle<Object> value,
1971 inline static Handle<Object> GetDataProperty(Handle<JSReceiver> object,
1973 static Handle<Object> GetDataProperty(LookupIterator* it);
1976 // Retrieves a permanent object identity hash code. The undefined value might
1978 static inline Object* GetIdentityHash(Isolate* isolate,
1979 Handle<JSReceiver> object);
1981 // Retrieves a permanent object identity hash code. May create and store a
1984 Handle<JSReceiver> object);
1988 Handle<JSReceiver> object);
1991 Handle<JSReceiver> object, PropertyFilter filter);
1994 Handle<JSReceiver> object, PropertyFilter filter);
2015 // Gets global object properties.
2018 static MaybeHandle<Context> GetFunctionRealm(Handle<JSObject> object);
2023 // corrensponds to a set of object representations of elements that
2036 // FixedArray parameter map for a (sloppy) arguments object.
2039 static void ResetElements(Handle<JSObject> object);
2040 static inline void SetMapAndElements(Handle<JSObject> object,
2045 // Returns true if an object has elements of FAST_SMI_ELEMENTS ElementsKind.
2047 // Returns true if an object has elements of FAST_ELEMENTS ElementsKind.
2049 // Returns true if an object has elements of FAST_ELEMENTS or
2052 // Returns true if an object has any of the fast elements kinds.
2054 // Returns true if an object has elements of FAST_DOUBLE_ELEMENTS
2057 // Returns true if an object has elements of FAST_HOLEY_*_ELEMENTS
2086 static void EnsureWritableFastElements(Handle<JSObject> object);
2091 static Handle<Object> PrepareElementsForSort(Handle<JSObject> object,
2096 static Handle<Object> PrepareSlowElementsForSort(Handle<JSObject> object,
2100 LookupIterator* it, ShouldThrow should_throw, Handle<Object> value);
2107 MUST_USE_RESULT static MaybeHandle<Object> DefineOwnPropertyIgnoreAttributes(
2108 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
2112 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
2116 MUST_USE_RESULT static MaybeHandle<Object> SetOwnPropertyIgnoreAttributes(
2117 Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
2120 MUST_USE_RESULT static MaybeHandle<Object> SetOwnElementIgnoreAttributes(
2121 Handle<JSObject> object, uint32_t index, Handle<Object> value,
2126 MUST_USE_RESULT static MaybeHandle<Object>
2127 DefinePropertyOrElementIgnoreAttributes(Handle<JSObject> object,
2129 Handle<Object> value,
2135 LookupIterator* it, Handle<Object> value,
2138 static void AddProperty(Handle<JSObject> object, Handle<Name> name,
2139 Handle<Object> value, PropertyAttributes attributes);
2142 Handle<JSObject> receiver, uint32_t index, Handle<Object> value,
2144 MUST_USE_RESULT static MaybeHandle<Object> AddDataElement(
2145 Handle<JSObject> receiver, uint32_t index, Handle<Object> value,
2150 static void AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map);
2152 // Migrates the given object to a map whose field representations are the
2156 // Migrates the given object only if the target map is already available,
2160 // Sets the property value in a normalized object given (key, value, details).
2162 static void SetNormalizedProperty(Handle<JSObject> object, Handle<Name> name,
2163 Handle<Object> value,
2165 static void SetDictionaryElement(Handle<JSObject> object, uint32_t index,
2166 Handle<Object> value,
2168 static void SetDictionaryArgumentsElement(Handle<JSObject> object,
2170 Handle<Object> value,
2173 static void OptimizeAsPrototype(Handle<JSObject> object,
2175 static void ReoptimizeIfPrototype(Handle<JSObject> object);
2176 static void MakePrototypesFast(Handle<Object> receiver,
2188 static void Callback(Object* value, int old_index, int new_index);
2201 // Defines an AccessorPair property on the given object.
2203 static MaybeHandle<Object> DefineAccessor(Handle<JSObject> object,
2205 Handle<Object> getter,
2206 Handle<Object> setter,
2208 static MaybeHandle<Object> DefineAccessor(LookupIterator* it,
2209 Handle<Object> getter,
2210 Handle<Object> setter,
2213 // Defines an AccessorInfo property on the given object.
2214 MUST_USE_RESULT static MaybeHandle<Object> SetAccessor(
2215 Handle<JSObject> object,
2221 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithInterceptor(
2224 static void ValidateElements(Handle<JSObject> object);
2226 // Makes sure that this object can contain HeapObject as elements.
2229 // Makes sure that this object can contain the specified elements.
2231 Handle<JSObject> object,
2232 Object** elements,
2236 Handle<JSObject> object,
2241 Handle<JSObject> object,
2258 static void UpdateAllocationSite(Handle<JSObject> object,
2268 Handle<JSObject> object, Handle<Name> name);
2270 Handle<JSObject> object, uint32_t index);
2272 Handle<JSObject> object, Handle<Name> name);
2282 inline Object* GetInternalField(int index);
2283 inline void SetInternalField(int index, Object* value);
2287 // Returns a new map with all transitions dropped from the object's current
2289 static Handle<Map> GetElementsTransitionMap(Handle<JSObject> object,
2291 static void TransitionElementsKind(Handle<JSObject> object,
2294 // Always use this to migrate an object to a new map.
2297 static void MigrateToMap(Handle<JSObject> object, Handle<Map> new_map,
2300 // Convert the object to use the canonical dictionary
2301 // representation. If the object is expected to have additional properties
2304 static void NormalizeProperties(Handle<JSObject> object,
2312 Handle<JSObject> object);
2317 static void MigrateSlowToFast(Handle<JSObject> object,
2322 // Access fast-case object properties at index.
2323 static Handle<Object> FastPropertyAt(Handle<JSObject> object,
2326 inline Object* RawFastPropertyAt(FieldIndex index);
2329 inline void FastPropertyAtPut(FieldIndex index, Object* value);
2330 inline void RawFastPropertyAtPut(FieldIndex index, Object* value);
2333 Object* value);
2334 inline void WriteToField(int descriptor, Object* value);
2336 // Access to in object properties.
2338 inline Object* InObjectPropertyAt(int index);
2339 inline Object* InObjectPropertyAtPut(int index,
2340 Object* value,
2344 // Set the object's prototype (only JSReceiver and null are allowed values).
2345 MUST_USE_RESULT static Maybe<bool> SetPrototype(Handle<JSObject> object,
2346 Handle<Object> value,
2351 // the caller to initialize object header. Fill the pre-allocated fields with
2356 Object* pre_allocated_value, Object* filler_value);
2358 // Check whether this object references another object
2359 bool ReferencesObject(Object* obj);
2362 Handle<JSObject> object, ShouldThrow should_throw);
2364 static bool IsExtensible(Handle<JSObject> object);
2366 // Copy object.
2370 object,
2374 Handle<JSObject> object,
2392 FILE* file, Handle<JSObject> object,
2421 // If a GC was caused while constructing this object, the elements pointer
2422 // may point to a one pointer filler map. The object won't be rooted, but
2427 Object* SlowReverseLookup(Object* value);
2448 // This constant applies only to the initial map of "global.Object" and
2455 // to the same object requires fewer allocations and copies.
2474 friend class Object;
2476 // Used from Object::GetProperty().
2477 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithFailedAccessCheck(
2481 LookupIterator* it, Handle<Object> value, ShouldThrow should_throw);
2483 // Add a property to a slow-case object.
2484 static void AddSlowProperty(Handle<JSObject> object,
2486 Handle<Object> value,
2494 Object* object);
2496 static Object* GetIdentityHash(Isolate* isolate, Handle<JSObject> object);
2499 Handle<JSObject> object);
2505 Handle<JSObject> object, ShouldThrow should_throw);
2512 // map. This initial map adds in-object properties for "get", "set",
2517 // Offsets of object fields.
2523 // Indices of in-object properties.
2535 // This initial map adds in-object properties for "value", "writable",
2540 // Offsets of object fields.
2546 // Indices of in-object properties.
2558 // This initial map adds in-object properties for "done" and "value",
2562 // Offsets of object fields.
2566 // Indices of in-object properties.
2578 // Offsets of object fields.
2581 // Indices of in-object properties.
2590 // This initial map adds in-object properties for "length" and "callee".
2593 // Offsets of object fields.
2596 // Indices of in-object properties.
2605 // This initial map adds an in-object property for "length".
2608 // Offsets of object fields.
2641 // FixedArray describes fixed-sized arrays with element type Object*.
2645 inline Object* get(int index) const;
2646 static inline Handle<Object> get(FixedArray* array, int index,
2649 inline void set(int index, Object* value);
2655 inline void set(int index, Object* value, WriteBarrierMode mode);
2662 inline Object** GetFirstElementAddress();
2666 inline Object** data_start();
2683 inline Object** RawFieldOfElementAt(int index);
2703 // numbers array are the same object, the elements are only swapped
2709 // object, the prefix of this array is sorted.
2719 Object* value);
2734 static inline Handle<Object> get(FixedDoubleArray* array, int index,
2778 static Handle<WeakFixedArray> Add(Handle<Object> maybe_array,
2787 static void Callback(Object* value, int old_index, int new_index) {}
2793 inline Object* Get(int index) const;
2798 static Object* Empty() { return Smi::FromInt(0); }
2802 explicit Iterator(Object* maybe_array) : list_(NULL) { Reset(maybe_array); }
2803 void Reset(Object* maybe_array);
2836 void set(int index, Object* value);
2837 void set(int index, Object* value, WriteBarrierMode mode);
2850 static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj,
2852 static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj1,
2853 Handle<Object> obj2, AddMode = kNone);
2856 inline Object* Get(int index);
2857 inline Object** Slot(int index);
2858 inline void Set(int index, Object* obj);
2859 inline void Clear(int index, Object* undefined);
2906 inline Object** GetEnumCacheSlot();
2918 inline Object** GetKeySlot(int descriptor_number);
2919 inline Object* GetValue(int descriptor_number);
2920 inline void SetValue(int descriptor_number, Object* value);
2921 inline Object** GetValueSlot(int descriptor_number);
2923 inline Object** GetDescriptorStartSlot(int descriptor_number);
2924 inline Object** GetDescriptorEndSlot(int descriptor_number);
2929 inline Object* GetConstant(int descriptor_number);
2930 inline Object* GetCallbacksObject(int descriptor_number);
2972 // empty descriptor array object if number_of_descriptors is 0.
3053 inline Object* GetCallbackObject();
3096 // static bool IsMatch(Key key, Object* other);
3099 // // Returns the hash value for object.
3100 // static uint32_t HashForObject(Key key, Object* object);
3101 // // Convert key to an object.
3102 // static inline Handle<Object> AsHandle(Isolate* isolate, Key key);
3122 static uint32_t HashForObject(Key key, Object* object) { return 0; }
3123 static uint32_t SeededHashForObject(Key key, uint32_t seed, Object* object) {
3125 return HashForObject(key, object);
3156 inline bool IsKey(Object* k);
3157 inline bool IsKey(Isolate* isolate, Object* k);
3210 inline uint32_t HashForObject(Key key, Object* object) {
3212 return Shape::SeededHashForObject(key, GetHeap()->HashSeed(), object);
3214 return Shape::HashForObject(key, object);
3218 // Returns a new HashTable object.
3239 Object* KeyAt(int entry) { return get(EntryToIndex(entry) + kEntryKeyIndex); }
3295 uint32_t EntryForProbe(Key key, Object* k, int probe, uint32_t expected);
3307 // Returns whether the other object matches this key.
3308 virtual bool IsMatch(Object* other) = 0;
3311 // Returns the hash value for object.
3312 virtual uint32_t HashForObject(Object* key) = 0;
3313 // Returns the key object for storing into the hash table.
3314 MUST_USE_RESULT virtual Handle<Object
3322 static inline bool IsMatch(HashTableKey* key, Object* value) {
3330 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
3331 return key->HashForObject(object);
3334 static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
3385 static inline bool IsMatch(String* key, Object* value);
3387 static inline uint32_t HashForObject(String* key, Object* object);
3409 Object* ValueAt(int entry) {
3414 void ValueAtPut(int entry, Object* value) {
3434 static Handle<Object> DeleteProperty(Handle<Derived> dictionary, int entry);
3495 Object* SlowReverseLookup(Object* value);
3499 Handle<Object> key,
3500 Handle<Object> value);
3502 Handle<Object> key,
3503 Handle<Object> value,
3509 Handle<Object> value,
3522 Handle<Object> value);
3528 Handle<Object> value,
3577 static inline void SetEntry(Dictionary* dict, int entry, Handle<Object> key,
3578 Handle<Object> value, PropertyDetails details);
3584 static inline bool IsMatch(Handle<Name> key, Object* other);
3586 static inline uint32_t HashForObject(Handle<Name> key, Object* object);
3587 static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Name> key);
3627 static inline void SetEntry(Dictionary* dict, int entry, Handle<Object> key,
3628 Handle<Object> value, PropertyDetails details);
3643 static inline bool IsMatch(uint32_t key, Object* other);
3644 static inline Handle<Object> AsHandle(Isolate* isolate, uint32_t key);
3658 Object* object);
3667 static inline uint32_t HashForObject(uint32_t key, Object* object);
3681 Handle<Object> value, bool used_as_prototype);
3684 Handle<Object> value, PropertyDetails details, bool used_as_prototype);
3690 Handle<Object> value, PropertyDetails details, bool used_as_prototype);
3732 Handle<Object> value);
3736 Handle<Object> value);
3743 Handle<Object> value);
3750 class ObjectHashTableShape : public BaseShape<Handle<Object> > {
3752 static inline bool IsMatch(Handle<Object> key, Object* other);
3753 static inline uint32_t Hash(Handle<Object> key);
3754 static inline uint32_t HashForObject(Handle<Object> key, Object* object);
3755 static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Object> key);
3761 // ObjectHashTable maps keys that are arbitrary objects to object values by
3765 Handle<Object> > {
3767 ObjectHashTable, ObjectHashTableShape, Handle<Object> > DerivedHashTable;
3774 Handle<Object> key);
3778 Object* Lookup(Handle<Object> key);
3779 Object* Lookup(Handle<Object> key, int32_t hash);
3780 Object* Lookup(Isolate* isolate, Handle<Object> key, int32_t hash);
3784 Handle<Object> key,
3785 Handle<Object> value);
3787 Handle<Object> key, Handle<Object> value,
3792 Handle<Object> key,
3795 Handle<Object> key, bool* was_present,
3801 void AddEntry(int entry, Object* key, Object* value);
3811 // OrderedHashTable is a HashTable with Object keys that preserves
3815 // Only Object* keys are supported, with Object::SameValueZero() used as the
3816 // equality operator and Object::GetHash() for the hash function.
3867 static bool HasKey(Handle<Derived> table, Handle<Object> key);
3894 Object* entry = this->get(kHashTableStartIndex + bucket);
3898 int KeyToFirstEntry(Isolate* isolate, Object* key) {
3899 Object* hash = key->GetHash();
3900 // If the object does not have an identity hash, it was never used as a key
3906 Object* next_entry = get(EntryToIndex(entry) + kChainOffset);
3911 Object* KeyAt(int entry) {
4005 Handle<Object> value);
4019 inline Object* ValueAt(int entry);
4026 class WeakHashTableShape : public BaseShape<Handle<Object> > {
4028 static inline bool IsMatch(Handle<Object> key, Object* other);
4029 static inline uint32_t Hash(Handle<Object> key);
4030 static inline uint32_t HashForObject(Handle<Object> key, Object* object);
4031 static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Object> key);
4037 // WeakHashTable maps keys that are arbitrary heap objects to heap object
4042 Handle<Object> > {
4044 WeakHashTable, WeakHashTableShape<2>, Handle<Object> > DerivedHashTable;
4050 Object* Lookup(Handle<HeapObject> key);
4077 // This object provides quick access to scope info details for runtime
4372 Object* get(int index);
4373 void set(int index, Object* value);
4411 // Returns a pointer to the ByteArray object for a given data start address.
4517 // They look like heap objects (are heap object tagged and have a map) so that
4519 // The next pointer is the raw address of the next FreeSpace object (or NULL)
4568 DECL_ACCESSORS(base_pointer, Object)
4615 static inline Handle<Object> get(FixedTypedArray* array, int index);
4623 inline void SetValue(uint32_t index, Object* value);
4638 static inline Handle<Object> ToHandle(Isolate* isolate, \
4688 DECLARE_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
4689 DECLARE_ELEMENT_ACCESSORS(WeakCellCache, Object)
4780 inline Object* literal(int literal_index) const;
4781 inline void set_literal(int literal_index, Object* literal);
4793 inline Object* get(int index) const;
4794 inline void set(int index, Object* value);
4796 inline void set(int index, Object* value, WriteBarrierMode mode);
4801 // the code object it is associated with. The tables comes in two flavors:
4943 // the kind of the code object.
4946 DECL_ACCESSORS(raw_type_feedback_info, Object)
4947 inline Object* type_feedback_info();
4949 Object* value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
4955 DECL_ACCESSORS(next_code_link, Object)
4960 DECL_ACCESSORS(gc_metadata, Object)
4963 // at the moment when this object was created.
5010 // object was generated by either the hydrogen or the TurboFan optimizing
5017 // code object was generated by the TurboFan optimizing compiler.
5050 // the code object was seen on the stack with no IC patching going on.
5058 // To verify in that case, compare the code object to the indexed builtin.
5093 // Find an object in a stub with a specified map
5094 Object* FindNthObject(int n, Map* match_map);
5103 // For each (map-to-find, object-to-replace) pair in the pattern, this
5105 // object-to-replace. The function assumes that pairs in the pattern come in
5111 // The entire code object
5134 // Convert a target address into a code object.
5137 // Convert an entry address into an object.
5138 static inline Object* GetObjectFromEntryAddress(Address location_of_address);
5157 // [has_unwinding_info]: Whether this code object has unwinding information.
5171 // memory location after the end of the code object. Otherwise, the body
5186 // of the code object.
5203 // Returns true if pc is inside this object's instructions.
5207 // object has been moved by delta bytes.
5213 // Returns the object size for a given body (used for allocation).
5219 // Calculate the size of the code object to report for log events. This takes
5220 // the layout of the code object into account.
5258 // relatively safe to flush this code object and replace it with the lazy
5288 inline bool IsWeakObject(Object* object);
5290 static inline bool IsWeakObjectInOptimizedCode(Object* object);
5326 // the Code object header.
5454 // Returns true if pc is inside this object's instructions.
5460 // Calculate the size of the code object to report for log events. This takes
5461 // the layout of the code object into account.
5498 // described by this map. The group is deoptimized whenever an object
5552 inline Object* object_at(int i);
5553 inline void set_object_at(int i, Object* object);
5564 Handle<Object> object);
5565 static Handle<DependentCode> New(DependencyGroup group, Handle<Object> object,
5591 // - Size information about the object
5592 // - How to iterate over an object (for garbage collection)
5609 // Count of properties allocated in the object (JSObject only).
5613 // or the special sentinel value to indicate that there is no object wrapper
5663 // This counter is used for in-object slack tracking.
5664 // The in-object slack tracking is considered enabled when the counter is
5689 // object with one_pointer_filler_map instead of undefined_value (the "used"
5709 // Starts the tracking by initializing object constructions countdown counter.
5712 // True if the object constructions countdown counter is a range
5723 // Tells whether the object in the prototype property will be used
5749 // An undetectable object is a special class of JSObject: 'typeof' operator
5751 // a normal JS object. It is useful for implementing undetectable
5800 DECL_ACCESSORS(raw_transitions, Object)
5803 DECL_ACCESSORS(prototype_info, Object)
5814 // [prototype chain validity cell]: Associated with a prototype object,
5815 // stored in that object's map's PrototypeInfo, indicates that prototype
5816 // chains through this object are currently valid. The cell will be
5854 Handle<Object> value);
5874 // [prototype]: implicit prototype object.
5875 DECL_ACCESSORS(prototype, Object)
5878 Handle<Map> map, Handle<Object> prototype,
5885 DECL_ACCESSORS(constructor_or_backpointer, Object)
5886 inline Object* GetConstructor() const;
5887 inline void SetConstructor(Object* constructor,
5891 inline Object* GetBackPointer();
5892 inline void SetBackPointer(Object* value,
5895 // [instance descriptors]: describes the object.
5898 // [layout descriptor]: describes the object layout.
5921 DECL_ACCESSORS(weak_cell_cache, Object)
5932 // Checks whether all properties are stored either in the map or on the object
5979 Handle<Object> constant,
6013 Handle<Object> value,
6018 Handle<Object> getter, Handle<Object> setter,
6060 Handle<Object> descriptors);
6114 Handle<Object> prototype,
6293 // Fires when the layout of an object with a leaf map changes.
6311 Handle<Object> new_wrapped_type);
6320 MaybeHandle<Object> old_value,
6322 MaybeHandle<Object> new_value);
6345 DECL_ACCESSORS(value, Object)
6368 DECL_ACCESSORS(prototype_users, Object)
6370 // [object_create_map]: A field caching the map for Object.create(prototype).
6381 // going through this object, or Smi(0) if uninitialized.
6382 // When a prototype object changes its map, then both its own validity cell
6386 DECL_ACCESSORS(validity_cell, Object)
6410 DECL_ACCESSORS(object_create_map, Object)
6416 // Pair used to store both a ScopeInfo and an extension object in the extension
6424 // [extension]: Extension object.
6465 DECL_ACCESSORS(source, Object)
6468 DECL_ACCESSORS(name, Object)
6481 DECL_ACCESSORS(context_data, Object)
6490 DECL_ACCESSORS(line_ends, Object)
6494 DECL_ACCESSORS(eval_from_shared, Object)
6503 DECL_ACCESSORS(shared_function_infos, Object)
6509 DECL_ACCESSORS(source_url, Object)
6512 DECL_ACCESSORS(source_mapping_url, Object)
6541 static Handle<Object> GetNameOrSourceURL(Handle<Script> script);
6575 // Returns false on failure, and otherwise writes into the given info object
6580 // Get the JS object wrapping the given script; create it if none exists.
6640 // Each entry has a name of a global object property holding an object
6642 // on the object (the one the id is set for), and a label.
6654 V(Object.prototype, hasOwnProperty, ObjectHasOwnProperty) \
6727 DECL_ACCESSORS(name, Object)
6733 // a Code object or a BytecodeArray.
6760 // Removes a specific optimized code object from the optimized code map.
6786 Handle<Object> script_object);
6853 DECL_ACCESSORS(instance_class_name, Object)
6859 DECL_ACCESSORS(function_data, Object)
6876 // all functions are anonymous but are assigned to object
6878 DECL_ACCESSORS(function_identifier, Object)
6888 DECL_ACCESSORS(script, Object)
6910 DECL_ACCESSORS(debug_info, Object)
6973 // False if the function definitely does not allocate an arguments object.
6987 // global object.
7073 Handle<Object> GetSourceCode();
7433 // [function]: The function corresponding to this generator object.
7440 DECL_ACCESSORS(receiver, Object)
7448 DECL_ACCESSORS(input_or_debug_pos, Object)
7500 DECL_ACCESSORS(context, Object)
7521 // JSBoundFunction describes a bound function exotic object.
7524 // [bound_target_function]: The wrapped function object.
7529 DECL_ACCESSORS(bound_this, Object)
7565 DECL_ACCESSORS(prototype_or_initial_map, Object)
7576 inline void set_context(Object* context);
7580 static Handle<Object> GetName(Isolate* isolate, Handle<JSFunction> function);
7585 // [code]: The generated code object for this function. Executed
7595 // a Code object or a BytecodeArray.
7623 // If the function contains object, regexp or array literals, the
7624 // literals array prefix contains the object, regexp, and array
7626 // necessary so that we do not dynamically lookup the object, regexp
7641 // The initial map for an object created by this constructor.
7644 Handle<Object> prototype);
7661 inline Object* prototype();
7662 inline Object* instance_prototype();
7664 Handle<Object> value);
7666 Handle<Object> value);
7679 DECL_ACCESSORS(next_function_link, Object)
7686 // Calculate the instance size and in-object properties count.
7708 // Iterates the function object according to the visiting policy.
7712 // Visit the whole object.
7770 // [native_context]: the owner native context of this global proxy object.
7771 // It is null value if this object is not used by any context.
7772 DECL_ACCESSORS(native_context, Object)
7775 DECL_ACCESSORS(hash, Object)
7795 // JavaScript global object.
7798 // [native context]: the natives corresponding to this global object.
7801 // [global proxy]: the global proxy object of the context
7805 static void InvalidatePropertyCell(Handle<JSGlobalObject> object,
7807 // Ensure that the global object has a cell for the given property name.
7833 // [value]: the object being wrapped.
7834 DECL_ACCESSORS(value, Object)
7862 DECL_ACCESSORS(value, Object)
7864 DECL_ACCESSORS(year, Object)
7866 DECL_ACCESSORS(month, Object)
7868 DECL_ACCESSORS(day, Object)
7870 DECL_ACCESSORS(weekday, Object)
7872 DECL_ACCESSORS(hour, Object)
7874 DECL_ACCESSORS(min, Object)
7876 DECL_ACCESSORS(sec, Object)
7879 DECL_ACCESSORS(cache_stamp, Object)
7888 static Object* GetField(Object* date, Smi* index);
7890 static Handle<Object> SetValue(Handle<JSDate> date, double v);
7892 void SetValue(Object* value, bool is_value_nan);
7895 static MUST_USE_RESULT MaybeHandle<Object> ToPrimitive(
7896 Handle<JSReceiver> receiver, Handle<Object> hint);
7944 inline Object* DoGetField(FieldIndex index);
7946 Object* GetUTCField(FieldIndex index, double value, DateCache* date_cache);
7957 // the API. The messages are formatted in JavaScript so this object is
7958 // a real JavaScript object. The information used for formatting the
7969 DECL_ACCESSORS(argument, Object)
7972 DECL_ACCESSORS(script, Object)
7974 // [stack_frames]: an array of stack frames for this error object.
7975 DECL_ACCESSORS(stack_frames, Object)
8039 DECL_ACCESSORS(data, Object)
8040 DECL_ACCESSORS(flags, Object)
8041 DECL_ACCESSORS(source, Object)
8056 inline Object* DataAt(int index);
8057 // Set implementation data after the object has been prepared.
8058 inline void SetDataAt(int index, Object* value);
8100 // fails, this fields hold an exception object that should be
8104 // fails, this fields hold an exception object that should be
8136 // In-object fields.
8140 // The uninitialized value for a regexp code object.
8143 // The compilation error value for the regexp code object. The real error
8144 // object is in the saved code field.
8158 static inline bool IsMatch(HashTableKey* key, Object* value) {
8166 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
8167 return key->HashForObject(object);
8170 static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
8178 // maps identifying info of the regexp to the cached regexp object. Scripts and
8179 // eval code only gets cached after a second probe for the code object. To do
8193 Handle<Object> Lookup(
8195 Handle<Object> LookupEval(
8198 Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
8202 Handle<Object> value);
8210 void Remove(Object* value);
8223 static inline bool IsMatch(HashTableKey* key, Object* value) {
8231 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
8232 return key->HashForObject(object);
8235 static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
8238 // The both the key (name + flags) and value (code object) can be derived from
8337 DECL_ACCESSORS(transition_info, Object)
8341 DECL_ACCESSORS(nested_site, Object)
8345 DECL_ACCESSORS(weak_next, Object)
8452 DECL_ACCESSORS(allocation_site, Object)
8734 DECL_ACCESSORS(name, Object)
8899 static Handle<Object> ToNumber(Handle<String> subject);
9232 inline Object* unchecked_first();
9240 inline Object* unchecked_second();
9547 DECL_ACCESSORS(to_number, Object)
9559 MUST_USE_RESULT static inline Handle<Object> ToNumber(Handle<Oddball> input);
9568 const char* to_string, Handle<Object> to_number,
9609 DECL_ACCESSORS(value, Object)
9614 Object* result = FromAddress(value - kValueOffset);
9642 DECL_ACCESSORS(property_details_raw, Object)
9644 DECL_ACCESSORS(value, Object)
9657 Handle<Object> value,
9660 Handle<Object> value, PropertyDetails details);
9666 Handle<Object> new_value);
9694 inline Object* value() const;
9704 DECL_ACCESSORS(next, Object)
9706 inline void clear_next(Object* the_hole_value);
9731 Handle<Object>,
9732 Handle<Object>);
9735 DECL_ACCESSORS(handler, Object)
9739 DECL_ACCESSORS(hash, Object)
9749 static MaybeHandle<Object> GetPrototype(Handle<JSProxy> receiver);
9753 Handle<Object> value,
9770 Isolate* isolate, Handle<JSProxy> object, Handle<Object> key,
9779 MUST_USE_RESULT static MaybeHandle<Object> GetProperty(
9781 Handle<Object> receiver, bool* was_found);
9786 Handle<Object> value,
9787 Handle<Object> receiver,
9815 static Object* GetIdentityHash(Handle<JSProxy> receiver);
9832 DECL_ACCESSORS(table, Object)
9892 DECL_ACCESSORS(table, Object)
9895 DECL_ACCESSORS(index, Object)
9898 DECL_ACCESSORS(kind, Object)
9931 inline Object* CurrentKey();
9976 inline Object* CurrentValue();
9986 DECL_ACCESSORS(table, Object)
9989 DECL_ACCESSORS(next, Object)
9992 static void Set(Handle<JSWeakCollection> collection, Handle<Object> key,
9993 Handle<Object> value, int32_t hash);
9994 static bool Delete(Handle<JSWeakCollection> collection, Handle<Object> key,
10005 // Iterates the function object according to the visiting policy.
10009 // Visit the whole object.
10058 DECL_ACCESSORS(byte_length, Object)
10105 // Iterates all fields in the object including internal ones except
10122 DECL_ACCESSORS(buffer, Object)
10125 DECL_ACCESSORS(byte_offset, Object)
10128 DECL_ACCESSORS(byte_length, Object)
10143 DECL_ACCESSORS(raw_byte_offset, Object)
10144 DECL_ACCESSORS(raw_byte_length, Object)
10154 DECL_ACCESSORS(length, Object)
10178 DECL_ACCESSORS(raw_length, Object)
10238 DECL_ACCESSORS(length, Object)
10268 Isolate* isolate, Handle<JSArray> o, Handle<Object> name,
10272 Handle<Object> length_object,
10311 Handle<Object> CacheInitialJSArrayMaps(Handle<Context> native_context,
10316 // This initial map adds in-object properties for "index" and "input"
10323 // Offsets of object fields.
10327 // Indices of in-object properties.
10342 // a new value is added to the derived object when the property is set.
10346 DECL_ACCESSORS(name, Object)
10348 DECL_ACCESSORS(expected_receiver_type, Object)
10350 DECL_ACCESSORS(getter, Object)
10351 DECL_ACCESSORS(setter, Object)
10354 DECL_ACCESSORS(js_getter, Object)
10355 DECL_ACCESSORS(data, Object)
10383 inline bool IsCompatibleReceiver(Object* receiver);
10392 static int AppendUnique(Handle<Object> descriptors,
10428 DECL_ACCESSORS(getter, Object)
10429 DECL_ACCESSORS(setter, Object)
10435 inline Object* get(AccessorComponent component);
10436 inline void set(AccessorComponent component, Object* value);
10439 static Handle<Object> GetComponent(Handle<AccessorPair> accessor_pair,
10443 inline void SetComponents(Object* getter, Object* setter);
10446 inline bool Equals(Object* getter_value, Object* setter_value);
10462 // Object.defineProperty(obj, "foo", {get: undefined});
10464 inline bool IsJSAccessor(Object* obj);
10472 DECL_ACCESSORS(callback, Object)
10473 DECL_ACCESSORS(named_interceptor, Object)
10474 DECL_ACCESSORS(indexed_interceptor, Object)
10475 DECL_ACCESSORS(data, Object)
10499 DECL_ACCESSORS(getter, Object)
10500 DECL_ACCESSORS(setter, Object)
10501 DECL_ACCESSORS(query, Object)
10502 DECL_ACCESSORS(deleter, Object)
10503 DECL_ACCESSORS(enumerator, Object)
10504 DECL_ACCESSORS(data, Object)
10538 DECL_ACCESSORS(callback, Object)
10539 DECL_ACCESSORS(data, Object)
10540 DECL_ACCESSORS(fast_handler, Object)
10560 DECL_ACCESSORS(tag, Object)
10561 DECL_ACCESSORS(serial_number, Object)
10563 DECL_ACCESSORS(property_list, Object)
10564 DECL_ACCESSORS(property_accessors, Object)
10585 DECL_ACCESSORS(call_code, Object)
10586 DECL_ACCESSORS(prototype_template, Object)
10587 DECL_ACCESSORS(parent_template, Object)
10588 DECL_ACCESSORS(named_property_handler, Object)
10589 DECL_ACCESSORS(indexed_property_handler, Object)
10590 DECL_ACCESSORS(instance_template, Object)
10591 DECL_ACCESSORS(class_name, Object)
10592 DECL_ACCESSORS(signature, Object)
10593 DECL_ACCESSORS(instance_call_handler, Object)
10594 DECL_ACCESSORS(access_check_info, Object)
10595 DECL_ACCESSORS(shared_function_info, Object)
10604 // If the bit is set, object instances created by this function
10642 // Returns true if |object| is an instance of this function template.
10643 inline bool IsTemplateFor(JSObject* object);
10663 DECL_ACCESSORS(constructor, Object)
10664 DECL_ACCESSORS(internal_field_count, Object)
10685 // Code object for the patched code. This code object is the code object
10693 // Get the break point info object for a code offset.
10694 Object* GetBreakPointInfo(int code_offset);
10697 Handle<Object> break_point_object);
10701 Handle<Object> break_point_object);
10703 Handle<Object> GetBreakPointObjects(int code_offset);
10704 // Find the break point info holding this break point object.
10705 static Handle<Object> FindBreakPointInfo(Handle<DebugInfo> debug_info,
10706 Handle<Object> break_point_object);
10738 // function. The DebugInfo object holds a BreakPointInfo object for each code
10750 DECL_ACCESSORS(break_point_objects, Object)
10754 Handle<Object> break_point_object);
10757 Handle<Object> break_point_object);
10758 // Check if break point info has this break point object.
10760 Handle<Object> break_point_object);
10828 virtual void VisitPointers(Object** start, Object** end) = 0;
10831 virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); }
10833 // Visit weak next_code_link in Code object.
10834 virtual void VisitNextCodeLink(Object** p) { VisitPointers(p, p + 1); }
10864 // Visit pointer embedded into a code object.
10867 // Visits an external reference embedded into a code object.
10877 virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
