source: webkit/trunk/JavaScriptCore/runtime/JSCell.h@ 52178

Last change on this file since 52178 was 52178, checked in by [email protected], 15 years ago

Inlined JSCell's operator new.

Reviewed by Beth Dakin.

3.7% speedup on bench-allocate-nonretained.js.

(JSC::JSCell::operator new):
  • Property svn:eol-style set to native
File size: 10.6 KB
Line 
1/*
2 * Copyright (C) 1999-2001 Harri Porten ([email protected])
3 * Copyright (C) 2001 Peter Kelly ([email protected])
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 "Collector.h"
27#include "JSImmediate.h"
28#include "JSValue.h"
29#include "MarkStack.h"
30#include "Structure.h"
31#include <wtf/Noncopyable.h>
32
33namespace JSC {
34
35 class JSCell : public NoncopyableCustomAllocated {
36 friend class GetterSetter;
37 friend class Heap;
38 friend class JIT;
39 friend class JSNumberCell;
40 friend class JSObject;
41 friend class JSPropertyNameIterator;
42 friend class JSString;
43 friend class JSValue;
44 friend class JSAPIValueWrapper;
45 friend class JSZombie;
46 friend struct VPtrSet;
47
48 private:
49 explicit JSCell(Structure*);
50 virtual ~JSCell();
51
52 public:
53 static PassRefPtr<Structure> createDummyStructure()
54 {
55 return Structure::create(jsNull(), TypeInfo(UnspecifiedType));
56 }
57
58 // Querying the type.
59#if USE(JSVALUE32)
60 bool isNumber() const;
61#endif
62 bool isString() const;
63 bool isObject() const;
64 virtual bool isGetterSetter() const;
65 bool inherits(const ClassInfo*) const;
66 virtual bool isAPIValueWrapper() const { return false; }
67 virtual bool isPropertyNameIterator() const { return false; }
68
69 Structure* structure() const;
70
71 // Extracting the value.
72 bool getString(ExecState* exec, UString&) const;
73 UString getString(ExecState* exec) const; // null string if not a string
74 JSObject* getObject(); // NULL if not an object
75 const JSObject* getObject() const; // NULL if not an object
76
77 virtual CallType getCallData(CallData&);
78 virtual ConstructType getConstructData(ConstructData&);
79
80 // Extracting integer values.
81 // FIXME: remove these methods, can check isNumberCell in JSValue && then call asNumberCell::*.
82 virtual bool getUInt32(uint32_t&) const;
83
84 // Basic conversions.
85 virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
86 virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
87 virtual bool toBoolean(ExecState*) const;
88 virtual double toNumber(ExecState*) const;
89 virtual UString toString(ExecState*) const;
90 virtual JSObject* toObject(ExecState*) const;
91
92 // Garbage collection.
93 void* operator new(size_t, ExecState*);
94 void* operator new(size_t, JSGlobalData*);
95 void* operator new(size_t, void* placementNewDestination) { return placementNewDestination; }
96
97 virtual void markChildren(MarkStack&);
98#if ENABLE(JSC_ZOMBIES)
99 virtual bool isZombie() const { return false; }
100#endif
101
102 // Object operations, with the toObject operation included.
103 virtual const ClassInfo* classInfo() const;
104 virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
105 virtual void put(ExecState*, unsigned propertyName, JSValue);
106 virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
107 virtual bool deleteProperty(ExecState*, unsigned propertyName);
108
109 virtual JSObject* toThisObject(ExecState*) const;
110 virtual UString toThisString(ExecState*) const;
111 virtual JSString* toThisJSString(ExecState*);
112 virtual JSValue getJSNumber();
113 void* vptr() { return *reinterpret_cast<void**>(this); }
114
115 private:
116 // Base implementation; for non-object classes implements getPropertySlot.
117 bool fastGetOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
118 virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
119 virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
120
121 Structure* m_structure;
122 };
123
124 inline JSCell::JSCell(Structure* structure)
125 : m_structure(structure)
126 {
127 }
128
129 inline JSCell::~JSCell()
130 {
131 }
132
133#if USE(JSVALUE32)
134 inline bool JSCell::isNumber() const
135 {
136 return m_structure->typeInfo().type() == NumberType;
137 }
138#endif
139
140 inline bool JSCell::isObject() const
141 {
142 return m_structure->typeInfo().type() == ObjectType;
143 }
144
145 inline bool JSCell::isString() const
146 {
147 return m_structure->typeInfo().type() == StringType;
148 }
149
150 inline Structure* JSCell::structure() const
151 {
152 return m_structure;
153 }
154
155 inline void JSCell::markChildren(MarkStack&)
156 {
157 }
158
159 inline void* JSCell::operator new(size_t size, JSGlobalData* globalData)
160 {
161 return globalData->heap.allocate(size);
162 }
163
164 inline void* JSCell::operator new(size_t size, ExecState* exec)
165 {
166 return exec->heap()->allocate(size);
167 }
168
169 // --- JSValue inlines ----------------------------
170
171 inline bool JSValue::isString() const
172 {
173 return isCell() && asCell()->isString();
174 }
175
176 inline bool JSValue::isGetterSetter() const
177 {
178 return isCell() && asCell()->isGetterSetter();
179 }
180
181 inline bool JSValue::isObject() const
182 {
183 return isCell() && asCell()->isObject();
184 }
185
186 inline bool JSValue::getString(ExecState* exec, UString& s) const
187 {
188 return isCell() && asCell()->getString(exec, s);
189 }
190
191 inline UString JSValue::getString(ExecState* exec) const
192 {
193 return isCell() ? asCell()->getString(exec) : UString();
194 }
195
196 inline JSObject* JSValue::getObject() const
197 {
198 return isCell() ? asCell()->getObject() : 0;
199 }
200
201 inline CallType JSValue::getCallData(CallData& callData)
202 {
203 return isCell() ? asCell()->getCallData(callData) : CallTypeNone;
204 }
205
206 inline ConstructType JSValue::getConstructData(ConstructData& constructData)
207 {
208 return isCell() ? asCell()->getConstructData(constructData) : ConstructTypeNone;
209 }
210
211 ALWAYS_INLINE bool JSValue::getUInt32(uint32_t& v) const
212 {
213 if (isInt32()) {
214 int32_t i = asInt32();
215 v = static_cast<uint32_t>(i);
216 return i >= 0;
217 }
218 if (isDouble()) {
219 double d = asDouble();
220 v = static_cast<uint32_t>(d);
221 return v == d;
222 }
223 return false;
224 }
225
226#if !USE(JSVALUE32_64)
227 ALWAYS_INLINE JSCell* JSValue::asCell() const
228 {
229 ASSERT(isCell());
230 return m_ptr;
231 }
232#endif // !USE(JSVALUE32_64)
233
234 inline JSValue JSValue::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
235 {
236 return isCell() ? asCell()->toPrimitive(exec, preferredType) : asValue();
237 }
238
239 inline bool JSValue::getPrimitiveNumber(ExecState* exec, double& number, JSValue& value)
240 {
241 if (isInt32()) {
242 number = asInt32();
243 value = *this;
244 return true;
245 }
246 if (isDouble()) {
247 number = asDouble();
248 value = *this;
249 return true;
250 }
251 if (isCell())
252 return asCell()->getPrimitiveNumber(exec, number, value);
253 if (isTrue()) {
254 number = 1.0;
255 value = *this;
256 return true;
257 }
258 if (isFalse() || isNull()) {
259 number = 0.0;
260 value = *this;
261 return true;
262 }
263 ASSERT(isUndefined());
264 number = nonInlineNaN();
265 value = *this;
266 return true;
267 }
268
269 inline bool JSValue::toBoolean(ExecState* exec) const
270 {
271 if (isInt32())
272 return asInt32() != 0;
273 if (isDouble())
274 return asDouble() > 0.0 || asDouble() < 0.0; // false for NaN
275 if (isCell())
276 return asCell()->toBoolean(exec);
277 return isTrue(); // false, null, and undefined all convert to false.
278 }
279
280 ALWAYS_INLINE double JSValue::toNumber(ExecState* exec) const
281 {
282 if (isInt32())
283 return asInt32();
284 if (isDouble())
285 return asDouble();
286 if (isCell())
287 return asCell()->toNumber(exec);
288 if (isTrue())
289 return 1.0;
290 return isUndefined() ? nonInlineNaN() : 0; // null and false both convert to 0.
291 }
292
293 inline bool JSValue::needsThisConversion() const
294 {
295 if (UNLIKELY(!isCell()))
296 return true;
297 return asCell()->structure()->typeInfo().needsThisConversion();
298 }
299
300 inline UString JSValue::toThisString(ExecState* exec) const
301 {
302 return isCell() ? asCell()->toThisString(exec) : toString(exec);
303 }
304
305 inline JSValue JSValue::getJSNumber()
306 {
307 if (isInt32() || isDouble())
308 return *this;
309 if (isCell())
310 return asCell()->getJSNumber();
311 return JSValue();
312 }
313
314 inline JSObject* JSValue::toObject(ExecState* exec) const
315 {
316 return isCell() ? asCell()->toObject(exec) : toObjectSlowCase(exec);
317 }
318
319 inline JSObject* JSValue::toThisObject(ExecState* exec) const
320 {
321 return isCell() ? asCell()->toThisObject(exec) : toThisObjectSlowCase(exec);
322 }
323
324 ALWAYS_INLINE void MarkStack::append(JSCell* cell)
325 {
326 ASSERT(!m_isCheckingForDefaultMarkViolation);
327 ASSERT(cell);
328 if (Heap::isCellMarked(cell))
329 return;
330 Heap::markCell(cell);
331 if (cell->structure()->typeInfo().type() >= CompoundType)
332 m_values.append(cell);
333 }
334
335 ALWAYS_INLINE void MarkStack::append(JSValue value)
336 {
337 ASSERT(value);
338 if (value.isCell())
339 append(value.asCell());
340 }
341
342 inline Heap* Heap::heap(JSValue v)
343 {
344 if (!v.isCell())
345 return 0;
346 return heap(v.asCell());
347 }
348
349 inline Heap* Heap::heap(JSCell* c)
350 {
351 return cellBlock(c)->heap;
352 }
353
354#if ENABLE(JSC_ZOMBIES)
355 inline bool JSValue::isZombie() const
356 {
357 return isCell() && asCell() && asCell()->isZombie();
358 }
359#endif
360} // namespace JSC
361
362#endif // JSCell_h
Note: See TracBrowser for help on using the repository browser.