6d648ad262944ed7b4670e23df79c8e63b2985b8
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSCell.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef JSCell_h
24 #define JSCell_h
25
26 #include "CallData.h"
27 #include "ConstructData.h"
28 #include "EnumerationMode.h"
29 #include "Heap.h"
30 #include "IndexingType.h"
31 #include "JSLock.h"
32 #include "JSTypeInfo.h"
33 #include "SlotVisitor.h"
34 #include "TypedArrayType.h"
35 #include "WriteBarrier.h"
36 #include <wtf/Noncopyable.h>
37
38 namespace JSC {
39
40 class CopyVisitor;
41 class ExecState;
42 class Identifier;
43 class JSArrayBufferView;
44 class JSDestructibleObject;
45 class JSGlobalObject;
46 class LLIntOffsetsExtractor;
47 class PropertyDescriptor;
48 class PropertyNameArray;
49 class Structure;
50
51 template<typename T> void* allocateCell(Heap&);
52 template<typename T> void* allocateCell(Heap&, size_t);
53
54 #define DECLARE_EXPORT_INFO                                             \
55     protected:                                                          \
56         static JS_EXPORTDATA const ::JSC::ClassInfo s_info;             \
57     public:                                                             \
58         static const ::JSC::ClassInfo* info() { return &s_info; }
59
60 #define DECLARE_INFO                                                    \
61     protected:                                                          \
62         static const ::JSC::ClassInfo s_info;                           \
63     public:                                                             \
64         static const ::JSC::ClassInfo* info() { return &s_info; }
65
66 class JSCell {
67     friend class JSValue;
68     friend class MarkedBlock;
69     template<typename T> friend void* allocateCell(Heap&);
70     template<typename T> friend void* allocateCell(Heap&, size_t);
71
72 public:
73     static const unsigned StructureFlags = 0;
74
75     static const bool needsDestruction = false;
76
77     static JSCell* seenMultipleCalleeObjects() { return bitwise_cast<JSCell*>(static_cast<uintptr_t>(1)); }
78
79     enum CreatingEarlyCellTag { CreatingEarlyCell };
80     JSCell(CreatingEarlyCellTag);
81
82 protected:
83     JSCell(VM&, Structure*);
84     JS_EXPORT_PRIVATE static void destroy(JSCell*);
85
86 public:
87     // Querying the type.
88     bool isString() const;
89     bool isSymbol() const;
90     bool isObject() const;
91     bool isGetterSetter() const;
92     bool isCustomGetterSetter() const;
93     bool isProxy() const;
94     bool inherits(const ClassInfo*) const;
95     bool isAPIValueWrapper() const;
96
97     JSType type() const;
98     IndexingType indexingType() const;
99     StructureID structureID() const { return m_structureID; }
100     Structure* structure() const;
101     Structure* structure(VM&) const;
102     void setStructure(VM&, Structure*);
103     void clearStructure() { m_structureID = 0; }
104
105     TypeInfo::InlineTypeFlags inlineTypeFlags() const { return m_flags; }
106
107     const char* className() const;
108
109     VM* vm() const;
110
111     // Extracting the value.
112     JS_EXPORT_PRIVATE bool getString(ExecState*, String&) const;
113     JS_EXPORT_PRIVATE String getString(ExecState*) const; // null string if not a string
114     JS_EXPORT_PRIVATE JSObject* getObject(); // NULL if not an object
115     const JSObject* getObject() const; // NULL if not an object
116         
117     // Returns information about how to call/construct this cell as a function/constructor. May tell
118     // you that the cell is not callable or constructor (default is that it's not either). If it
119     // says that the function is callable, and the TypeOfShouldCallGetCallData type flag is set, and
120     // this is an object, then typeof will return "function" instead of "object". These methods
121     // cannot change their minds and must be thread-safe. They are sometimes called from compiler
122     // threads.
123     JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
124     JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
125
126     // Basic conversions.
127     JS_EXPORT_PRIVATE JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
128     bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
129     bool toBoolean(ExecState*) const;
130     TriState pureToBoolean() const;
131     JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
132     JS_EXPORT_PRIVATE JSObject* toObject(ExecState*, JSGlobalObject*) const;
133
134     void dump(PrintStream&) const;
135     JS_EXPORT_PRIVATE static void dumpToStream(const JSCell*, PrintStream&);
136     static void visitChildren(JSCell*, SlotVisitor&);
137     JS_EXPORT_PRIVATE static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);
138
139     // Object operations, with the toObject operation included.
140     const ClassInfo* classInfo() const;
141     const MethodTable* methodTable() const;
142     const MethodTable* methodTable(VM&) const;
143     static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
144     static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
145         
146     static bool deleteProperty(JSCell*, ExecState*, PropertyName);
147     static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
148
149     static JSValue toThis(JSCell*, ExecState*, ECMAMode);
150
151     void zap() { *reinterpret_cast<uintptr_t**>(this) = 0; }
152     bool isZapped() const { return !*reinterpret_cast<uintptr_t* const*>(this); }
153
154     static bool canUseFastGetOwnProperty(const Structure&);
155     JSValue fastGetOwnProperty(VM&, Structure&, PropertyName);
156
157     enum GCData : uint8_t {
158         Marked = 0, // The object has survived a GC and is in the old gen.
159         NotMarked = 1, // The object is new and in the eden gen.
160         MarkedAndRemembered = 2, // The object is in the GC's remembered set.
161
162         // The object being in the GC's remembered set implies that it is also
163         // Marked. This is because objects are only added to the remembered sets
164         // by write barriers, and write barriers are only interested in old gen
165         // objects that point to potential eden gen objects.
166     };
167
168     void setMarked() { m_gcData = Marked; }
169     void setRemembered(bool remembered)
170     {
171         ASSERT(m_gcData == (remembered ? Marked : MarkedAndRemembered));
172         m_gcData = remembered ? MarkedAndRemembered : Marked; 
173     }
174     bool isMarked() const
175     {
176         switch (m_gcData) {
177         case Marked:
178         case MarkedAndRemembered:
179             return true;
180         case NotMarked:
181             return false;
182         }
183         RELEASE_ASSERT_NOT_REACHED();
184         return false;
185     }
186     bool isRemembered() const { return m_gcData == MarkedAndRemembered; }
187
188     static ptrdiff_t structureIDOffset()
189     {
190         return OBJECT_OFFSETOF(JSCell, m_structureID);
191     }
192
193     static ptrdiff_t typeInfoFlagsOffset()
194     {
195         return OBJECT_OFFSETOF(JSCell, m_flags);
196     }
197
198     static ptrdiff_t typeInfoTypeOffset()
199     {
200         return OBJECT_OFFSETOF(JSCell, m_type);
201     }
202
203     static ptrdiff_t indexingTypeOffset()
204     {
205         return OBJECT_OFFSETOF(JSCell, m_indexingType);
206     }
207
208     static ptrdiff_t gcDataOffset()
209     {
210         return OBJECT_OFFSETOF(JSCell, m_gcData);
211     }
212
213     static const TypedArrayType TypedArrayStorageType = NotTypedArray;
214 protected:
215
216     void finishCreation(VM&);
217     void finishCreation(VM&, Structure*, CreatingEarlyCellTag);
218
219     // Dummy implementations of override-able static functions for classes to put in their MethodTable
220     static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
221     static NO_RETURN_DUE_TO_CRASH void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
222     static NO_RETURN_DUE_TO_CRASH void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
223     static NO_RETURN_DUE_TO_CRASH void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
224
225     static uint32_t getEnumerableLength(ExecState*, JSObject*);
226     static NO_RETURN_DUE_TO_CRASH void getStructurePropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
227     static NO_RETURN_DUE_TO_CRASH void getGenericPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
228
229     static String className(const JSObject*);
230     JS_EXPORT_PRIVATE static bool customHasInstance(JSObject*, ExecState*, JSValue);
231     static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
232     static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
233     static bool getOwnPropertySlotByIndex(JSObject*, ExecState*, unsigned propertyName, PropertySlot&);
234     JS_EXPORT_PRIVATE static ArrayBuffer* slowDownAndWasteMemory(JSArrayBufferView*);
235     JS_EXPORT_PRIVATE static PassRefPtr<ArrayBufferView> getTypedArrayImpl(JSArrayBufferView*);
236
237 private:
238     friend class LLIntOffsetsExtractor;
239
240     StructureID m_structureID;
241     IndexingType m_indexingType;
242     JSType m_type;
243     TypeInfo::InlineTypeFlags m_flags;
244     uint8_t m_gcData;
245 };
246
247 template<typename To, typename From>
248 inline To jsCast(From* from)
249 {
250     ASSERT_WITH_SECURITY_IMPLICATION(!from || from->JSCell::inherits(std::remove_pointer<To>::type::info()));
251     return static_cast<To>(from);
252 }
253     
254 template<typename To>
255 inline To jsCast(JSValue from)
256 {
257     ASSERT_WITH_SECURITY_IMPLICATION(from.isCell() && from.asCell()->JSCell::inherits(std::remove_pointer<To>::type::info()));
258     return static_cast<To>(from.asCell());
259 }
260
261 template<typename To, typename From>
262 inline To jsDynamicCast(From* from)
263 {
264     if (LIKELY(from->inherits(std::remove_pointer<To>::type::info())))
265         return static_cast<To>(from);
266     return nullptr;
267 }
268
269 template<typename To>
270 inline To jsDynamicCast(JSValue from)
271 {
272     if (LIKELY(from.isCell() && from.asCell()->inherits(std::remove_pointer<To>::type::info())))
273         return static_cast<To>(from.asCell());
274     return nullptr;
275 }
276
277 } // namespace JSC
278
279 #endif // JSCell_h