Foo::s_info should be Foo::info(), so that you can change how the s_info is actually...
[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 "ArrayAllocationProfile.h"
26 #include "JSArray.h"
27 #include "JSClassRef.h"
28 #include "VM.h"
29 #include "JSSegmentedVariableObject.h"
30 #include "JSWeakObjectMapRefInternal.h"
31 #include "NumberPrototype.h"
32 #include "SpecialPointer.h"
33 #include "StringPrototype.h"
34 #include "StructureChain.h"
35 #include "StructureRareDataInlines.h"
36 #include "Watchpoint.h"
37 #include <JavaScriptCore/JSBase.h>
38 #include <wtf/HashSet.h>
39 #include <wtf/OwnPtr.h>
40 #include <wtf/RandomNumber.h>
41
42 struct OpaqueJSClass;
43 struct OpaqueJSClassContextData;
44
45 namespace JSC {
46
47 class ArrayPrototype;
48 class BooleanPrototype;
49 class DatePrototype;
50 class Debugger;
51 class ErrorConstructor;
52 class ErrorPrototype;
53 class EvalCodeBlock;
54 class EvalExecutable;
55 class FunctionCodeBlock;
56 class FunctionExecutable;
57 class FunctionPrototype;
58 class GetterSetter;
59 class GlobalCodeBlock;
60 class JSStack;
61 class LLIntOffsetsExtractor;
62 class NativeErrorConstructor;
63 class ProgramCodeBlock;
64 class ProgramExecutable;
65 class RegExpConstructor;
66 class RegExpPrototype;
67 class SourceCode;
68 struct ActivationStackNode;
69 struct HashTable;
70
71 typedef Vector<ExecState*, 16> ExecStateStack;
72     
73 struct GlobalObjectMethodTable {
74     typedef bool (*AllowsAccessFromFunctionPtr)(const JSGlobalObject*, ExecState*);
75     AllowsAccessFromFunctionPtr allowsAccessFrom;
76
77     typedef bool (*SupportsProfilingFunctionPtr)(const JSGlobalObject*); 
78     SupportsProfilingFunctionPtr supportsProfiling;
79
80     typedef bool (*SupportsRichSourceInfoFunctionPtr)(const JSGlobalObject*);
81     SupportsRichSourceInfoFunctionPtr supportsRichSourceInfo;
82
83     typedef bool (*ShouldInterruptScriptFunctionPtr)(const JSGlobalObject*);
84     ShouldInterruptScriptFunctionPtr shouldInterruptScript;
85
86     typedef bool (*JavaScriptExperimentsEnabledFunctionPtr)(const JSGlobalObject*);
87     JavaScriptExperimentsEnabledFunctionPtr javaScriptExperimentsEnabled;
88 };
89
90 class JSGlobalObject : public JSSegmentedVariableObject {
91 private:
92     typedef HashSet<RefPtr<OpaqueJSWeakObjectMap> > WeakMapSet;
93     typedef HashMap<OpaqueJSClass*, OwnPtr<OpaqueJSClassContextData> > OpaqueJSClassDataMap;
94
95     struct JSGlobalObjectRareData {
96         JSGlobalObjectRareData()
97             : profileGroup(0)
98         {
99         }
100
101         WeakMapSet weakMaps;
102         unsigned profileGroup;
103         
104         OpaqueJSClassDataMap opaqueJSClassData;
105     };
106
107 protected:
108
109     Register m_globalCallFrame[JSStack::CallFrameHeaderSize];
110
111     WriteBarrier<JSObject> m_globalThis;
112
113     WriteBarrier<RegExpConstructor> m_regExpConstructor;
114     WriteBarrier<ErrorConstructor> m_errorConstructor;
115     WriteBarrier<NativeErrorConstructor> m_evalErrorConstructor;
116     WriteBarrier<NativeErrorConstructor> m_rangeErrorConstructor;
117     WriteBarrier<NativeErrorConstructor> m_referenceErrorConstructor;
118     WriteBarrier<NativeErrorConstructor> m_syntaxErrorConstructor;
119     WriteBarrier<NativeErrorConstructor> m_typeErrorConstructor;
120     WriteBarrier<NativeErrorConstructor> m_URIErrorConstructor;
121
122     WriteBarrier<JSFunction> m_evalFunction;
123     WriteBarrier<JSFunction> m_callFunction;
124     WriteBarrier<JSFunction> m_applyFunction;
125     WriteBarrier<GetterSetter> m_throwTypeErrorGetterSetter;
126
127     WriteBarrier<ObjectPrototype> m_objectPrototype;
128     WriteBarrier<FunctionPrototype> m_functionPrototype;
129     WriteBarrier<ArrayPrototype> m_arrayPrototype;
130     WriteBarrier<BooleanPrototype> m_booleanPrototype;
131     WriteBarrier<StringPrototype> m_stringPrototype;
132     WriteBarrier<NumberPrototype> m_numberPrototype;
133     WriteBarrier<DatePrototype> m_datePrototype;
134     WriteBarrier<RegExpPrototype> m_regExpPrototype;
135     WriteBarrier<ErrorPrototype> m_errorPrototype;
136
137     WriteBarrier<Structure> m_withScopeStructure;
138     WriteBarrier<Structure> m_strictEvalActivationStructure;
139     WriteBarrier<Structure> m_activationStructure;
140     WriteBarrier<Structure> m_nameScopeStructure;
141     WriteBarrier<Structure> m_argumentsStructure;
142         
143     // Lists the actual structures used for having these particular indexing shapes.
144     WriteBarrier<Structure> m_originalArrayStructureForIndexingShape[NumberOfIndexingShapes];
145     // Lists the structures we should use during allocation for these particular indexing shapes.
146     WriteBarrier<Structure> m_arrayStructureForIndexingShapeDuringAllocation[NumberOfIndexingShapes];
147         
148     WriteBarrier<Structure> m_booleanObjectStructure;
149     WriteBarrier<Structure> m_callbackConstructorStructure;
150     WriteBarrier<Structure> m_callbackFunctionStructure;
151     WriteBarrier<Structure> m_callbackObjectStructure;
152 #if JSC_OBJC_API_ENABLED
153     WriteBarrier<Structure> m_objcCallbackFunctionStructure;
154     WriteBarrier<Structure> m_objcWrapperObjectStructure;
155 #endif
156     WriteBarrier<Structure> m_dateStructure;
157     WriteBarrier<Structure> m_nullPrototypeObjectStructure;
158     WriteBarrier<Structure> m_errorStructure;
159     WriteBarrier<Structure> m_functionStructure;
160     WriteBarrier<Structure> m_boundFunctionStructure;
161     WriteBarrier<Structure> m_namedFunctionStructure;
162     PropertyOffset m_functionNameOffset;
163     WriteBarrier<Structure> m_numberObjectStructure;
164     WriteBarrier<Structure> m_privateNameStructure;
165     WriteBarrier<Structure> m_regExpMatchesArrayStructure;
166     WriteBarrier<Structure> m_regExpStructure;
167     WriteBarrier<Structure> m_stringObjectStructure;
168     WriteBarrier<Structure> m_internalFunctionStructure;
169         
170     void* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
171
172     Debugger* m_debugger;
173
174     RefPtr<WatchpointSet> m_masqueradesAsUndefinedWatchpoint;
175     RefPtr<WatchpointSet> m_havingABadTimeWatchpoint;
176     RefPtr<WatchpointSet> m_varInjectionWatchpoint;
177
178     OwnPtr<JSGlobalObjectRareData> m_rareData;
179
180     WeakRandom m_weakRandom;
181
182     bool m_evalEnabled;
183     String m_evalDisabledErrorMessage;
184     bool m_experimentsEnabled;
185
186     static JS_EXPORTDATA const GlobalObjectMethodTable s_globalObjectMethodTable;
187     const GlobalObjectMethodTable* m_globalObjectMethodTable;
188
189     void createRareDataIfNeeded()
190     {
191         if (m_rareData)
192             return;
193         m_rareData = adoptPtr(new JSGlobalObjectRareData);
194     }
195         
196 public:
197     typedef JSSegmentedVariableObject Base;
198
199     static JSGlobalObject* create(VM& vm, Structure* structure)
200     {
201         JSGlobalObject* globalObject = new (NotNull, allocateCell<JSGlobalObject>(vm.heap)) JSGlobalObject(vm, structure);
202         globalObject->finishCreation(vm);
203         vm.heap.addFinalizer(globalObject, destroy);
204         return globalObject;
205     }
206
207     DECLARE_EXPORT_INFO;
208
209     bool hasDebugger() const { return m_debugger; }
210     bool hasProfiler() const { return globalObjectMethodTable()->supportsProfiling(this); }
211
212 protected:
213     JS_EXPORT_PRIVATE explicit JSGlobalObject(VM&, Structure*, const GlobalObjectMethodTable* = 0);
214
215     void finishCreation(VM& vm)
216     {
217         Base::finishCreation(vm);
218         structure()->setGlobalObject(vm, this);
219         m_experimentsEnabled = m_globalObjectMethodTable->javaScriptExperimentsEnabled(this);
220         init(this);
221     }
222
223     void finishCreation(VM& vm, JSObject* thisValue)
224     {
225         Base::finishCreation(vm);
226         structure()->setGlobalObject(vm, this);
227         m_experimentsEnabled = m_globalObjectMethodTable->javaScriptExperimentsEnabled(this);
228         init(thisValue);
229     }
230
231 public:
232     JS_EXPORT_PRIVATE ~JSGlobalObject();
233     JS_EXPORT_PRIVATE static void destroy(JSCell*);
234     // We don't need a destructor because we use a finalizer instead.
235     static const bool needsDestruction = false;
236
237     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
238
239     JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
240     JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, PropertyName, PropertyDescriptor&);
241     bool hasOwnPropertyForWrite(ExecState*, PropertyName);
242     JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
243
244     JS_EXPORT_PRIVATE static void putDirectVirtual(JSObject*, ExecState*, PropertyName, JSValue, unsigned attributes);
245
246     JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, PropertyName, JSObject* getterFunc, unsigned attributes);
247     JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, PropertyName, JSObject* setterFunc, unsigned attributes);
248     JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, PropertyDescriptor&, bool shouldThrow);
249
250     // We use this in the code generator as we perform symbol table
251     // lookups prior to initializing the properties
252     bool symbolTableHasProperty(PropertyName);
253
254     // The following accessors return pristine values, even if a script 
255     // replaces the global object's associated property.
256
257     RegExpConstructor* regExpConstructor() const { return m_regExpConstructor.get(); }
258
259     ErrorConstructor* errorConstructor() const { return m_errorConstructor.get(); }
260     NativeErrorConstructor* evalErrorConstructor() const { return m_evalErrorConstructor.get(); }
261     NativeErrorConstructor* rangeErrorConstructor() const { return m_rangeErrorConstructor.get(); }
262     NativeErrorConstructor* referenceErrorConstructor() const { return m_referenceErrorConstructor.get(); }
263     NativeErrorConstructor* syntaxErrorConstructor() const { return m_syntaxErrorConstructor.get(); }
264     NativeErrorConstructor* typeErrorConstructor() const { return m_typeErrorConstructor.get(); }
265     NativeErrorConstructor* URIErrorConstructor() const { return m_URIErrorConstructor.get(); }
266
267     JSFunction* evalFunction() const { return m_evalFunction.get(); }
268     JSFunction* callFunction() const { return m_callFunction.get(); }
269     JSFunction* applyFunction() const { return m_applyFunction.get(); }
270     GetterSetter* throwTypeErrorGetterSetter(ExecState* exec)
271     {
272         if (!m_throwTypeErrorGetterSetter)
273             createThrowTypeError(exec);
274         return m_throwTypeErrorGetterSetter.get();
275     }
276
277     ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
278     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
279     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
280     BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
281     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
282     NumberPrototype* numberPrototype() const { return m_numberPrototype.get(); }
283     DatePrototype* datePrototype() const { return m_datePrototype.get(); }
284     RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
285     ErrorPrototype* errorPrototype() const { return m_errorPrototype.get(); }
286
287     Structure* withScopeStructure() const { return m_withScopeStructure.get(); }
288     Structure* strictEvalActivationStructure() const { return m_strictEvalActivationStructure.get(); }
289     Structure* activationStructure() const { return m_activationStructure.get(); }
290     Structure* nameScopeStructure() const { return m_nameScopeStructure.get(); }
291     Structure* argumentsStructure() const { return m_argumentsStructure.get(); }
292     Structure* originalArrayStructureForIndexingType(IndexingType indexingType) const
293     {
294         ASSERT(indexingType & IsArray);
295         return m_originalArrayStructureForIndexingShape[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
296     }
297     Structure* arrayStructureForIndexingTypeDuringAllocation(IndexingType indexingType) const
298     {
299         ASSERT(indexingType & IsArray);
300         return m_arrayStructureForIndexingShapeDuringAllocation[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
301     }
302     Structure* arrayStructureForProfileDuringAllocation(ArrayAllocationProfile* profile) const
303     {
304         return arrayStructureForIndexingTypeDuringAllocation(ArrayAllocationProfile::selectIndexingTypeFor(profile));
305     }
306         
307     bool isOriginalArrayStructure(Structure* structure)
308     {
309         return originalArrayStructureForIndexingType(structure->indexingType() | IsArray) == structure;
310     }
311         
312     Structure* booleanObjectStructure() const { return m_booleanObjectStructure.get(); }
313     Structure* callbackConstructorStructure() const { return m_callbackConstructorStructure.get(); }
314     Structure* callbackFunctionStructure() const { return m_callbackFunctionStructure.get(); }
315     Structure* callbackObjectStructure() const { return m_callbackObjectStructure.get(); }
316 #if JSC_OBJC_API_ENABLED
317     Structure* objcCallbackFunctionStructure() const { return m_objcCallbackFunctionStructure.get(); }
318     Structure* objcWrapperObjectStructure() const { return m_objcWrapperObjectStructure.get(); }
319 #endif
320     Structure* dateStructure() const { return m_dateStructure.get(); }
321     Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(); }
322     Structure* errorStructure() const { return m_errorStructure.get(); }
323     Structure* functionStructure() const { return m_functionStructure.get(); }
324     Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(); }
325     Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(); }
326     PropertyOffset functionNameOffset() const { return m_functionNameOffset; }
327     Structure* numberObjectStructure() const { return m_numberObjectStructure.get(); }
328     Structure* privateNameStructure() const { return m_privateNameStructure.get(); }
329     Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
330     Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
331     Structure* regExpStructure() const { return m_regExpStructure.get(); }
332     Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
333
334     void* actualPointerFor(Special::Pointer pointer)
335     {
336         ASSERT(pointer < Special::TableSize);
337         return m_specialPointers[pointer];
338     }
339
340     WatchpointSet* masqueradesAsUndefinedWatchpoint() { return m_masqueradesAsUndefinedWatchpoint.get(); }
341     WatchpointSet* havingABadTimeWatchpoint() { return m_havingABadTimeWatchpoint.get(); }
342     WatchpointSet* varInjectionWatchpoint() { return m_varInjectionWatchpoint.get(); }
343         
344     bool isHavingABadTime() const
345     {
346         return m_havingABadTimeWatchpoint->hasBeenInvalidated();
347     }
348         
349     void haveABadTime(VM&);
350         
351     bool objectPrototypeIsSane();
352     bool arrayPrototypeChainIsSane();
353     bool stringPrototypeChainIsSane();
354
355     void setProfileGroup(unsigned value) { createRareDataIfNeeded(); m_rareData->profileGroup = value; }
356     unsigned profileGroup() const
357     { 
358         if (!m_rareData)
359             return 0;
360         return m_rareData->profileGroup;
361     }
362
363     Debugger* debugger() const { return m_debugger; }
364     void setDebugger(Debugger* debugger) { m_debugger = debugger; }
365
366     const GlobalObjectMethodTable* globalObjectMethodTable() const { return m_globalObjectMethodTable; }
367
368     static bool allowsAccessFrom(const JSGlobalObject*, ExecState*) { return true; }
369     static bool supportsProfiling(const JSGlobalObject*) { return false; }
370     static bool supportsRichSourceInfo(const JSGlobalObject*) { return true; }
371
372     JS_EXPORT_PRIVATE ExecState* globalExec();
373
374     static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
375     static bool javaScriptExperimentsEnabled(const JSGlobalObject*) { return false; }
376
377     bool evalEnabled() const { return m_evalEnabled; }
378     const String& evalDisabledErrorMessage() const { return m_evalDisabledErrorMessage; }
379     void setEvalEnabled(bool enabled, const String& errorMessage = String())
380     {
381         m_evalEnabled = enabled;
382         m_evalDisabledErrorMessage = errorMessage;
383     }
384
385     void resetPrototype(VM&, JSValue prototype);
386
387     VM& vm() const { return *Heap::heap(this)->vm(); }
388     JSObject* globalThis() const;
389     JS_EXPORT_PRIVATE void setGlobalThis(VM&, JSObject* globalThis);
390
391     static Structure* createStructure(VM& vm, JSValue prototype)
392     {
393         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
394     }
395
396     void registerWeakMap(OpaqueJSWeakObjectMap* map)
397     {
398         createRareDataIfNeeded();
399         m_rareData->weakMaps.add(map);
400     }
401
402     void unregisterWeakMap(OpaqueJSWeakObjectMap* map)
403     {
404         if (m_rareData)
405             m_rareData->weakMaps.remove(map);
406     }
407
408     OpaqueJSClassDataMap& opaqueJSClassData()
409     {
410         createRareDataIfNeeded();
411         return m_rareData->opaqueJSClassData;
412     }
413
414     double weakRandomNumber() { return m_weakRandom.get(); }
415     unsigned weakRandomInteger() { return m_weakRandom.getUint32(); }
416
417     UnlinkedProgramCodeBlock* createProgramCodeBlock(CallFrame*, ProgramExecutable*, JSObject** exception);
418     UnlinkedEvalCodeBlock* createEvalCodeBlock(CallFrame*, EvalExecutable*);
419
420 protected:
421
422     static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | Base::StructureFlags;
423
424     struct GlobalPropertyInfo {
425         GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
426             : identifier(i)
427             , value(v)
428             , attributes(a)
429         {
430         }
431
432         const Identifier identifier;
433         JSValue value;
434         unsigned attributes;
435     };
436     JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
437
438     JS_EXPORT_PRIVATE static JSC::JSValue toThis(JSC::JSCell*, JSC::ExecState*, ECMAMode);
439
440 private:
441     friend class LLIntOffsetsExtractor;
442         
443     // FIXME: Fold reset into init.
444     JS_EXPORT_PRIVATE void init(JSObject* thisValue);
445     void reset(JSValue prototype);
446
447     void createThrowTypeError(ExecState*);
448
449     JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
450 };
451
452 JSGlobalObject* asGlobalObject(JSValue);
453
454 inline JSGlobalObject* asGlobalObject(JSValue value)
455 {
456     ASSERT(asObject(value)->isGlobalObject());
457     return jsCast<JSGlobalObject*>(asObject(value));
458 }
459
460 inline bool JSGlobalObject::hasOwnPropertyForWrite(ExecState* exec, PropertyName propertyName)
461 {
462     PropertySlot slot(this);
463     if (Base::getOwnPropertySlot(this, exec, propertyName, slot))
464         return true;
465     bool slotIsWriteable;
466     return symbolTableGet(this, propertyName, slot, slotIsWriteable);
467 }
468
469 inline bool JSGlobalObject::symbolTableHasProperty(PropertyName propertyName)
470 {
471     SymbolTableEntry entry = symbolTable()->inlineGet(propertyName.publicName());
472     return !entry.isNull();
473 }
474
475 inline JSGlobalObject* ExecState::dynamicGlobalObject()
476 {
477     if (this == lexicalGlobalObject()->globalExec())
478         return lexicalGlobalObject();
479
480     // For any ExecState that's not a globalExec, the 
481     // dynamic global object must be set since code is running
482     ASSERT(vm().dynamicGlobalObject);
483     return vm().dynamicGlobalObject;
484 }
485
486 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, unsigned initialLength = 0)
487 {
488     return ArrayAllocationProfile::updateLastAllocationFor(profile, JSArray::create(exec->vm(), initialLength >= MIN_SPARSE_ARRAY_INDEX ? globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage) : globalObject->arrayStructureForProfileDuringAllocation(profile), initialLength));
489 }
490
491 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, unsigned initialLength = 0)
492 {
493     return constructEmptyArray(exec, profile, exec->lexicalGlobalObject(), initialLength);
494 }
495  
496 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const ArgList& values)
497 {
498     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values));
499 }
500
501 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const ArgList& values)
502 {
503     return constructArray(exec, profile, exec->lexicalGlobalObject(), values);
504 }
505
506 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length)
507 {
508     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values, length));
509 }
510
511 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length)
512 {
513     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, length);
514 }
515
516 class DynamicGlobalObjectScope {
517     WTF_MAKE_NONCOPYABLE(DynamicGlobalObjectScope);
518 public:
519     JS_EXPORT_PRIVATE DynamicGlobalObjectScope(VM&, JSGlobalObject*);
520
521     ~DynamicGlobalObjectScope()
522     {
523         m_dynamicGlobalObjectSlot = m_savedDynamicGlobalObject;
524     }
525
526 private:
527     JSGlobalObject*& m_dynamicGlobalObjectSlot;
528     JSGlobalObject* m_savedDynamicGlobalObject;
529 };
530
531 inline JSObject* JSScope::globalThis()
532
533     return globalObject()->globalThis();
534 }
535
536 inline JSObject* JSGlobalObject::globalThis() const
537
538     return m_globalThis.get();
539 }
540
541 } // namespace JSC
542
543 #endif // JSGlobalObject_h