b85b6c0514a7dcde5db54d866b03872c64aad35e
[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 "CallFrame.h"
28 #include "ConstructData.h"
29 #include "Heap.h"
30 #include "JSLock.h"
31 #include "JSValueInlineMethods.h"
32 #include "SlotVisitor.h"
33 #include "WriteBarrier.h"
34 #include <wtf/Noncopyable.h>
35
36 namespace JSC {
37
38     class JSGlobalObject;
39     class Structure;
40
41     class JSCell {
42         friend class JSValue;
43         friend class MarkedBlock;
44
45     public:
46         enum CreatingEarlyCellTag { CreatingEarlyCell };
47         JSCell(CreatingEarlyCellTag);
48
49         enum VPtrStealingHackType { VPtrStealingHack };
50         explicit JSCell(VPtrStealingHackType) { }
51
52     public:
53         void* operator new(size_t, void* placementNewDestination) { return placementNewDestination; } // Used for initialization after GC allocation.
54
55     protected:
56         JSCell(JSGlobalData&, Structure*);
57         virtual ~JSCell(); // Invoked by GC finalization.
58
59     public:
60         // Querying the type.
61         bool isString() const;
62         bool isObject() const;
63         bool isGetterSetter() const;
64         bool inherits(const ClassInfo*) const;
65         bool isAPIValueWrapper() const;
66
67         Structure* structure() const;
68         void setStructure(JSGlobalData&, Structure*);
69
70         // Extracting the value.
71         bool getString(ExecState* exec, UString&) const;
72         UString getString(ExecState* exec) const; // null string if not a string
73         JSObject* getObject(); // NULL if not an object
74         const JSObject* getObject() const; // NULL if not an object
75         
76         static CallType getCallData(JSCell*, CallData&);
77         virtual ConstructType getConstructDataVirtual(ConstructData&);
78         static ConstructType getConstructData(JSCell*, ConstructData&);
79
80         // Basic conversions.
81         JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
82         bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
83         bool toBoolean(ExecState*) const;
84         double toNumber(ExecState*) const;
85         UString toString(ExecState*) const;
86         JSObject* toObject(ExecState*, JSGlobalObject*) const;
87
88         static void visitChildren(JSCell*, SlotVisitor&);
89
90         // Object operations, with the toObject operation included.
91         const ClassInfo* classInfo() const;
92         const MethodTable* methodTable() const;
93         virtual void putVirtual(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
94         static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
95         virtual void putVirtual(ExecState*, unsigned propertyName, JSValue);
96         static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
97         
98         virtual bool deletePropertyVirtual(ExecState*, const Identifier& propertyName);
99         static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
100         virtual bool deletePropertyVirtual(ExecState*, unsigned propertyName);
101         static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
102
103         virtual JSObject* toThisObject(ExecState*) const;
104
105         void* vptr() const { ASSERT(!isZapped()); return *reinterpret_cast<void* const*>(this); }
106         void setVPtr(void* vptr) { *reinterpret_cast<void**>(this) = vptr; ASSERT(!isZapped()); }
107         void zap() { *reinterpret_cast<uintptr_t**>(this) = 0; }
108         bool isZapped() const { return !*reinterpret_cast<uintptr_t* const*>(this); }
109
110         // FIXME: Rename getOwnPropertySlot to virtualGetOwnPropertySlot, and
111         // fastGetOwnPropertySlot to getOwnPropertySlot. Callers should always
112         // call this function, not its slower virtual counterpart. (For integer
113         // property names, we want a similar interface with appropriate optimizations.)
114         bool fastGetOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
115         JSValue fastGetOwnProperty(ExecState*, const UString&);
116
117         static ptrdiff_t structureOffset()
118         {
119             return OBJECT_OFFSETOF(JSCell, m_structure);
120         }
121         
122         void* structureAddress()
123         {
124             return &m_structure;
125         }
126
127 #if ENABLE(GC_VALIDATION)
128         Structure* unvalidatedStructure() { return m_structure.unvalidatedGet(); }
129 #endif
130         
131     protected:
132
133         void finishCreation(JSGlobalData&);
134         void finishCreation(JSGlobalData&, Structure*, CreatingEarlyCellTag);
135
136     private:
137         // Base implementation; for non-object classes implements getPropertySlot.
138         virtual bool getOwnPropertySlotVirtual(ExecState*, const Identifier& propertyName, PropertySlot&);
139         static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier& propertyName, PropertySlot&);
140         virtual bool getOwnPropertySlotVirtual(ExecState*, unsigned propertyName, PropertySlot&);
141         static bool getOwnPropertySlot(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
142         
143         WriteBarrier<Structure> m_structure;
144     };
145     
146     inline JSCell::JSCell(JSGlobalData& globalData, Structure* structure)
147         : m_structure(globalData, this, structure)
148     {
149     }
150
151     inline JSCell::JSCell(CreatingEarlyCellTag)
152     {
153     }
154
155     inline void JSCell::finishCreation(JSGlobalData& globalData)
156     {
157 #if ENABLE(GC_VALIDATION)
158         ASSERT(globalData.isInitializingObject());
159         globalData.setInitializingObject(false);
160 #else
161         UNUSED_PARAM(globalData);
162 #endif
163         ASSERT(m_structure);
164     }
165
166     inline void JSCell::finishCreation(JSGlobalData& globalData, Structure* structure, CreatingEarlyCellTag)
167     {
168 #if ENABLE(GC_VALIDATION)
169         ASSERT(globalData.isInitializingObject());
170         globalData.setInitializingObject(false);
171         if (structure)
172 #endif
173             m_structure.setEarlyValue(globalData, this, structure);
174         // Very first set of allocations won't have a real structure.
175         ASSERT(m_structure || !globalData.structureStructure);
176     }
177
178     inline JSCell::~JSCell()
179     {
180 #if ENABLE(GC_VALIDATION)
181         m_structure.clear();
182 #endif
183     }
184
185     inline Structure* JSCell::structure() const
186     {
187         return m_structure.get();
188     }
189
190     inline void JSCell::visitChildren(JSCell* cell, SlotVisitor& visitor)
191     {
192         JSCell* thisObject = static_cast<JSCell*>(cell);
193         visitor.append(&thisObject->m_structure);
194     }
195
196     // --- JSValue inlines ----------------------------
197
198     inline bool JSValue::isString() const
199     {
200         return isCell() && asCell()->isString();
201     }
202
203     inline bool JSValue::isPrimitive() const
204     {
205         return !isCell() || asCell()->isString();
206     }
207
208     inline bool JSValue::isGetterSetter() const
209     {
210         return isCell() && asCell()->isGetterSetter();
211     }
212
213     inline bool JSValue::isObject() const
214     {
215         return isCell() && asCell()->isObject();
216     }
217
218     inline bool JSValue::getString(ExecState* exec, UString& s) const
219     {
220         return isCell() && asCell()->getString(exec, s);
221     }
222
223     inline UString JSValue::getString(ExecState* exec) const
224     {
225         return isCell() ? asCell()->getString(exec) : UString();
226     }
227
228     template <typename Base> UString HandleConverter<Base, Unknown>::getString(ExecState* exec) const
229     {
230         return jsValue().getString(exec);
231     }
232
233     inline JSObject* JSValue::getObject() const
234     {
235         return isCell() ? asCell()->getObject() : 0;
236     }
237
238     inline ConstructType getConstructData(JSValue value, ConstructData& constructData)
239     {
240         ConstructType result = value.isCell() ? value.asCell()->getConstructDataVirtual(constructData) : ConstructTypeNone;
241         ASSERT(result == ConstructTypeNone || value.isValidCallee());
242         return result;
243     }
244
245     ALWAYS_INLINE bool JSValue::getUInt32(uint32_t& v) const
246     {
247         if (isInt32()) {
248             int32_t i = asInt32();
249             v = static_cast<uint32_t>(i);
250             return i >= 0;
251         }
252         if (isDouble()) {
253             double d = asDouble();
254             v = static_cast<uint32_t>(d);
255             return v == d;
256         }
257         return false;
258     }
259
260     inline JSValue JSValue::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
261     {
262         return isCell() ? asCell()->toPrimitive(exec, preferredType) : asValue();
263     }
264
265     inline bool JSValue::getPrimitiveNumber(ExecState* exec, double& number, JSValue& value)
266     {
267         if (isInt32()) {
268             number = asInt32();
269             value = *this;
270             return true;
271         }
272         if (isDouble()) {
273             number = asDouble();
274             value = *this;
275             return true;
276         }
277         if (isCell())
278             return asCell()->getPrimitiveNumber(exec, number, value);
279         if (isTrue()) {
280             number = 1.0;
281             value = *this;
282             return true;
283         }
284         if (isFalse() || isNull()) {
285             number = 0.0;
286             value = *this;
287             return true;
288         }
289         ASSERT(isUndefined());
290         number = std::numeric_limits<double>::quiet_NaN();
291         value = *this;
292         return true;
293     }
294
295     ALWAYS_INLINE double JSValue::toNumber(ExecState* exec) const
296     {
297         if (isInt32())
298             return asInt32();
299         if (isDouble())
300             return asDouble();
301         return toNumberSlowCase(exec);
302     }
303
304     inline JSObject* JSValue::toObject(ExecState* exec) const
305     {
306         return isCell() ? asCell()->toObject(exec, exec->lexicalGlobalObject()) : toObjectSlowCase(exec, exec->lexicalGlobalObject());
307     }
308
309     inline JSObject* JSValue::toObject(ExecState* exec, JSGlobalObject* globalObject) const
310     {
311         return isCell() ? asCell()->toObject(exec, globalObject) : toObjectSlowCase(exec, globalObject);
312     }
313
314     inline JSObject* JSValue::toThisObject(ExecState* exec) const
315     {
316         return isCell() ? asCell()->toThisObject(exec) : toThisObjectSlowCase(exec);
317     }
318
319     template <typename T> void* allocateCell(Heap& heap)
320     {
321 #if ENABLE(GC_VALIDATION)
322         ASSERT(sizeof(T) == T::s_info.cellSize);
323         ASSERT(!heap.globalData()->isInitializingObject());
324         heap.globalData()->setInitializingObject(true);
325 #endif
326         return heap.allocate(sizeof(T));
327     }
328     
329     inline bool isZapped(const JSCell* cell)
330     {
331         return cell->isZapped();
332     }
333
334 } // namespace JSC
335
336 #endif // JSCell_h