Bug 20821: Cache property transitions to speed up object initialization
[WebKit-https.git] / JavaScriptCore / kjs / JSObject.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, 2006, 2007, 2008 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 JSObject_h
24 #define JSObject_h
25
26 #include "ArgList.h"
27 #include "ClassInfo.h"
28 #include "CommonIdentifiers.h"
29 #include "ExecState.h"
30 #include "JSNumberCell.h"
31 #include "PropertyMap.h"
32 #include "PropertySlot.h"
33 #include "PutPropertySlot.h"
34 #include "ScopeChain.h"
35 #include "StructureID.h"
36
37 namespace JSC {
38
39     class InternalFunction;
40     class PropertyNameArray;
41     class StructureID;
42     struct HashEntry;
43     struct HashTable;
44
45     // ECMA 262-3 8.6.1
46     // Property attributes
47     enum Attribute {
48         None         = 0,
49         ReadOnly     = 1 << 1,  // property can be only read, not written
50         DontEnum     = 1 << 2,  // property doesn't appear in (for .. in ..)
51         DontDelete   = 1 << 3,  // property can't be deleted
52         Function     = 1 << 4,  // property is a function - only used by static hashtables
53     };
54
55     class JSObject : public JSCell {
56         friend class BatchedTransitionOptimizer;
57         friend class CTI;
58
59     public:
60         JSObject(PassRefPtr<StructureID>);
61         JSObject(JSObject* prototype);
62
63         virtual void mark();
64
65         // The inline virtual destructor cannot be the first virtual function declared
66         // in the class as it results in the vtable being generated as a weak symbol
67         virtual ~JSObject();
68
69         bool inherits(const ClassInfo* classInfo) const { return JSCell::isObject(classInfo); }
70
71         JSValue* prototype() const;
72         void setPrototype(JSValue* prototype);
73         
74         void setStructureID(PassRefPtr<StructureID>);
75         StructureID* inheritorID();
76
77         PropertyStorage& propertyStorage() { return m_propertyStorage; }
78
79         virtual UString className() const;
80
81         JSValue* get(ExecState*, const Identifier& propertyName) const;
82         JSValue* get(ExecState*, unsigned propertyName) const;
83
84         bool getPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
85         bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
86
87         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
88         virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
89
90         virtual void put(ExecState*, const Identifier& propertyName, JSValue* value, PutPropertySlot&);
91         virtual void put(ExecState*, unsigned propertyName, JSValue* value);
92
93         virtual void putWithAttributes(ExecState*, const Identifier& propertyName, JSValue* value, unsigned attributes);
94         virtual void putWithAttributes(ExecState*, unsigned propertyName, JSValue* value, unsigned attributes);
95
96         bool propertyIsEnumerable(ExecState*, const Identifier& propertyName) const;
97
98         bool hasProperty(ExecState*, const Identifier& propertyName) const;
99         bool hasProperty(ExecState*, unsigned propertyName) const;
100         bool hasOwnProperty(ExecState*, const Identifier& propertyName) const;
101
102         virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
103         virtual bool deleteProperty(ExecState*, unsigned propertyName);
104
105         virtual JSValue* defaultValue(ExecState*, PreferredPrimitiveType) const;
106
107         virtual bool implementsHasInstance() const;
108         virtual bool hasInstance(ExecState*, JSValue*);
109
110         virtual void getPropertyNames(ExecState*, PropertyNameArray&);
111
112         virtual JSValue* toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
113         virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue*& value);
114         virtual bool toBoolean(ExecState*) const;
115         virtual double toNumber(ExecState*) const;
116         virtual UString toString(ExecState*) const;
117         virtual JSObject* toObject(ExecState*) const;
118
119         virtual JSObject* toThisObject(ExecState*) const;
120         virtual JSGlobalObject* toGlobalObject(ExecState*) const;
121
122         virtual bool getPropertyAttributes(ExecState*, const Identifier& propertyName, unsigned& attributes) const;
123
124         // This get function only looks at the property map.
125         JSValue* getDirect(const Identifier& propertyName) const
126         {
127             size_t offset = m_structureID->propertyMap().getOffset(propertyName);
128             return offset != WTF::notFound ? m_propertyStorage[offset] : 0;
129         }
130
131         JSValue** getDirectLocation(const Identifier& propertyName)
132         {
133             size_t offset = m_structureID->propertyMap().getOffset(propertyName);
134             return offset != WTF::notFound ? locationForOffset(offset) : 0;
135         }
136
137         JSValue** getDirectLocation(const Identifier& propertyName, unsigned& attributes)
138         {
139             size_t offset = m_structureID->propertyMap().getOffset(propertyName, attributes);
140             return offset != WTF::notFound ? locationForOffset(offset) : 0;
141         }
142
143         size_t offsetForLocation(JSValue** location)
144         {
145             return location - m_propertyStorage;
146         }
147
148         JSValue** locationForOffset(size_t offset)
149         {
150             return &m_propertyStorage[offset];
151         }
152
153         void transitionTo(StructureID*);
154
155         void removeDirect(const Identifier& propertyName);
156         bool hasCustomProperties() { return !m_structureID->propertyMap().isEmpty(); }
157         bool hasGetterSetterProperties() { return m_structureID->propertyMap().hasGetterSetterProperties(); }
158
159         void putDirect(const Identifier& propertyName, JSValue* value, unsigned attr = 0);
160         void putDirect(const Identifier& propertyName, JSValue* value, unsigned attr, bool checkReadOnly, PutPropertySlot& slot);
161         void putDirectFunction(ExecState* exec, InternalFunction* function, unsigned attr = 0);
162
163         // Fast access to known property offsets.
164         JSValue* getDirectOffset(size_t offset) { return m_propertyStorage[offset]; }
165         void putDirectOffset(size_t offset, JSValue* value) { m_propertyStorage[offset] = value; }
166
167         void fillGetterPropertySlot(PropertySlot&, JSValue** location);
168
169         virtual void defineGetter(ExecState*, const Identifier& propertyName, JSObject* getterFunction);
170         virtual void defineSetter(ExecState*, const Identifier& propertyName, JSObject* setterFunction);
171         virtual JSValue* lookupGetter(ExecState*, const Identifier& propertyName);
172         virtual JSValue* lookupSetter(ExecState*, const Identifier& propertyName);
173
174         virtual bool isActivationObject() const { return false; }
175         virtual bool isGlobalObject() const { return false; }
176         virtual bool isVariableObject() const { return false; }
177         virtual bool isWatchdogException() const { return false; }
178         virtual bool isNotAnObjectErrorStub() const { return false; }
179
180         void allocatePropertyStorage(size_t oldSize, size_t newSize);
181         bool usingInlineStorage() const { return m_propertyStorage == m_inlineStorage; }
182
183         static const size_t inlineStorageCapacity = 2;
184
185     protected:
186         bool getOwnPropertySlotForWrite(ExecState*, const Identifier&, PropertySlot&, bool& slotIsWriteable);
187
188     private:
189         const HashEntry* findPropertyHashEntry(ExecState*, const Identifier& propertyName) const;
190         StructureID* createInheritorID();
191
192         RefPtr<StructureID> m_inheritorID;
193
194         PropertyStorage m_propertyStorage;        
195         JSValue* m_inlineStorage[inlineStorageCapacity];
196     };
197
198   JSObject* constructEmptyObject(ExecState*);
199
200 inline JSObject::JSObject(JSObject* prototype)
201     : JSCell(prototype->inheritorID())
202     , m_propertyStorage(m_inlineStorage)
203 {
204     ASSERT(m_structureID);
205     ASSERT(this->prototype());
206     ASSERT(this->prototype()->isNull() || Heap::heap(this) == Heap::heap(this->prototype()));
207     m_structureID->ref(); // ~JSObject balances this ref()
208 }
209
210 inline JSObject::JSObject(PassRefPtr<StructureID> structureID)
211     : JSCell(structureID.releaseRef()) // ~JSObject balances this ref()
212     , m_propertyStorage(m_inlineStorage)
213 {
214     ASSERT(m_structureID);
215 }
216
217 inline JSObject::~JSObject()
218 {
219     ASSERT(m_structureID);
220     if (m_propertyStorage != m_inlineStorage)
221         delete [] m_propertyStorage;
222     m_structureID->deref();
223 }
224
225 inline JSValue* JSObject::prototype() const
226 {
227     return m_structureID->storedPrototype();
228 }
229
230 inline void JSObject::setPrototype(JSValue* prototype)
231 {
232     ASSERT(prototype);
233     RefPtr<StructureID> newStructureID = StructureID::changePrototypeTransition(m_structureID, prototype);
234     setStructureID(newStructureID.release());
235 }
236
237 inline void JSObject::setStructureID(PassRefPtr<StructureID> structureID)
238 {
239     m_structureID->deref();
240     m_structureID = structureID.releaseRef(); // ~JSObject balances this ref()
241 }
242
243 inline StructureID* JSObject::inheritorID()
244 {
245     if (m_inheritorID)
246         return m_inheritorID.get();
247     return createInheritorID();
248 }
249
250 inline bool JSCell::isObject(const ClassInfo* info) const
251 {
252     for (const ClassInfo* ci = classInfo(); ci; ci = ci->parentClass) {
253         if (ci == info)
254             return true;
255     }
256     return false;
257 }
258
259 // this method is here to be after the inline declaration of JSCell::isObject
260 inline bool JSValue::isObject(const ClassInfo* classInfo) const
261 {
262     return !JSImmediate::isImmediate(this) && asCell()->isObject(classInfo);
263 }
264
265 inline JSValue* JSObject::get(ExecState* exec, const Identifier& propertyName) const
266 {
267     PropertySlot slot(const_cast<JSObject*>(this));
268     if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))
269         return slot.getValue(exec, propertyName);
270     
271     return jsUndefined();
272 }
273
274 inline JSValue* JSObject::get(ExecState* exec, unsigned propertyName) const
275 {
276     PropertySlot slot(const_cast<JSObject*>(this));
277     if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))
278         return slot.getValue(exec, propertyName);
279
280     return jsUndefined();
281 }
282
283 // It may seem crazy to inline a function this large but it makes a big difference
284 // since this is function very hot in variable lookup
285 inline bool JSObject::getPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
286 {
287     JSObject* object = this;
288     while (true) {
289         if (object->getOwnPropertySlot(exec, propertyName, slot))
290             return true;
291
292         JSValue* prototype = object->prototype();
293         if (!prototype->isObject())
294             return false;
295
296         object = static_cast<JSObject*>(prototype);
297     }
298 }
299
300 inline bool JSObject::getPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot)
301 {
302     JSObject* object = this;
303
304     while (true) {
305         if (object->getOwnPropertySlot(exec, propertyName, slot))
306             return true;
307
308         JSValue* prototype = object->prototype();
309         if (!prototype->isObject())
310             break;
311
312         object = static_cast<JSObject*>(prototype);
313     }
314
315     return false;
316 }
317
318 // It may seem crazy to inline a function this large, especially a virtual function,
319 // but it makes a big difference to property lookup that derived classes can inline their
320 // base class call to this.
321 ALWAYS_INLINE bool JSObject::getOwnPropertySlotForWrite(ExecState* exec, const Identifier& propertyName, PropertySlot& slot, bool& slotIsWriteable)
322 {
323     unsigned attributes;
324     if (JSValue** location = getDirectLocation(propertyName, attributes)) {
325         if (m_structureID->propertyMap().hasGetterSetterProperties() && location[0]->isGetterSetter()) {
326             slotIsWriteable = false;
327             fillGetterPropertySlot(slot, location);
328         } else {
329             slotIsWriteable = !(attributes & ReadOnly);
330             slot.setValueSlot(this, location, offsetForLocation(location));
331         }
332         return true;
333     }
334
335     // non-standard Netscape extension
336     if (propertyName == exec->propertyNames().underscoreProto) {
337         slot.setValue(prototype());
338         slotIsWriteable = false;
339         return true;
340     }
341
342     return false;
343 }
344
345 // It may seem crazy to inline a function this large, especially a virtual function,
346 // but it makes a big difference to property lookup that derived classes can inline their
347 // base class call to this.
348 ALWAYS_INLINE bool JSObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
349 {
350     if (JSValue** location = getDirectLocation(propertyName)) {
351         if (m_structureID->propertyMap().hasGetterSetterProperties() && location[0]->isGetterSetter())
352             fillGetterPropertySlot(slot, location);
353         else
354             slot.setValueSlot(this, location, offsetForLocation(location));
355         return true;
356     }
357
358     // non-standard Netscape extension
359     if (propertyName == exec->propertyNames().underscoreProto) {
360         slot.setValue(prototype());
361         return true;
362     }
363
364     return false;
365 }
366
367 inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value, unsigned attr)
368 {
369     PutPropertySlot slot;
370     putDirect(propertyName, value, attr, false, slot);
371 }
372
373 inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value, unsigned attributes, bool checkReadOnly, PutPropertySlot& slot)
374 {
375     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
376
377      if (m_structureID->isDictionary()) {
378          unsigned currentAttributes;
379          size_t offset = m_structureID->propertyMap().getOffset(propertyName, currentAttributes);
380          if (offset != WTF::notFound) {
381              if (checkReadOnly && currentAttributes & ReadOnly)
382                  return;
383              m_propertyStorage[offset] = value;
384              slot.setExistingProperty(this, offset);
385              return;
386          }
387
388          if (m_structureID->propertyMap().storageSize() == inlineStorageCapacity)
389              allocatePropertyStorage(m_structureID->propertyMap().storageSize(), m_structureID->propertyMap().size());
390          m_structureID->propertyMap().put(propertyName, value, attributes, checkReadOnly, this, slot, m_propertyStorage);
391          return;
392      }
393
394     unsigned currentAttributes;
395     size_t offset = m_structureID->propertyMap().getOffset(propertyName, currentAttributes);
396     if (offset != WTF::notFound) {
397         if (checkReadOnly && currentAttributes & ReadOnly)
398             return;
399         m_propertyStorage[offset] = value;
400         slot.setExistingProperty(this, offset);
401         return;
402     }
403
404      if (m_structureID->propertyMap().storageSize() == inlineStorageCapacity)
405          allocatePropertyStorage(m_structureID->propertyMap().storageSize(), m_structureID->propertyMap().size());
406
407      RefPtr<StructureID> structureID = StructureID::addPropertyTransition(m_structureID, propertyName, value, attributes, this, slot, m_propertyStorage);
408      slot.setWasTransition(true);
409      setStructureID(structureID.release());
410 }
411
412 inline void JSObject::transitionTo(StructureID* newStructureID)
413 {
414     StructureID::transitionTo(m_structureID, newStructureID, this);
415     setStructureID(newStructureID);
416 }
417
418 inline JSValue* JSObject::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
419 {
420     return defaultValue(exec, preferredType);
421 }
422
423 inline JSValue* JSValue::get(ExecState* exec, const Identifier& propertyName) const
424 {
425     PropertySlot slot(const_cast<JSValue*>(this));
426     return get(exec, propertyName, slot);
427 }
428
429 inline JSValue* JSValue::get(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) const
430 {
431     if (UNLIKELY(JSImmediate::isImmediate(this))) {
432         JSObject* prototype = JSImmediate::prototype(this, exec);
433         if (!prototype->getPropertySlot(exec, propertyName, slot))
434             return jsUndefined();
435         return slot.getValue(exec, propertyName);
436     }
437     JSCell* cell = static_cast<JSCell*>(const_cast<JSValue*>(this));
438     while (true) {
439         if (cell->getOwnPropertySlot(exec, propertyName, slot))
440             return slot.getValue(exec, propertyName);
441         ASSERT(cell->isObject());
442         JSValue* prototype = static_cast<JSObject*>(cell)->prototype();
443         if (!prototype->isObject())
444             return jsUndefined();
445         cell = static_cast<JSCell*>(prototype);
446     }
447 }
448
449 inline JSValue* JSValue::get(ExecState* exec, unsigned propertyName) const
450 {
451     PropertySlot slot(const_cast<JSValue*>(this));
452     return get(exec, propertyName, slot);
453 }
454
455 inline JSValue* JSValue::get(ExecState* exec, unsigned propertyName, PropertySlot& slot) const
456 {
457     if (UNLIKELY(JSImmediate::isImmediate(this))) {
458         JSObject* prototype = JSImmediate::prototype(this, exec);
459         if (!prototype->getPropertySlot(exec, propertyName, slot))
460             return jsUndefined();
461         return slot.getValue(exec, propertyName);
462     }
463     JSCell* cell = const_cast<JSCell*>(asCell());
464     while (true) {
465         if (cell->getOwnPropertySlot(exec, propertyName, slot))
466             return slot.getValue(exec, propertyName);
467         ASSERT(cell->isObject());
468         JSValue* prototype = static_cast<JSObject*>(cell)->prototype();
469         if (!prototype->isObject())
470             return jsUndefined();
471         cell = static_cast<JSCell*>(prototype);
472     }
473 }
474
475 inline void JSValue::put(ExecState* exec, const Identifier& propertyName, JSValue* value, PutPropertySlot& slot)
476 {
477     if (UNLIKELY(JSImmediate::isImmediate(this))) {
478         JSImmediate::toObject(this, exec)->put(exec, propertyName, value, slot);
479         return;
480     }
481     asCell()->put(exec, propertyName, value, slot);
482 }
483
484 inline void JSValue::put(ExecState* exec, unsigned propertyName, JSValue* value)
485 {
486     if (UNLIKELY(JSImmediate::isImmediate(this))) {
487         JSImmediate::toObject(this, exec)->put(exec, propertyName, value);
488         return;
489     }
490     asCell()->put(exec, propertyName, value);
491 }
492
493 } // namespace JSC
494
495 #endif // JSObject_h