De-virtualize JSVariableObject::isDynamicScope
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSGlobalObject.h
1 /*
2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  *  Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Library General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Library General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Library General Public License
16  *  along with this library; see the file COPYING.LIB.  If not, write to
17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  *  Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #ifndef JSGlobalObject_h
23 #define JSGlobalObject_h
24
25 #include "JSArray.h"
26 #include "JSGlobalData.h"
27 #include "JSGlobalThis.h"
28 #include "JSVariableObject.h"
29 #include "JSWeakObjectMapRefInternal.h"
30 #include "NumberPrototype.h"
31 #include "StringPrototype.h"
32 #include "StructureChain.h"
33 #include <wtf/HashSet.h>
34 #include <wtf/OwnPtr.h>
35 #include <wtf/RandomNumber.h>
36
37 namespace JSC {
38
39     class ArrayPrototype;
40     class BooleanPrototype;
41     class DatePrototype;
42     class Debugger;
43     class ErrorConstructor;
44     class FunctionPrototype;
45     class GetterSetter;
46     class GlobalCodeBlock;
47     class NativeErrorConstructor;
48     class ProgramCodeBlock;
49     class RegExpConstructor;
50     class RegExpPrototype;
51     class RegisterFile;
52
53     struct ActivationStackNode;
54     struct HashTable;
55
56     typedef Vector<ExecState*, 16> ExecStateStack;
57     
58     class JSGlobalObject : public JSVariableObject {
59     private:
60         typedef HashSet<RefPtr<OpaqueJSWeakObjectMap> > WeakMapSet;
61
62         struct JSGlobalObjectRareData {
63             JSGlobalObjectRareData()
64                 : profileGroup(0)
65             {
66             }
67
68             WeakMapSet weakMaps;
69             unsigned profileGroup;
70         };
71
72     protected:
73
74         RefPtr<JSGlobalData> m_globalData;
75
76         size_t m_registerArraySize;
77         Register m_globalCallFrame[RegisterFile::CallFrameHeaderSize];
78
79         WriteBarrier<ScopeChainNode> m_globalScopeChain;
80         WriteBarrier<JSObject> m_methodCallDummy;
81
82         WriteBarrier<RegExpConstructor> m_regExpConstructor;
83         WriteBarrier<ErrorConstructor> m_errorConstructor;
84         WriteBarrier<NativeErrorConstructor> m_evalErrorConstructor;
85         WriteBarrier<NativeErrorConstructor> m_rangeErrorConstructor;
86         WriteBarrier<NativeErrorConstructor> m_referenceErrorConstructor;
87         WriteBarrier<NativeErrorConstructor> m_syntaxErrorConstructor;
88         WriteBarrier<NativeErrorConstructor> m_typeErrorConstructor;
89         WriteBarrier<NativeErrorConstructor> m_URIErrorConstructor;
90
91         WriteBarrier<JSFunction> m_evalFunction;
92         WriteBarrier<JSFunction> m_callFunction;
93         WriteBarrier<JSFunction> m_applyFunction;
94         WriteBarrier<GetterSetter> m_throwTypeErrorGetterSetter;
95
96         WriteBarrier<ObjectPrototype> m_objectPrototype;
97         WriteBarrier<FunctionPrototype> m_functionPrototype;
98         WriteBarrier<ArrayPrototype> m_arrayPrototype;
99         WriteBarrier<BooleanPrototype> m_booleanPrototype;
100         WriteBarrier<StringPrototype> m_stringPrototype;
101         WriteBarrier<NumberPrototype> m_numberPrototype;
102         WriteBarrier<DatePrototype> m_datePrototype;
103         WriteBarrier<RegExpPrototype> m_regExpPrototype;
104
105         WriteBarrier<Structure> m_argumentsStructure;
106         WriteBarrier<Structure> m_arrayStructure;
107         WriteBarrier<Structure> m_booleanObjectStructure;
108         WriteBarrier<Structure> m_callbackConstructorStructure;
109         WriteBarrier<Structure> m_callbackFunctionStructure;
110         WriteBarrier<Structure> m_callbackObjectStructure;
111         WriteBarrier<Structure> m_dateStructure;
112         WriteBarrier<Structure> m_emptyObjectStructure;
113         WriteBarrier<Structure> m_nullPrototypeObjectStructure;
114         WriteBarrier<Structure> m_errorStructure;
115         WriteBarrier<Structure> m_functionStructure;
116         WriteBarrier<Structure> m_boundFunctionStructure;
117         WriteBarrier<Structure> m_namedFunctionStructure;
118         size_t m_functionNameOffset;
119         WriteBarrier<Structure> m_numberObjectStructure;
120         WriteBarrier<Structure> m_regExpMatchesArrayStructure;
121         WriteBarrier<Structure> m_regExpStructure;
122         WriteBarrier<Structure> m_stringObjectStructure;
123         WriteBarrier<Structure> m_internalFunctionStructure;
124         WriteBarrier<Structure> m_strictModeTypeErrorFunctionStructure;
125
126         Debugger* m_debugger;
127
128         OwnPtr<JSGlobalObjectRareData> m_rareData;
129
130         WeakRandom m_weakRandom;
131
132         SymbolTable m_symbolTable;
133
134         bool m_evalEnabled;
135
136         void createRareDataIfNeeded()
137         {
138             if (m_rareData)
139                 return;
140             m_rareData = adoptPtr(new JSGlobalObjectRareData);
141             Heap::heap(this)->addFinalizer(this, clearRareData);
142         }
143         
144     public:
145         typedef JSVariableObject Base;
146
147         static JSGlobalObject* create(JSGlobalData& globalData, Structure* structure)
148         {
149             JSGlobalObject* globalObject = new (allocateCell<JSGlobalObject>(globalData.heap)) JSGlobalObject(globalData, structure);
150             globalObject->finishCreation(globalData);
151             return globalObject;
152         }
153
154         static JS_EXPORTDATA const ClassInfo s_info;
155
156     protected:
157         explicit JSGlobalObject(JSGlobalData& globalData, Structure* structure)
158             : JSVariableObject(globalData, structure, &m_symbolTable, 0)
159             , m_registerArraySize(0)
160             , m_globalScopeChain()
161             , m_weakRandom(static_cast<unsigned>(randomNumber() * (std::numeric_limits<unsigned>::max() + 1.0)))
162             , m_evalEnabled(true)
163         {
164         }
165
166         void finishCreation(JSGlobalData& globalData)
167         {
168             Base::finishCreation(globalData);
169             structure()->setGlobalObject(globalData, this);
170             init(this);
171         }
172
173         void finishCreation(JSGlobalData& globalData, JSGlobalThis* thisValue)
174         {
175             Base::finishCreation(globalData);
176             structure()->setGlobalObject(globalData, this);
177             init(thisValue);
178         }
179
180     public:
181         virtual ~JSGlobalObject();
182
183         static void visitChildren(JSCell*, SlotVisitor&);
184
185         static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
186         static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
187         bool hasOwnPropertyForWrite(ExecState*, const Identifier&);
188         static void put(JSCell*, ExecState*, const Identifier&, JSValue, PutPropertySlot&);
189
190         static void putWithAttributes(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
191
192         static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunc, unsigned attributes);
193         static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunc, unsigned attributes);
194
195         // We use this in the code generator as we perform symbol table
196         // lookups prior to initializing the properties
197         bool symbolTableHasProperty(const Identifier& propertyName);
198
199         // The following accessors return pristine values, even if a script 
200         // replaces the global object's associated property.
201
202         RegExpConstructor* regExpConstructor() const { return m_regExpConstructor.get(); }
203
204         ErrorConstructor* errorConstructor() const { return m_errorConstructor.get(); }
205         NativeErrorConstructor* evalErrorConstructor() const { return m_evalErrorConstructor.get(); }
206         NativeErrorConstructor* rangeErrorConstructor() const { return m_rangeErrorConstructor.get(); }
207         NativeErrorConstructor* referenceErrorConstructor() const { return m_referenceErrorConstructor.get(); }
208         NativeErrorConstructor* syntaxErrorConstructor() const { return m_syntaxErrorConstructor.get(); }
209         NativeErrorConstructor* typeErrorConstructor() const { return m_typeErrorConstructor.get(); }
210         NativeErrorConstructor* URIErrorConstructor() const { return m_URIErrorConstructor.get(); }
211
212         JSFunction* evalFunction() const { return m_evalFunction.get(); }
213         JSFunction* callFunction() const { return m_callFunction.get(); }
214         JSFunction* applyFunction() const { return m_applyFunction.get(); }
215         GetterSetter* throwTypeErrorGetterSetter(ExecState* exec)
216         {
217             if (!m_throwTypeErrorGetterSetter)
218                 createThrowTypeError(exec);
219             return m_throwTypeErrorGetterSetter.get();
220         }
221
222         ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
223         FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
224         ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
225         BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
226         StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
227         NumberPrototype* numberPrototype() const { return m_numberPrototype.get(); }
228         DatePrototype* datePrototype() const { return m_datePrototype.get(); }
229         RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
230
231         JSObject* methodCallDummy() const { return m_methodCallDummy.get(); }
232
233         Structure* argumentsStructure() const { return m_argumentsStructure.get(); }
234         Structure* arrayStructure() const { return m_arrayStructure.get(); }
235         Structure* booleanObjectStructure() const { return m_booleanObjectStructure.get(); }
236         Structure* callbackConstructorStructure() const { return m_callbackConstructorStructure.get(); }
237         Structure* callbackFunctionStructure() const { return m_callbackFunctionStructure.get(); }
238         Structure* callbackObjectStructure() const { return m_callbackObjectStructure.get(); }
239         Structure* dateStructure() const { return m_dateStructure.get(); }
240         Structure* emptyObjectStructure() const { return m_emptyObjectStructure.get(); }
241         Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(); }
242         Structure* errorStructure() const { return m_errorStructure.get(); }
243         Structure* functionStructure() const { return m_functionStructure.get(); }
244         Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(); }
245         Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(); }
246         size_t functionNameOffset() const { return m_functionNameOffset; }
247         Structure* numberObjectStructure() const { return m_numberObjectStructure.get(); }
248         Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
249         Structure* strictModeTypeErrorFunctionStructure() const { return m_strictModeTypeErrorFunctionStructure.get(); }
250         Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
251         Structure* regExpStructure() const { return m_regExpStructure.get(); }
252         Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
253
254         void setProfileGroup(unsigned value) { createRareDataIfNeeded(); m_rareData->profileGroup = value; }
255         unsigned profileGroup() const
256         { 
257             if (!m_rareData)
258                 return 0;
259             return m_rareData->profileGroup;
260         }
261
262         Debugger* debugger() const { return m_debugger; }
263         void setDebugger(Debugger* debugger) { m_debugger = debugger; }
264
265         virtual bool supportsProfiling() const { return false; }
266         virtual bool supportsRichSourceInfo() const { return true; }
267
268         ScopeChainNode* globalScopeChain() { return m_globalScopeChain.get(); }
269
270         ExecState* globalExec();
271
272         virtual bool shouldInterruptScript() const { return true; }
273
274         virtual bool allowsAccessFrom(const JSGlobalObject*) const { return true; }
275
276         bool isDynamicScope(bool& requiresDynamicChecks) const;
277
278         void setEvalEnabled(bool enabled) { m_evalEnabled = enabled; }
279         bool evalEnabled() { return m_evalEnabled; }
280
281         void resizeRegisters(size_t newSize);
282
283         void resetPrototype(JSGlobalData&, JSValue prototype);
284
285         JSGlobalData& globalData() const { return *m_globalData.get(); }
286
287         static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
288         {
289             return Structure::create(globalData, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), &s_info);
290         }
291
292         void registerWeakMap(OpaqueJSWeakObjectMap* map)
293         {
294             createRareDataIfNeeded();
295             m_rareData->weakMaps.add(map);
296         }
297
298         void unregisterWeakMap(OpaqueJSWeakObjectMap* map)
299         {
300             if (m_rareData)
301                 m_rareData->weakMaps.remove(map);
302         }
303
304         double weakRandomNumber() { return m_weakRandom.get(); }
305     protected:
306
307         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
308
309         struct GlobalPropertyInfo {
310             GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
311                 : identifier(i)
312                 , value(v)
313                 , attributes(a)
314             {
315             }
316
317             const Identifier identifier;
318             JSValue value;
319             unsigned attributes;
320         };
321         void addStaticGlobals(GlobalPropertyInfo*, int count);
322
323     private:
324         // FIXME: Fold reset into init.
325         void init(JSObject* thisValue);
326         void reset(JSValue prototype);
327
328         void createThrowTypeError(ExecState*);
329
330         void setRegisters(WriteBarrier<Unknown>* registers, PassOwnArrayPtr<WriteBarrier<Unknown> > registerArray, size_t count);
331         static void clearRareData(JSCell*);
332     };
333
334     JSGlobalObject* asGlobalObject(JSValue);
335
336     inline JSGlobalObject* asGlobalObject(JSValue value)
337     {
338         ASSERT(asObject(value)->isGlobalObject());
339         return static_cast<JSGlobalObject*>(asObject(value));
340     }
341
342     inline void JSGlobalObject::setRegisters(WriteBarrier<Unknown>* registers, PassOwnArrayPtr<WriteBarrier<Unknown> > registerArray, size_t count)
343     {
344         JSVariableObject::setRegisters(registers, registerArray);
345         m_registerArraySize = count;
346     }
347
348     inline bool JSGlobalObject::hasOwnPropertyForWrite(ExecState* exec, const Identifier& propertyName)
349     {
350         PropertySlot slot;
351         if (JSVariableObject::getOwnPropertySlot(this, exec, propertyName, slot))
352             return true;
353         bool slotIsWriteable;
354         return symbolTableGet(propertyName, slot, slotIsWriteable);
355     }
356
357     inline bool JSGlobalObject::symbolTableHasProperty(const Identifier& propertyName)
358     {
359         SymbolTableEntry entry = symbolTable().inlineGet(propertyName.impl());
360         return !entry.isNull();
361     }
362
363     inline JSValue Structure::prototypeForLookup(ExecState* exec) const
364     {
365         if (isObject())
366             return m_prototype.get();
367
368         ASSERT(typeInfo().type() == StringType);
369         return exec->lexicalGlobalObject()->stringPrototype();
370     }
371
372     inline StructureChain* Structure::prototypeChain(ExecState* exec) const
373     {
374         // We cache our prototype chain so our clients can share it.
375         if (!isValid(exec, m_cachedPrototypeChain.get())) {
376             JSValue prototype = prototypeForLookup(exec);
377             m_cachedPrototypeChain.set(exec->globalData(), this, StructureChain::create(exec->globalData(), prototype.isNull() ? 0 : asObject(prototype)->structure()));
378         }
379         return m_cachedPrototypeChain.get();
380     }
381
382     inline bool Structure::isValid(ExecState* exec, StructureChain* cachedPrototypeChain) const
383     {
384         if (!cachedPrototypeChain)
385             return false;
386
387         JSValue prototype = prototypeForLookup(exec);
388         WriteBarrier<Structure>* cachedStructure = cachedPrototypeChain->head();
389         while(*cachedStructure && !prototype.isNull()) {
390             if (asObject(prototype)->structure() != cachedStructure->get())
391                 return false;
392             ++cachedStructure;
393             prototype = asObject(prototype)->prototype();
394         }
395         return prototype.isNull() && !*cachedStructure;
396     }
397
398     inline JSGlobalObject* ExecState::dynamicGlobalObject()
399     {
400         if (this == lexicalGlobalObject()->globalExec())
401             return lexicalGlobalObject();
402
403         // For any ExecState that's not a globalExec, the 
404         // dynamic global object must be set since code is running
405         ASSERT(globalData().dynamicGlobalObject);
406         return globalData().dynamicGlobalObject;
407     }
408
409     inline JSObject* constructEmptyObject(ExecState* exec, JSGlobalObject* globalObject)
410     {
411         return constructEmptyObject(exec, globalObject->emptyObjectStructure());
412     }
413
414     inline JSObject* constructEmptyObject(ExecState* exec)
415     {
416         return constructEmptyObject(exec, exec->lexicalGlobalObject());
417     }
418
419     inline JSArray* constructEmptyArray(ExecState* exec, JSGlobalObject* globalObject)
420     {
421         return JSArray::create(exec->globalData(), globalObject->arrayStructure());
422     }
423     
424     inline JSArray* constructEmptyArray(ExecState* exec)
425     {
426         return constructEmptyArray(exec, exec->lexicalGlobalObject());
427     }
428
429     inline JSArray* constructEmptyArray(ExecState* exec, JSGlobalObject* globalObject, unsigned initialLength)
430     {
431         return JSArray::create(exec->globalData(), globalObject->arrayStructure(), initialLength, CreateInitialized);
432     }
433
434     inline JSArray* constructEmptyArray(ExecState* exec, unsigned initialLength)
435     {
436         return constructEmptyArray(exec, exec->lexicalGlobalObject(), initialLength);
437     }
438
439     inline JSArray* constructArray(ExecState* exec, JSGlobalObject* globalObject, JSValue singleItemValue)
440     {
441         MarkedArgumentBuffer values;
442         values.append(singleItemValue);
443         return JSArray::create(exec->globalData(), globalObject->arrayStructure(), values);
444     }
445
446     inline JSArray* constructArray(ExecState* exec, JSValue singleItemValue)
447     {
448         return constructArray(exec, exec->lexicalGlobalObject(), singleItemValue);
449     }
450
451     inline JSArray* constructArray(ExecState* exec, JSGlobalObject* globalObject, const ArgList& values)
452     {
453         return JSArray::create(exec->globalData(), globalObject->arrayStructure(), values);
454     }
455
456     inline JSArray* constructArray(ExecState* exec, const ArgList& values)
457     {
458         return constructArray(exec, exec->lexicalGlobalObject(), values);
459     }
460
461     class DynamicGlobalObjectScope {
462         WTF_MAKE_NONCOPYABLE(DynamicGlobalObjectScope);
463     public:
464         DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
465
466         ~DynamicGlobalObjectScope()
467         {
468             m_dynamicGlobalObjectSlot = m_savedDynamicGlobalObject;
469         }
470
471     private:
472         JSGlobalObject*& m_dynamicGlobalObjectSlot;
473         JSGlobalObject* m_savedDynamicGlobalObject;
474     };
475
476     inline bool JSGlobalObject::isDynamicScope(bool&) const
477     {
478         return true;
479     }
480
481 } // namespace JSC
482
483 #endif // JSGlobalObject_h