https://bugs.webkit.org/show_bug.cgi?id=16777
[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 "MarkStack.h"
33 #include "WriteBarrier.h"
34 #include <wtf/Noncopyable.h>
35
36 namespace JSC {
37
38     class JSGlobalObject;
39     class Structure;
40
41 #if COMPILER(MSVC)
42     // If WTF_MAKE_NONCOPYABLE is applied to JSCell we end up with a bunch of
43     // undefined references to the JSCell copy constructor and assignment operator
44     // when linking JavaScriptCore.
45     class MSVCBugWorkaround {
46         WTF_MAKE_NONCOPYABLE(MSVCBugWorkaround);
47
48     protected:
49         MSVCBugWorkaround() { }
50         ~MSVCBugWorkaround() { }
51     };
52
53     class JSCell : MSVCBugWorkaround {
54 #else
55     class JSCell {
56         WTF_MAKE_NONCOPYABLE(JSCell);
57 #endif
58
59         friend class ExecutableBase;
60         friend class GetterSetter;
61         friend class Heap;
62         friend class JSObject;
63         friend class JSPropertyNameIterator;
64         friend class JSString;
65         friend class JSValue;
66         friend class JSAPIValueWrapper;
67         friend class JSZombie;
68         friend class JSGlobalData;
69         friend class NewSpace;
70         friend class MarkedBlock;
71         friend class ScopeChainNode;
72         friend class Structure;
73         friend class StructureChain;
74         friend class RegExp;
75         friend void destructor(JSCell*);
76
77         enum CreatingEarlyCellTag { CreatingEarlyCell };
78
79     protected:
80         enum VPtrStealingHackType { VPtrStealingHack };
81
82     private:
83         explicit JSCell(VPtrStealingHackType) { }
84         JSCell(JSGlobalData&, Structure*);
85         JSCell(JSGlobalData&, Structure*, CreatingEarlyCellTag);
86         virtual ~JSCell();
87         static const ClassInfo s_dummyCellInfo;
88
89     public:
90         static Structure* createDummyStructure(JSGlobalData&);
91
92         // Querying the type.
93         bool isString() const;
94         bool isObject() const;
95         virtual bool isGetterSetter() const;
96         bool inherits(const ClassInfo*) const;
97         virtual bool isAPIValueWrapper() const { return false; }
98         virtual bool isPropertyNameIterator() const { return false; }
99
100         Structure* structure() const;
101
102         // Extracting the value.
103         bool getString(ExecState* exec, UString&) const;
104         UString getString(ExecState* exec) const; // null string if not a string
105         JSObject* getObject(); // NULL if not an object
106         const JSObject* getObject() const; // NULL if not an object
107         
108         virtual CallType getCallData(CallData&);
109         virtual ConstructType getConstructData(ConstructData&);
110
111         // Extracting integer values.
112         // FIXME: remove these methods, can check isNumberCell in JSValue && then call asNumberCell::*.
113         virtual bool getUInt32(uint32_t&) const;
114
115         // Basic conversions.
116         virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
117         virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
118         virtual bool toBoolean(ExecState*) const;
119         virtual double toNumber(ExecState*) const;
120         virtual UString toString(ExecState*) const;
121         virtual JSObject* toObject(ExecState*, JSGlobalObject*) const;
122
123         // Garbage collection.
124         void* operator new(size_t, ExecState*);
125         void* operator new(size_t, JSGlobalData*);
126         void* operator new(size_t, void* placementNewDestination) { return placementNewDestination; }
127
128         virtual void visitChildren(SlotVisitor&);
129 #if ENABLE(JSC_ZOMBIES)
130         virtual bool isZombie() const { return false; }
131 #endif
132
133         // Object operations, with the toObject operation included.
134         const ClassInfo* classInfo() const;
135         virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
136         virtual void put(ExecState*, unsigned propertyName, JSValue);
137         virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
138         virtual bool deleteProperty(ExecState*, unsigned propertyName);
139
140         virtual JSObject* toThisObject(ExecState*) const;
141         virtual JSValue getJSNumber();
142         void* vptr() { return *reinterpret_cast<void**>(this); }
143         void setVPtr(void* vptr) { *reinterpret_cast<void**>(this) = vptr; }
144
145         // FIXME: Rename getOwnPropertySlot to virtualGetOwnPropertySlot, and
146         // fastGetOwnPropertySlot to getOwnPropertySlot. Callers should always
147         // call this function, not its slower virtual counterpart. (For integer
148         // property names, we want a similar interface with appropriate optimizations.)
149         bool fastGetOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
150
151         static ptrdiff_t structureOffset()
152         {
153             return OBJECT_OFFSETOF(JSCell, m_structure);
154         }
155
156 #if ENABLE(GC_VALIDATION)
157         Structure* unvalidatedStructure() { return m_structure.unvalidatedGet(); }
158 #endif
159         
160     protected:
161         static const unsigned AnonymousSlotCount = 0;
162
163     private:
164         // Base implementation; for non-object classes implements getPropertySlot.
165         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
166         virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
167         
168         WriteBarrier<Structure> m_structure;
169     };
170
171     inline JSCell::JSCell(JSGlobalData& globalData, Structure* structure)
172         : m_structure(globalData, this, structure)
173     {
174         ASSERT(m_structure);
175     }
176
177     inline JSCell::JSCell(JSGlobalData& globalData, Structure* structure, CreatingEarlyCellTag)
178     {
179 #if ENABLE(GC_VALIDATION)
180         if (structure)
181 #endif
182             m_structure.setEarlyValue(globalData, this, structure);
183         // Very first set of allocations won't have a real structure.
184         ASSERT(m_structure || !globalData.dummyMarkableCellStructure);
185     }
186
187     inline JSCell::~JSCell()
188     {
189     }
190
191     inline Structure* JSCell::structure() const
192     {
193         return m_structure.get();
194     }
195
196     inline void JSCell::visitChildren(SlotVisitor& visitor)
197     {
198         visitor.append(&m_structure);
199     }
200
201     // --- JSValue inlines ----------------------------
202
203     inline bool JSValue::isString() 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 CallType getCallData(JSValue value, CallData& callData)
239     {
240         CallType result = value.isCell() ? value.asCell()->getCallData(callData) : CallTypeNone;
241         ASSERT(result == CallTypeNone || value.isValidCallee());
242         return result;
243     }
244
245     inline ConstructType getConstructData(JSValue value, ConstructData& constructData)
246     {
247         ConstructType result = value.isCell() ? value.asCell()->getConstructData(constructData) : ConstructTypeNone;
248         ASSERT(result == ConstructTypeNone || value.isValidCallee());
249         return result;
250     }
251
252     ALWAYS_INLINE bool JSValue::getUInt32(uint32_t& v) const
253     {
254         if (isInt32()) {
255             int32_t i = asInt32();
256             v = static_cast<uint32_t>(i);
257             return i >= 0;
258         }
259         if (isDouble()) {
260             double d = asDouble();
261             v = static_cast<uint32_t>(d);
262             return v == d;
263         }
264         return false;
265     }
266
267     inline JSValue JSValue::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
268     {
269         return isCell() ? asCell()->toPrimitive(exec, preferredType) : asValue();
270     }
271
272     inline bool JSValue::getPrimitiveNumber(ExecState* exec, double& number, JSValue& value)
273     {
274         if (isInt32()) {
275             number = asInt32();
276             value = *this;
277             return true;
278         }
279         if (isDouble()) {
280             number = asDouble();
281             value = *this;
282             return true;
283         }
284         if (isCell())
285             return asCell()->getPrimitiveNumber(exec, number, value);
286         if (isTrue()) {
287             number = 1.0;
288             value = *this;
289             return true;
290         }
291         if (isFalse() || isNull()) {
292             number = 0.0;
293             value = *this;
294             return true;
295         }
296         ASSERT(isUndefined());
297         number = std::numeric_limits<double>::quiet_NaN();
298         value = *this;
299         return true;
300     }
301
302     inline bool JSValue::toBoolean(ExecState* exec) const
303     {
304         if (isInt32())
305             return asInt32() != 0;
306         if (isDouble())
307             return asDouble() > 0.0 || asDouble() < 0.0; // false for NaN
308         if (isCell())
309             return asCell()->toBoolean(exec);
310         return isTrue(); // false, null, and undefined all convert to false.
311     }
312
313     ALWAYS_INLINE double JSValue::toNumber(ExecState* exec) const
314     {
315         if (isInt32())
316             return asInt32();
317         if (isDouble())
318             return asDouble();
319         if (isCell())
320             return asCell()->toNumber(exec);
321         if (isTrue())
322             return 1.0;
323         return isUndefined() ? std::numeric_limits<double>::quiet_NaN() : 0; // null and false both convert to 0.
324     }
325
326     inline JSValue JSValue::getJSNumber()
327     {
328         if (isInt32() || isDouble())
329             return *this;
330         if (isCell())
331             return asCell()->getJSNumber();
332         return JSValue();
333     }
334
335     inline JSObject* JSValue::toObject(ExecState* exec) const
336     {
337         return isCell() ? asCell()->toObject(exec, exec->lexicalGlobalObject()) : toObjectSlowCase(exec, exec->lexicalGlobalObject());
338     }
339
340     inline JSObject* JSValue::toObject(ExecState* exec, JSGlobalObject* globalObject) const
341     {
342         return isCell() ? asCell()->toObject(exec, globalObject) : toObjectSlowCase(exec, globalObject);
343     }
344
345     inline JSObject* JSValue::toThisObject(ExecState* exec) const
346     {
347         return isCell() ? asCell()->toThisObject(exec) : toThisObjectSlowCase(exec);
348     }
349
350 #if ENABLE(JSC_ZOMBIES)
351     inline bool JSValue::isZombie() const
352     {
353         return isCell() && asCell()->isZombie();
354     }
355 #endif
356
357     inline void* JSCell::operator new(size_t size, JSGlobalData* globalData)
358     {
359         return globalData->heap.allocate(size);
360     }
361
362     inline void* JSCell::operator new(size_t size, ExecState* exec)
363     {
364         return exec->heap()->allocate(size);
365     }
366     
367     inline void destructor(JSCell* cell)
368     {
369         cell->~JSCell();
370     }
371
372 } // namespace JSC
373
374 #endif // JSCell_h