Lines Matching defs:Object
46 // Most object types in the V8 JavaScript are described in this file.
49 // - MaybeObject (an object or a failure)
51 // - Object
125 // Formats of Object*:
204 // Indicates whether a get method should implicitly create the object looked up.
218 // As an example, a JavaScript object is a heap object and its map
233 // Object::IsString.
237 // 'object', whereas JS_FUNCTION_TYPE has typeof 'function'.
273 /* Object::IsExternalArray(). */ \
425 // A struct is a simple object a set of object-valued fields. Including an
426 // object type in this causes the compiler to generate most of the boilerplate
429 // object verification routines. Easy, no?
462 // We use the full 8 bits of the instance_type field to encode heap object
463 // instance types. The high-order bit (bit 7) is set if the object is not a
469 // Bit 6 indicates that the object is a symbol (if set) or not (if cleared).
664 object.
667 // Boundaries for testing the types for which typeof is "object".
713 Object* ptr;
720 template <class C> static inline bool Is(Object* obj);
730 inline bool ToObject(Object** obj) {
732 *obj = reinterpret_cast<Object*>(this);
739 inline Object* ToObjectUnchecked() {
741 return reinterpret_cast<Object*>(this);
743 inline Object* ToObjectChecked() {
745 return reinterpret_cast<Object*>(this);
751 *obj = T::cast(reinterpret_cast<Object*>(this));
756 // Prints this object with details.
767 // Verifies the object.
854 // Object is the abstract superclass for all classes in the
855 // object hierarchy.
856 // Object does not use any virtual functions to avoid the
858 // Since Smi and Failure are subclasses of Object no
859 // data members can be present in Object.
860 class Object : public MaybeObject {
872 // Returns true if this object is an instance of the specified
900 // Returns true if the object is of the correct type to be used as a
907 Object* ToBoolean(); // ECMA-262 9.2.
910 // global_context is used when creating wrapper object.
925 Object* receiver,
929 static Handle<Object> GetProperty(Handle<Object> object,
930 Handle<Object> receiver,
935 MUST_USE_RESULT MaybeObject* GetProperty(Object* receiver,
940 MUST_USE_RESULT MaybeObject* GetPropertyWithDefinedGetter(Object* receiver,
943 static Handle<Object> GetElement(Handle<Object> object, uint32_t index);
946 inline Object* GetElementNoExceptionThrown(uint32_t index);
947 MUST_USE_RESULT MaybeObject* GetElementWithReceiver(Object* receiver,
950 // Return the object's prototype (might be Heap::null_value()).
951 Object* GetPrototype();
953 // Returns the permanent hash code associated with this object depending on
954 // the actual object type. Might return a failure in case no hash was
958 // Checks whether this object has the same value as the given one. This
961 bool SameValue(Object* other);
963 // Tries to convert an object to an array index. Returns true and sets
972 // Verify a pointer is a valid object pointer.
973 static void VerifyPointer(Object* p);
976 // Prints this object without details.
982 // Prints this object without details to a message accumulator.
986 static Object* cast(Object* value) { return value; }
989 static const int kHeaderSize = 0; // Object does not take up any space.
992 DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
1002 class Smi: public Object {
1007 // Convert a value to a Smi object.
1016 static inline Smi* cast(Object* object);
1039 // are transient and cannot occur as part of the object graph.
1089 static inline Failure* cast(MaybeObject* object);
1112 // value in a heap object's first word.
1125 // contains a forwarding address (a heap object pointer in the to space).
1129 // when all map words are heap object pointers, i.e. not during a full GC).
1133 static inline MapWord FromForwardingAddress(HeapObject* object);
1158 class HeapObject: public Object {
1160 // [map]: Contains a map which contains the object's reflective
1164 // The no-write-barrier version. This is OK if the object is white and in
1165 // new space, or if the value is an immortal immutable object, like the maps
1169 // During garbage collection, the map word of a heap object does not
1174 // The Heap the object was allocated in. Used also to access Isolate.
1188 // Iterates over pointers contained in the object (including the Map)
1191 // Iterates over all pointers contained in the object except the
1192 // first map pointer. The object type is given in the first
1194 // object, and so is safe to call while the map pointer is modified.
1197 // Returns the heap object's size in bytes
1200 // Given a heap object's map pointer, returns the heap size in bytes
1205 // Returns the field at offset in obj, as a read/write Object* reference.
1209 static inline Object** RawField(HeapObject* obj, int offset);
1212 static inline HeapObject* cast(Object* obj);
1216 // object as a sign that they are not going to use this function
1236 // Verify a pointer is a valid HeapObject pointer that points to object
1238 static void VerifyHeapPointer(Object* p);
1242 // First field in a heap object is map.
1243 static const int kMapOffset = Object::kHeaderSize;
1261 reinterpret_cast<Object**>((obj)->address() + offset)
1263 // This class describes a body of an object of a fixed size
1283 // This class describes a body of an object of a variable size
1314 static inline HeapNumber* cast(Object* obj);
1317 Object* HeapNumberToBoolean();
1390 static inline JSReceiver* cast(Object* obj);
1392 static Handle<Object> SetProperty(Handle<JSReceiver> object,
1394 Handle<Object> value,
1399 Object* value,
1404 Object* value,
1408 Object* value);
1416 Object* value,
1428 // function that was used to instantiate the object).
1441 // Return the object's prototype (might be Heap::null_value()).
1442 inline Object* GetPrototype();
1444 // Set the object's prototype (only JSReceiver and null are allowed).
1445 MUST_USE_RESULT MaybeObject* SetPrototype(Object* value,
1448 // Retrieves a permanent object identity hash code. The undefined value might
1486 // corrensponds to a set of object representations of elements that
1500 // arguments object.
1508 // Returns if an object has either FAST_ELEMENT or FAST_SMI_ONLY_ELEMENT
1545 MUST_USE_RESULT MaybeObject* GetPropertyWithCallback(Object* receiver,
1546 Object* structure,
1552 Object* value,
1558 Object* value,
1562 Object* structure,
1564 Object* value,
1569 Object* value,
1574 Object* value,
1578 static Handle<Object> SetLocalPropertyIgnoreAttributes(
1579 Handle<JSObject> object,
1581 Handle<Object> value,
1587 Object* value,
1590 // Retrieve a value in a normalized object given a lookup result.
1592 Object* GetNormalizedProperty(LookupResult* result);
1594 // Sets the property value in a normalized object given a lookup result.
1596 Object* SetNormalizedProperty(LookupResult* result, Object* value);
1598 // Sets the property value in a normalized object given (key, value, details).
1600 static Handle<Object> SetNormalizedProperty(Handle<JSObject> object,
1602 Handle<Object> value,
1606 Object* value,
1609 // Deletes the named property in a normalized object.
1625 Object* receiver,
1630 static void DefineAccessor(Handle<JSObject> object,
1632 Handle<Object> getter,
1633 Handle<Object> setter,
1636 Object* getter,
1637 Object* setter,
1639 Object* LookupAccessor(String* name, AccessorComponent component);
1643 // Used from Object::GetProperty().
1645 Object* receiver,
1668 inline Object* BypassGlobalProxy();
1670 // Accessors for hidden properties object.
1672 // Hidden properties are not local properties of the object itself.
1675 // receiver is a JSGlobalProxy then the auxiliary object is a property
1679 // Sets a hidden property on this object. Returns this object if successful,
1681 static Handle<Object> SetHiddenProperty(Handle<JSObject> obj,
1683 Handle<Object> value);
1685 MUST_USE_RESULT MaybeObject* SetHiddenProperty(String* key, Object* value);
1689 Object* GetHiddenProperty(String* key);
1693 // Returns true if the object has a property with the hidden symbol as name.
1698 MUST_USE_RESULT MaybeObject* SetIdentityHash(Object* hash, CreationFlag flag);
1700 static Handle<Object> DeleteProperty(Handle<JSObject> obj,
1704 static Handle<Object> DeleteElement(Handle<JSObject> obj, uint32_t index);
1709 // Makes sure that this object can contain HeapObject as elements.
1712 // Makes sure that this object can contain the specified elements.
1714 Object** elements,
1730 // this object takes up nearly as much space as a fast-case backing
1771 Object* value,
1777 Object* value,
1785 Object* value,
1789 static Handle<Object> SetOwnElement(Handle<JSObject> object,
1791 Handle<Object> value,
1795 static MUST_USE_RESULT Handle<Object> SetElement(
1796 Handle<JSObject> object,
1798 Handle<Object> value,
1803 // A Failure object is returned if GC is needed.
1806 Object* value,
1813 // The undefined object if index is out of bounds.
1814 MUST_USE_RESULT MaybeObject* GetElementWithInterceptor(Object* receiver,
1850 inline Object* GetInternalField(int index);
1851 inline void SetInternalField(int index, Object* value);
1860 uint32_t index, Object* value, bool* found, StrictModeFlag strict_mode);
1863 // Returns the number of properties on this object filtering out properties
1870 // Returns the number of properties on this object filtering out properties
1875 // Returns the number of elements on this object filtering out elements
1885 // Add a property to a fast-case object using a map transition to
1889 Object* value);
1891 // Add a constant function property to a fast-case object.
1893 // if it is called on a second object with this map, a
1904 Object* value,
1907 // Returns a new map with all transitions dropped from the object's current
1909 static Handle<Map> GetElementsTransitionMap(Handle<JSObject> object,
1917 static Handle<Object> TransitionElementsKind(Handle<JSObject> object,
1925 // Converts the descriptor on the original object's map to a
1926 // map transition, and the the new field is on the object's new map.
1929 Object* new_value,
1937 Object* new_value,
1940 // Add a property to a fast-case object.
1942 Object* value,
1945 // Add a property to a slow-case object.
1947 Object* value,
1950 // Add a property to an object.
1952 Object* value,
1956 // Convert the object to use the canonical dictionary
1957 // representation. If the object is expected to have additional properties
1960 static void NormalizeProperties(Handle<JSObject> object,
1971 Handle<JSObject> object);
1975 static void UpdateMapCodeCache(Handle<JSObject> object,
1983 static void TransformToFastProperties(Handle<JSObject> object,
1989 // Access fast-case object properties at index.
1990 inline Object* FastPropertyAt(int index);
1991 inline Object* FastPropertyAtPut(int index, Object* value);
1993 // Access to in object properties.
1995 inline Object* InObjectPropertyAt(int index);
1996 inline Object* InObjectPropertyAtPut(int index,
1997 Object* value,
2007 Object* pre_allocated_value,
2008 Object* filler_value);
2010 // Check whether this object references another object
2011 bool ReferencesObject(Object* obj);
2014 static inline JSObject* cast(Object* obj);
2016 // Disalow further properties to be added to the object.
2017 static Handle<Object> PreventExtensions(Handle<JSObject> object);
2069 Object* SlowReverseLookup(Object* value);
2100 // to the same object requires fewer allocations and copies.
2112 static inline int SizeOf(Map* map, HeapObject* object);
2118 MUST_USE_RESULT MaybeObject* GetElementWithCallback(Object* receiver,
2119 Object* structure,
2121 Object* holder);
2123 Object* structure,
2125 Object* value,
2130 Object* value,
2137 Object* value,
2150 Object* value,
2167 Object* object);
2178 Object* structure,
2182 Object* structure,
2186 Object* getter,
2187 Object* setter,
2191 Object* getter,
2192 Object* setter,
2196 // Returns the hidden properties backing store object, currently
2197 // a StringDictionary, stored on this object.
2198 // If no hidden properties object has been put on this object,
2200 // a new dictionary is created, added to this object, and returned.
2219 inline static FixedArrayBase* cast(Object* object);
2230 // FixedArray describes fixed-sized arrays with element type Object*.
2234 inline Object* get(int index);
2236 inline void set(int index, Object* value);
2242 inline void set(int index, Object* value, WriteBarrierMode mode);
2256 inline void set_unchecked(Heap* heap, int index, Object* value,
2260 inline Object** data_start();
2262 inline Object** GetFirstElementAddress();
2285 static inline FixedArray* cast(Object* obj);
2308 // numbers array are the same object, the elements are only swapped
2314 // object, the prefix of this array is sorted.
2319 static inline int SizeOf(Map* map, HeapObject* object) {
2320 return SizeFor(reinterpret_cast<FixedArray*>(object)->length());
2329 Object* value);
2332 // only be used if the object is guaranteed to be white (whiteness witness
2336 Object* value);
2372 static inline FixedDoubleArray* cast(Object* obj);
2406 // [0]: storage for bit_field3 for Map owning this object (Smi)
2430 Object* obj = get(kEnumerationIndexIndex);
2434 Object* index = FixedArray::cast(obj)->get(kEnumCacheBridgeEnumIndex);
2449 Object* GetEnumCache() {
2465 Object* new_index_cache);
2469 inline Object* GetValue(int descriptor_number);
2474 inline Object* GetCallbacksObject(int descriptor_number);
2521 // removed. Return a Failure object in case of an allocation failure.
2554 // empty descriptor array object if number_of_descriptors is 0.
2558 static inline DescriptorArray* cast(Object* obj);
2613 inline Object* GetCallbackObject() { return descs_->GetValue(index_); }
2668 // static bool IsMatch(Key key, Object* other);
2671 // // Returns the hash value for object.
2672 // static uint32_t HashForObject(Key key, Object* object);
2673 // // Convert key to an object.
2674 // static inline Object* AsObject(Key key);
2694 static uint32_t HashForObject(Key key, Object* object) { return 0; }
2695 static uint32_t SeededHashForObject(Key key, uint32_t seed, Object* object) {
2697 return HashForObject(key, object);
2714 inline uint32_t HashForObject(Key key, Object* object) {
2717 GetHeap()->HashSeed(), object);
2719 return Shape::HashForObject(key, object);
2753 // Returns a new HashTable object. Might return Failure.
2763 Object* KeyAt(int entry) { return get(EntryToIndex(entry)); }
2767 bool IsKey(Object* k) {
2776 static inline HashTable* cast(Object* obj);
2867 // Returns whether the other object matches this key.
2868 virtual bool IsMatch(Object* other) = 0;
2871 object.
2872 virtual uint32_t HashForObject(Object* key) = 0;
2873 // Returns the key object for storing into the hash table.
2874 // If allocations fails a failure object is returned.
2883 static inline bool IsMatch(HashTableKey* key, Object* value) {
2889 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
2890 return key->HashForObject(object);
2912 MUST_USE_RESULT MaybeObject* LookupSymbol(Vector<const char> str, Object** s);
2914 Object** s);
2919 Object** s);
2921 Object** s);
2922 MUST_USE_RESULT MaybeObject* LookupString(String* key, Object** s);
2931 static inline SymbolTable* cast(Object* obj);
2934 MUST_USE_RESULT MaybeObject* LookupKey(HashTableKey* key, Object** s);
2942 static inline bool IsMatch(HashTableKey* key, Object* value) {
2949 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
2950 return key->HashForObject(object);
2965 // Used for canonicalize maps for object literals.
2969 Object* Lookup(FixedArray* key);
2971 static inline MapCache* cast(Object* obj);
2981 static inline Dictionary<Shape, Key>* cast(Object* obj) {
2986 Object* ValueAt(int entry) {
2991 void ValueAtPut(int entry, Object* value) {
3011 Object* DeleteProperty(int entry, JSObject::DeleteMode mode);
3053 Object* SlowReverseLookup(Object* value);
3057 Object* key,
3058 Object* value);
3060 Object* key,
3061 Object* value,
3065 Object* value,
3070 MUST_USE_RESULT MaybeObject* AtPut(Key key, Object* value);
3074 Object* value,
3088 static inline bool IsMatch(String* key, Object* other);
3090 static inline uint32_t HashForObject(String* key, Object* object);
3100 static inline StringDictionary* cast(Object* obj) {
3123 static inline bool IsMatch(uint32_t key, Object* other);
3138 Object* object);
3147 static inline uint32_t HashForObject(uint32_t key, Object* object);
3154 static SeededNumberDictionary* cast(Object* obj) {
3160 MUST_USE_RESULT MaybeObject* AtNumberPut(uint32_t key, Object* value);
3162 Object* value,
3170 Handle<Object> value,
3174 Object* value,
3202 static UnseededNumberDictionary* cast(Object* obj) {
3208 MUST_USE_RESULT MaybeObject* AtNumberPut(uint32_t key, Object* value);
3209 MUST_USE_RESULT MaybeObject* AddNumberEntry(uint32_t key, Object* value);
3216 Handle<Object> value);
3218 MUST_USE_RESULT MaybeObject* Set(uint32_t key, Object* value);
3223 class ObjectHashTableShape : public BaseShape<Object*> {
3225 static inline bool IsMatch(Object* key, Object* other);
3226 static inline uint32_t Hash(Object* key);
3227 static inline uint32_t HashForObject(Object* key, Object* object);
3228 MUST_USE_RESULT static inline MaybeObject* AsObject(Object* key);
3236 class ObjectHashSet: public HashTable<ObjectHashTableShape<1>, Object*> {
3238 static inline ObjectHashSet* cast(Object* obj) {
3244 bool Contains(Object* key);
3247 MUST_USE_RESULT MaybeObject* Add(Object* key);
3250 MUST_USE_RESULT MaybeObject* Remove(Object* key);
3254 // ObjectHashTable maps keys that are arbitrary objects to object values by
3256 class ObjectHashTable: public HashTable<ObjectHashTableShape<2>, Object*> {
3258 static inline ObjectHashTable* cast(Object* obj) {
3265 Object* Lookup(Object* key);
3269 MUST_USE_RESULT MaybeObject* Put(Object* key, Object* value);
3274 void AddEntry(int entry, Object* key, Object* value);
3314 static inline JSFunctionResultCache* cast(Object* obj);
3327 // This object provides quick access to scope info details for runtime
3331 static inline ScopeInfo* cast(Object* object);
3530 MUST_USE_RESULT MaybeObject* Get(JSObject* object,
3536 static inline NormalizedMapCache* cast(Object* obj);
3573 // Returns a pointer to the ByteArray object for a given data start address.
3577 static inline ByteArray* cast(Object* obj);
3617 static inline FreeSpace* cast(Object* obj);
3661 static inline ExternalArray* cast(Object* obj);
3678 // semantics used for implementing the CanvasPixelArray object. Please see the
3696 Object* SetValue(uint32_t index, Object* value);
3699 static inline ExternalPixelArray* cast(Object* obj);
3725 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3728 static inline ExternalByteArray* cast(Object* obj);
3754 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3757 static inline ExternalUnsignedByteArray* cast(Object* obj);
3783 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3786 static inline ExternalShortArray* cast(Object* obj);
3812 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3815 static inline ExternalUnsignedShortArray* cast(Object* obj);
3841 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3844 static inline ExternalIntArray* cast(Object* obj);
3870 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3873 static inline ExternalUnsignedIntArray* cast(Object* obj);
3899 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3902 static inline ExternalFloatArray* cast(Object* obj);
3928 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3931 static inline ExternalDoubleArray* cast(Object* obj);
4014 static inline DeoptimizationInputData* cast(Object* obj);
4053 static inline DeoptimizationOutputData* cast(Object* obj);
4082 // The object that indicates an uninitialized cache.
4083 static inline Handle<Object> UninitializedSentinel(Isolate* isolate);
4085 // The object that indicates a megamorphic state.
4086 static inline Handle<Object> MegamorphicSentinel(Isolate* isolate);
4090 static inline Object* RawUninitializedSentinel(Heap* heap);
4093 static inline TypeFeedbackCells* cast(Object* obj);
4175 // Will contain either a TypeFeedbackInfo object, or undefined.
4176 DECL_ACCESSORS(type_feedback_info, Object)
4181 DECL_ACCESSORS(gc_metadata, Object)
4184 // at the moment when this object was created.
4259 // the code object was seen on the stack with no IC patching going on.
4309 // Mark this code object as not having a stack check table. Assumes kind
4363 // Convert a target address into a code object.
4366 // Convert an entry address into an object.
4367 static inline Object* GetObjectFromEntryAddress(Address location_of_address);
4384 // Returns true if pc is inside this object's instructions.
4388 // object has been moved by delta bytes.
4394 // Returns the object size for a given body (used for allocation).
4400 // Calculate the size of the code object to report for log events. This takes
4401 // the layout of the code object into account.
4403 // Check that the assumptions about the layout of the code object holds.
4414 static inline Code* cast(Object* obj);
4456 // the Code object header.
4510 // - Size information about the object
4511 // - How to iterate over an object (for garbage collection)
4520 // Count of properties allocated in the object.
4524 // Count of property fields pre-allocated in the object when first allocated.
4552 // Tells whether the object in the prototype property will be used
4595 // An undetectable object is a special class of JSObject: 'typeof' operator
4597 // a normal JS object. It is useful for implementing undetectable
4687 // [prototype]: implicit prototype object.
4688 DECL_ACCESSORS(prototype, Object)
4691 DECL_ACCESSORS(constructor, Object)
4699 // [instance descriptors]: describes the object.
4707 DECL_ACCESSORS(code_cache, Object)
4711 // when we change object's prototype to a new one.
4767 static inline Map* cast(Object* obj);
4784 Object* FindInCodeCache(String* name, Code::Flags flags);
4786 // Returns the non-negative index of the code object if it is in the
4788 int IndexInCodeCache(Object* name, Code* code);
4790 // Removes a code object from the code cache at the given index.
4798 void CreateOneBackPointer(Object* transition_target);
4804 void ClearNonLiveTransitions(Heap* heap, Object* real_prototype);
4806 // Restore a possible back pointer in the prototype field of object.
4809 bool RestoreOneBackPointer(Object* object,
4810 Object* real_prototype,
4825 Object* GetDescriptorContents(String* sentinel_name,
4868 Object* GetPrototypeTransition(Object* prototype);
4870 MUST_USE_RESULT MaybeObject* PutPrototypeTransition(Object* prototype,
4976 static inline Struct* cast(Object* that);
5003 DECL_ACCESSORS(source, Object)
5006 DECL_ACCESSORS(name, Object)
5009 DECL_ACCESSORS(id, Object)
5019 DECL_ACCESSORS(data, Object)
5022 DECL_ACCESSORS(context_data, Object)
5037 DECL_ACCESSORS(line_ends, Object)
5041 DECL_ACCESSORS(eval_from_shared, Object)
5047 static inline Script* cast(Object* obj);
5089 // Each entry has a name of a global object property holding an object
5091 // on the object (the one the id is set for), and a label.
5141 DECL_ACCESSORS(name, Object)
5214 // Proceed to create an object in the current context (with the adjusted
5235 // object reference this map).
5236 DECL_ACCESSORS(initial_map, Object)
5267 DECL_ACCESSORS(instance_class_name, Object)
5275 DECL_ACCESSORS(function_data, Object)
5283 DECL_ACCESSORS(script, Object)
5298 DECL_ACCESSORS(debug_info, Object)
5303 // all functions are anonymous but are assigned to object
5364 // code object. Used to determine when it is relatively safe to flush
5365 // this code object and replace it with lazy compilation stub.
5366 // Age is reset when GC notices that the code object is referenced
5392 // False if the function definitely does not allocate an arguments object.
5401 // global object.
5445 bool CanGenerateInlineConstructor(Object* prototype);
5453 DECL_ACCESSORS(this_property_assignments, Object)
5459 Object* GetThisPropertyAssignmentConstant(int index);
5463 Handle<Object> GetSourceCode();
5474 // Calculate the number of in-object properties.
5502 static inline SharedFunctionInfo* cast(Object* obj);
5703 DECL_ACCESSORS(prototype_or_initial_map, Object)
5713 inline Object* unchecked_context();
5714 inline void set_context(Object* context);
5716 // [code]: The generated code object for this function. Executed
5760 // If the function contains object, regexp or array literals, the
5761 // literals array prefix contains the object, regexp, and array
5763 // necessary so that we do not dynamically lookup the object, regexp
5779 // The initial map for an object created by this constructor.
5792 inline Object* prototype();
5793 inline Object* instance_prototype();
5794 MUST_USE_RESULT MaybeObject* SetInstancePrototype(Object* value);
5795 MUST_USE_RESULT MaybeObject* SetPrototype(Object* value);
5799 Object* RemovePrototype();
5811 Object* SetInstanceClassName(String* name);
5818 DECL_ACCESSORS(next_function_link, Object)
5827 static inline JSFunction* cast(Object* obj);
5830 // through pointers to the first instruction in the code object.
5887 // [context]: the owner global context of this global proxy object.
5888 // It is null value if this object is not used by any context.
5889 DECL_ACCESSORS(context, Object)
5892 static inline JSGlobalProxy* cast(Object* obj);
5921 // [builtins]: the object holding the runtime routines written in JS.
5924 // [global context]: the global context corresponding to this global object.
5927 // [global receiver]: the global receiver object of the context
5936 // on the object.
5937 Object* GetPropertyNoExceptionThrown(String* key) {
5938 Object* answer = GetProperty(key)->ToObjectUnchecked();
5942 // Ensure that the global object has a cell for the given property name.
5951 static inline GlobalObject* cast(Object* obj);
5964 // JavaScript global object.
5968 static inline JSGlobalObject* cast(Object* obj);
5989 // Builtins global object which holds the runtime routines written in
5994 inline Object* javascript_builtin(Builtins::JavaScript id);
5995 inline void set_javascript_builtin(Builtins::JavaScript id, Object* value);
6002 static inline JSBuiltinsObject* cast(Object* obj);
6015 // Layout description. The size of the builtins object includes
6017 // (function and code object).
6041 object being wrapped.
6042 DECL_ACCESSORS(value, Object)
6045 static inline JSValue* cast(Object* obj);
6074 DECL_ACCESSORS(value, Object)
6076 DECL_ACCESSORS(year, Object)
6078 DECL_ACCESSORS(month, Object)
6080 DECL_ACCESSORS(day, Object)
6082 DECL_ACCESSORS(weekday, Object)
6084 DECL_ACCESSORS(hour, Object)
6086 DECL_ACCESSORS(min, Object)
6088 DECL_ACCESSORS(sec, Object)
6091 DECL_ACCESSORS(cache_stamp, Object)
6094 static inline JSDate* cast(Object* obj);
6098 static MaybeObject* GetField(Object* date, Smi* index);
6100 void SetValue(Object* value, bool is_value_nan);
6155 inline Object* DoGetField(FieldIndex index);
6157 Object* GetUTCField(FieldIndex index, double value, DateCache* date_cache);
6168 // the API. The messages are formatted in JavaScript so this object is
6169 // a real JavaScript object. The information used for formatting the
6182 DECL_ACCESSORS(script, Object)
6185 DECL_ACCESSORS(stack_trace, Object)
6187 // [stack_frames]: an array of stack frames for this error object.
6188 DECL_ACCESSORS(stack_frames, Object)
6199 static inline JSMessageObject* cast(Object* obj);
6265 DECL_ACCESSORS(data, Object)
6271 inline Object* DataAt(int index);
6272 // Set implementation data after the object has been prepared.
6273 inline void SetDataAt(int index, Object* value);
6276 inline Object* DataAtUnchecked(int index);
6277 inline void SetDataAtUnchecked(int index, Object* value, Heap* heap);
6296 static inline JSRegExp* cast(Object* obj);
6319 // fails, this fields hold an exception object that should be
6323 // fails, this fields hold an exception object that should be
6352 // In-object fields.
6360 // The uninitialized value for a regexp code object.
6363 // The compilation error value for the regexp code object. The real error
6364 // object is in the saved code field.
6376 static inline bool IsMatch(HashTableKey* key, Object* value) {
6384 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
6385 return key->HashForObject(object);
6401 Object* Lookup(String* src);
6402 Object* LookupEval(String* src,
6406 Object* LookupRegExp(String* source, JSRegExp::Flags flags);
6407 MUST_USE_RESULT MaybeObject* Put(String* src, Object* value);
6417 void Remove(Object* value);
6419 static inline CompilationCacheTable* cast(Object* obj);
6429 DECL_ACCESSORS(normal_type_cache, Object)
6431 // Add the code object to the cache.
6434 // Lookup code object in the cache. Returns code object if found and undefined
6436 Object* Lookup(String* name, Code::Flags flags);
6438 // Get the internal index of a code object in the cache. Returns -1 if the
6439 // code object is not in that cache. This index can be used to later call
6442 int GetIndex(Object* name, Code* code);
6444 // Remove an object from the cache with the provided internal index.
6445 void RemoveByIndex(Object* name, Code* code, int index);
6447 static inline CodeCache* cast(Object* obj);
6467 Object* LookupDefaultCache(String* name, Code::Flags flags);
6468 Object* LookupNormalTypeCache(String* name, Code::Flags flags);
6482 static inline bool IsMatch(HashTableKey* key, Object* value) {
6490 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
6491 return key->HashForObject(object);
6506 Object* Lookup(String* name, Code::Flags flags);
6512 static inline CodeCacheHashTable* cast(Object* obj);
6524 DECL_ACCESSORS(cache, Object)
6536 Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
6538 static inline PolymorphicCodeCache* cast(Object* obj);
6561 Object* Lookup(MapHandleList* maps, int code_kind);
6567 static inline PolymorphicCodeCacheHashTable* cast(Object* obj);
6585 static inline TypeFeedbackInfo* cast(Object* obj);
6622 static inline AliasedArgumentsEntry* cast(Object* obj);
6882 // Mark the string as an undetectable object. It only applies to
6946 static inline String* cast(Object* obj);
7150 static inline SeqString* cast(Object* obj);
7176 static inline SeqAsciiString* cast(Object* obj);
7226 static inline SeqTwoByteString* cast(Object* obj);
7268 inline Object* unchecked_first();
7276 inline Object* unchecked_second();
7284 static inline ConsString* cast(Object* obj);
7337 static inline SlicedString* cast(Object* obj);
7379 static inline ExternalString* cast(Object* obj);
7421 static inline ExternalAsciiString* cast(Object* obj);
7469 static inline ExternalTwoByteString* cast(Object* obj);
7578 DECL_ACCESSORS(to_number, Object)
7584 static inline Oddball* cast(Object* obj);
7593 Object* to_number,
7623 DECL_ACCESSORS(value, Object)
7626 static inline JSGlobalPropertyCell* cast(Object* obj);
7655 DECL_ACCESSORS(handler, Object)
7658 DECL_ACCESSORS(hash, Object)
7661 static inline JSProxy* cast(Object* obj);
7667 Object* receiver,
7670 Object* receiver,
7675 Object* value,
7680 Object* value,
7687 Object* value,
7712 inline void InitializeBody(int object_size, Object* value);
7716 Handle<Object> CallTrap(const char* name,
7717 Handle<Object> derived_trap,
7719 Handle<Object> args[]);
7756 DECL_ACCESSORS(call_trap, Object)
7759 DECL_ACCESSORS(construct_trap, Object)
7762 static inline JSFunctionProxy* cast(Object* obj);
7797 DECL_ACCESSORS(table, Object)
7800 static inline JSSet* cast(Object* obj);
7824 DECL_ACCESSORS(table, Object)
7827 static inline JSMap* cast(Object* obj);
7851 DECL_ACCESSORS(table, Object)
7854 DECL_ACCESSORS(next, Object)
7857 static inline JSWeakMap* cast(Object* obj);
7888 static inline Foreign* cast(Object* obj);
7926 DECL_ACCESSORS(length, Object)
7933 Object* value);
7942 MUST_USE_RESULT MaybeObject* SetElementsLength(Object* length);
7948 static inline JSArray* cast(Object* obj);
7982 // This initial map adds in-object properties for "index" and "input"
7989 // Offsets of object fields.
7993 // Indices of in-object properties.
8008 // a new value is added to the local object when the property is set.
8012 DECL_ACCESSORS(getter, Object)
8013 DECL_ACCESSORS(setter, Object)
8014 DECL_ACCESSORS(data, Object)
8015 DECL_ACCESSORS(name, Object)
8030 static inline AccessorInfo* cast(Object* obj);
8068 DECL_ACCESSORS(getter, Object)
8069 DECL_ACCESSORS(setter, Object)
8071 static inline AccessorPair* cast(Object* obj);
8076 Object* GetComponent(AccessorComponent component);
8079 void SetComponents(Object* getter, Object* setter) {
8103 // Object.defineProperty(obj, "foo", {get: undefined});
8105 bool IsJSAccessor(Object* obj) {
8115 DECL_ACCESSORS(named_callback, Object)
8116 DECL_ACCESSORS(indexed_callback, Object)
8117 DECL_ACCESSORS(data, Object)
8119 static inline AccessCheckInfo* cast(Object* obj);
8143 DECL_ACCESSORS(getter, Object)
8144 DECL_ACCESSORS(setter, Object)
8145 DECL_ACCESSORS(query, Object)
8146 DECL_ACCESSORS(deleter, Object)
8147 DECL_ACCESSORS(enumerator, Object)
8148 DECL_ACCESSORS(data, Object)
8150 static inline InterceptorInfo* cast(Object* obj);
8177 DECL_ACCESSORS(callback, Object)
8178 DECL_ACCESSORS(data, Object)
8180 static inline CallHandlerInfo* cast(Object* obj);
8203 DECL_ACCESSORS(tag, Object)
8204 DECL_ACCESSORS(property_list, Object)
8221 DECL_ACCESSORS(serial_number, Object)
8222 DECL_ACCESSORS(call_code, Object)
8223 DECL_ACCESSORS(property_accessors, Object)
8224 DECL_ACCESSORS(prototype_template, Object)
8225 DECL_ACCESSORS(parent_template, Object)
8226 DECL_ACCESSORS(named_property_handler, Object)
8227 DECL_ACCESSORS(indexed_property_handler, Object)
8228 DECL_ACCESSORS(instance_template, Object)
8229 DECL_ACCESSORS(class_name, Object)
8230 DECL_ACCESSORS(signature, Object)
8231 DECL_ACCESSORS(instance_call_handler, Object)
8232 DECL_ACCESSORS(access_check_info, Object)
8238 // If the bit is set, object instances created by this function
8243 static inline FunctionTemplateInfo* cast(Object* obj);
8289 DECL_ACCESSORS(constructor, Object)
8290 DECL_ACCESSORS(internal_field_count, Object)
8292 static inline ObjectTemplateInfo* cast(Object* obj);
8313 DECL_ACCESSORS(receiver, Object)
8314 DECL_ACCESSORS(args, Object)
8316 static inline SignatureInfo* cast(Object* obj);
8339 DECL_ACCESSORS(types, Object)
8341 static inline TypeSwitchInfo* cast(Object* obj);
8365 // Code object for the original code.
8367 // Code object for the patched code. This code object is the code object
8375 // Get the break point info object for a code position.
8376 Object* GetBreakPointInfo(int code_position);
8380 Handle<Object> break_point_object);
8384 Handle<Object> break_point_object);
8386 Object* GetBreakPointObjects(int code_position);
8387 // Find the break point info holding this break point object.
8388 static Object* FindBreakPointInfo(Handle<DebugInfo> debug_info,
8389 Handle<Object> break_point_object);
8393 static inline DebugInfo* cast(Object* obj);
8425 // function. The DebugInfo object holds a BreakPointInfo object for each code
8437 DECL_ACCESSORS(break_point_objects, Object)
8441 Handle<Object> break_point_object);
8444 Handle<Object> break_point_object);
8445 // Check if break point info has this break point object.
8447 Handle<Object> break_point_object);
8451 static inline BreakPointInfo* cast(Object* obj);
8517 virtual void VisitPointers(Object** start, Object** end) = 0;
8544 virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); }
8546 // Visit pointer embedded into a code object.
8563 virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
8575 static inline int SizeOf(Map* map, HeapObject* object) {
