b0cad3dc5470f7c7a0e570bdcd2dffa895e2aa0c
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSGlobalObject.h
1 /*
2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  *  Copyright (C) 2007, 2008, 2009, 2014 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 "ConstantMode.h"
27 #include "JSArray.h"
28 #include "JSArrayBufferPrototype.h"
29 #include "JSClassRef.h"
30 #include "JSSegmentedVariableObject.h"
31 #include "JSWeakObjectMapRefInternal.h"
32 #include "NumberPrototype.h"
33 #include "SpecialPointer.h"
34 #include "StringPrototype.h"
35 #include "StructureChain.h"
36 #include "StructureRareDataInlines.h"
37 #include "VM.h"
38 #include "Watchpoint.h"
39 #include <JavaScriptCore/JSBase.h>
40 #include <array>
41 #include <wtf/HashSet.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/PassRefPtr.h>
44 #include <wtf/RandomNumber.h>
45
46 struct OpaqueJSClass;
47 struct OpaqueJSClassContextData;
48
49 namespace JSC {
50
51 class ArrayPrototype;
52 class BooleanPrototype;
53 class Debugger;
54 class ErrorConstructor;
55 class ErrorPrototype;
56 class EvalCodeBlock;
57 class EvalExecutable;
58 class FunctionCodeBlock;
59 class FunctionExecutable;
60 class FunctionPrototype;
61 class GetterSetter;
62 class GlobalCodeBlock;
63 class JSGlobalObjectDebuggable;
64 class JSPromiseConstructor;
65 class JSPromisePrototype;
66 class JSStack;
67 class LLIntOffsetsExtractor;
68 class Microtask;
69 class NativeErrorConstructor;
70 class ProgramCodeBlock;
71 class ProgramExecutable;
72 class RegExpConstructor;
73 class RegExpPrototype;
74 class SourceCode;
75 struct ActivationStackNode;
76 struct HashTable;
77
78 #define DEFINE_STANDARD_BUILTIN(macro, upperName, lowerName) macro(upperName, lowerName, lowerName, JS ## upperName, upperName)
79     
80 #define FOR_EACH_SIMPLE_BUILTIN_TYPE(macro) \
81     macro(Set, set, set, JSSet, Set) \
82     macro(Map, map, map, JSMap, Map) \
83     macro(Date, date, date, DateInstance, Date) \
84     macro(String, string, stringObject, StringObject, String) \
85     macro(Boolean, boolean, booleanObject, BooleanObject, Boolean) \
86     macro(Number, number, numberObject, NumberObject, Number) \
87     macro(Error, error, error, ErrorInstance, Error) \
88     macro(JSArrayBuffer, arrayBuffer, arrayBuffer, JSArrayBuffer, ArrayBuffer) \
89     DEFINE_STANDARD_BUILTIN(macro, WeakMap, weakMap) \
90     DEFINE_STANDARD_BUILTIN(macro, ArrayIterator, arrayIterator) \
91     DEFINE_STANDARD_BUILTIN(macro, ArgumentsIterator, argumentsIterator) \
92     DEFINE_STANDARD_BUILTIN(macro, MapIterator, mapIterator) \
93     DEFINE_STANDARD_BUILTIN(macro, SetIterator, setIterator) \
94
95
96 #define DECLARE_SIMPLE_BUILTIN_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
97     class JS ## capitalName; \
98     class capitalName ## Prototype; \
99     class capitalName ## Constructor;
100
101 FOR_EACH_SIMPLE_BUILTIN_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
102
103 #undef DECLARE_SIMPLE_BUILTIN_TYPE
104
105 typedef Vector<ExecState*, 16> ExecStateStack;
106
107 struct GlobalObjectMethodTable {
108     typedef bool (*AllowsAccessFromFunctionPtr)(const JSGlobalObject*, ExecState*);
109     AllowsAccessFromFunctionPtr allowsAccessFrom;
110
111     typedef bool (*SupportsProfilingFunctionPtr)(const JSGlobalObject*); 
112     SupportsProfilingFunctionPtr supportsProfiling;
113
114     typedef bool (*SupportsRichSourceInfoFunctionPtr)(const JSGlobalObject*);
115     SupportsRichSourceInfoFunctionPtr supportsRichSourceInfo;
116
117     typedef bool (*ShouldInterruptScriptFunctionPtr)(const JSGlobalObject*);
118     ShouldInterruptScriptFunctionPtr shouldInterruptScript;
119
120     typedef bool (*JavaScriptExperimentsEnabledFunctionPtr)(const JSGlobalObject*);
121     JavaScriptExperimentsEnabledFunctionPtr javaScriptExperimentsEnabled;
122
123     typedef void (*QueueTaskToEventLoopFunctionPtr)(const JSGlobalObject*, PassRefPtr<Microtask>);
124     QueueTaskToEventLoopFunctionPtr queueTaskToEventLoop;
125
126     typedef bool (*ShouldInterruptScriptBeforeTimeoutPtr)(const JSGlobalObject*);
127     ShouldInterruptScriptBeforeTimeoutPtr shouldInterruptScriptBeforeTimeout;
128 };
129
130 class JSGlobalObject : public JSSegmentedVariableObject {
131 private:
132     typedef HashSet<RefPtr<OpaqueJSWeakObjectMap>> WeakMapSet;
133     typedef HashMap<OpaqueJSClass*, std::unique_ptr<OpaqueJSClassContextData>> OpaqueJSClassDataMap;
134
135     struct JSGlobalObjectRareData {
136         JSGlobalObjectRareData()
137             : profileGroup(0)
138         {
139         }
140
141         WeakMapSet weakMaps;
142         unsigned profileGroup;
143         
144         OpaqueJSClassDataMap opaqueJSClassData;
145     };
146
147 protected:
148     Register m_globalCallFrame[JSStack::CallFrameHeaderSize];
149
150     WriteBarrier<JSObject> m_globalThis;
151
152     WriteBarrier<RegExpConstructor> m_regExpConstructor;
153     WriteBarrier<ErrorConstructor> m_errorConstructor;
154     WriteBarrier<NativeErrorConstructor> m_evalErrorConstructor;
155     WriteBarrier<NativeErrorConstructor> m_rangeErrorConstructor;
156     WriteBarrier<NativeErrorConstructor> m_referenceErrorConstructor;
157     WriteBarrier<NativeErrorConstructor> m_syntaxErrorConstructor;
158     WriteBarrier<NativeErrorConstructor> m_typeErrorConstructor;
159     WriteBarrier<NativeErrorConstructor> m_URIErrorConstructor;
160     WriteBarrier<JSPromiseConstructor> m_promiseConstructor;
161
162     WriteBarrier<JSFunction> m_evalFunction;
163     WriteBarrier<JSFunction> m_callFunction;
164     WriteBarrier<JSFunction> m_applyFunction;
165     WriteBarrier<GetterSetter> m_throwTypeErrorGetterSetter;
166
167     WriteBarrier<ObjectPrototype> m_objectPrototype;
168     WriteBarrier<FunctionPrototype> m_functionPrototype;
169     WriteBarrier<ArrayPrototype> m_arrayPrototype;
170     WriteBarrier<RegExpPrototype> m_regExpPrototype;
171     WriteBarrier<JSPromisePrototype> m_promisePrototype;
172
173     WriteBarrier<Structure> m_withScopeStructure;
174     WriteBarrier<Structure> m_strictEvalActivationStructure;
175     WriteBarrier<Structure> m_activationStructure;
176     WriteBarrier<Structure> m_nameScopeStructure;
177     WriteBarrier<Structure> m_argumentsStructure;
178         
179     // Lists the actual structures used for having these particular indexing shapes.
180     WriteBarrier<Structure> m_originalArrayStructureForIndexingShape[NumberOfIndexingShapes];
181     // Lists the structures we should use during allocation for these particular indexing shapes.
182     WriteBarrier<Structure> m_arrayStructureForIndexingShapeDuringAllocation[NumberOfIndexingShapes];
183
184     WriteBarrier<Structure> m_callbackConstructorStructure;
185     WriteBarrier<Structure> m_callbackFunctionStructure;
186     WriteBarrier<Structure> m_callbackObjectStructure;
187 #if JSC_OBJC_API_ENABLED
188     WriteBarrier<Structure> m_objcCallbackFunctionStructure;
189     WriteBarrier<Structure> m_objcWrapperObjectStructure;
190 #endif
191     WriteBarrier<Structure> m_nullPrototypeObjectStructure;
192     WriteBarrier<Structure> m_functionStructure;
193     WriteBarrier<Structure> m_boundFunctionStructure;
194     WriteBarrier<Structure> m_namedFunctionStructure;
195     PropertyOffset m_functionNameOffset;
196     WriteBarrier<Structure> m_privateNameStructure;
197     WriteBarrier<Structure> m_regExpMatchesArrayStructure;
198     WriteBarrier<Structure> m_regExpStructure;
199     WriteBarrier<Structure> m_internalFunctionStructure;
200     
201     WriteBarrier<Structure> m_iteratorResultStructure;
202
203 #if ENABLE(PROMISES)
204     WriteBarrier<Structure> m_promiseStructure;
205 #endif // ENABLE(PROMISES)
206
207 #define DEFINE_STORAGE_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
208     WriteBarrier<capitalName ## Prototype> m_ ## lowerName ## Prototype; \
209     WriteBarrier<Structure> m_ ## properName ## Structure;
210
211     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
212
213 #undef DEFINE_STORAGE_FOR_SIMPLE_TYPE
214
215     struct TypedArrayData {
216         WriteBarrier<JSObject> prototype;
217         WriteBarrier<Structure> structure;
218     };
219     
220     std::array<TypedArrayData, NUMBER_OF_TYPED_ARRAY_TYPES> m_typedArrays;
221         
222     void* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
223
224     String m_name;
225
226     Debugger* m_debugger;
227
228 #if ENABLE(REMOTE_INSPECTOR)
229     std::unique_ptr<JSGlobalObjectDebuggable> m_inspectorDebuggable;
230 #endif
231
232     RefPtr<WatchpointSet> m_masqueradesAsUndefinedWatchpoint;
233     RefPtr<WatchpointSet> m_havingABadTimeWatchpoint;
234     RefPtr<WatchpointSet> m_varInjectionWatchpoint;
235
236     OwnPtr<JSGlobalObjectRareData> m_rareData;
237
238     WeakRandom m_weakRandom;
239
240     bool m_evalEnabled;
241     String m_evalDisabledErrorMessage;
242     bool m_experimentsEnabled;
243
244     static JS_EXPORTDATA const GlobalObjectMethodTable s_globalObjectMethodTable;
245     const GlobalObjectMethodTable* m_globalObjectMethodTable;
246
247     void createRareDataIfNeeded()
248     {
249         if (m_rareData)
250             return;
251         m_rareData = adoptPtr(new JSGlobalObjectRareData);
252     }
253         
254 public:
255     typedef JSSegmentedVariableObject Base;
256
257     static JSGlobalObject* create(VM& vm, Structure* structure)
258     {
259         JSGlobalObject* globalObject = new (NotNull, allocateCell<JSGlobalObject>(vm.heap)) JSGlobalObject(vm, structure);
260         globalObject->finishCreation(vm);
261         vm.heap.addFinalizer(globalObject, destroy);
262         return globalObject;
263     }
264
265     DECLARE_EXPORT_INFO;
266
267     bool hasDebugger() const { return m_debugger; }
268     bool hasProfiler() const { return globalObjectMethodTable()->supportsProfiling(this); }
269
270 protected:
271     JS_EXPORT_PRIVATE explicit JSGlobalObject(VM&, Structure*, const GlobalObjectMethodTable* = 0);
272
273     void finishCreation(VM& vm)
274     {
275         Base::finishCreation(vm);
276         structure()->setGlobalObject(vm, this);
277         m_experimentsEnabled = m_globalObjectMethodTable->javaScriptExperimentsEnabled(this);
278         init(this);
279     }
280
281     void finishCreation(VM& vm, JSObject* thisValue)
282     {
283         Base::finishCreation(vm);
284         structure()->setGlobalObject(vm, this);
285         m_experimentsEnabled = m_globalObjectMethodTable->javaScriptExperimentsEnabled(this);
286         init(thisValue);
287     }
288
289     struct NewGlobalVar {
290         int registerNumber;
291         VariableWatchpointSet* set;
292     };
293     NewGlobalVar addGlobalVar(const Identifier&, ConstantMode);
294
295 public:
296     JS_EXPORT_PRIVATE ~JSGlobalObject();
297     JS_EXPORT_PRIVATE static void destroy(JSCell*);
298     // We don't need a destructor because we use a finalizer instead.
299     static const bool needsDestruction = false;
300
301     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
302
303     JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
304     bool hasOwnPropertyForWrite(ExecState*, PropertyName);
305     JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
306
307     JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, PropertyName, JSObject* getterFunc, unsigned attributes);
308     JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, PropertyName, JSObject* setterFunc, unsigned attributes);
309     JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
310
311     // We use this in the code generator as we perform symbol table
312     // lookups prior to initializing the properties
313     bool symbolTableHasProperty(PropertyName);
314
315     void addVar(ExecState* exec, const Identifier& propertyName)
316     {
317         if (!hasProperty(exec, propertyName))
318             addGlobalVar(propertyName, IsVariable);
319     }
320     void addConst(ExecState* exec, const Identifier& propertyName)
321     {
322         if (!hasProperty(exec, propertyName))
323             addGlobalVar(propertyName, IsConstant);
324     }
325     void addFunction(ExecState*, const Identifier&, JSValue);
326
327     // The following accessors return pristine values, even if a script 
328     // replaces the global object's associated property.
329
330     RegExpConstructor* regExpConstructor() const { return m_regExpConstructor.get(); }
331
332     ErrorConstructor* errorConstructor() const { return m_errorConstructor.get(); }
333     NativeErrorConstructor* evalErrorConstructor() const { return m_evalErrorConstructor.get(); }
334     NativeErrorConstructor* rangeErrorConstructor() const { return m_rangeErrorConstructor.get(); }
335     NativeErrorConstructor* referenceErrorConstructor() const { return m_referenceErrorConstructor.get(); }
336     NativeErrorConstructor* syntaxErrorConstructor() const { return m_syntaxErrorConstructor.get(); }
337     NativeErrorConstructor* typeErrorConstructor() const { return m_typeErrorConstructor.get(); }
338     NativeErrorConstructor* URIErrorConstructor() const { return m_URIErrorConstructor.get(); }
339     JSPromiseConstructor* promiseConstructor() const { return m_promiseConstructor.get(); }
340
341     JSFunction* evalFunction() const { return m_evalFunction.get(); }
342     JSFunction* callFunction() const { return m_callFunction.get(); }
343     JSFunction* applyFunction() const { return m_applyFunction.get(); }
344     GetterSetter* throwTypeErrorGetterSetter(VM& vm)
345     {
346         if (!m_throwTypeErrorGetterSetter)
347             createThrowTypeError(vm);
348         return m_throwTypeErrorGetterSetter.get();
349     }
350
351     ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
352     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
353     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
354     BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
355     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
356     NumberPrototype* numberPrototype() const { return m_numberPrototype.get(); }
357     DatePrototype* datePrototype() const { return m_datePrototype.get(); }
358     RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
359     ErrorPrototype* errorPrototype() const { return m_errorPrototype.get(); }
360     JSPromisePrototype* promisePrototype() const { return m_promisePrototype.get(); }
361
362     Structure* withScopeStructure() const { return m_withScopeStructure.get(); }
363     Structure* strictEvalActivationStructure() const { return m_strictEvalActivationStructure.get(); }
364     Structure* activationStructure() const { return m_activationStructure.get(); }
365     Structure* nameScopeStructure() const { return m_nameScopeStructure.get(); }
366     Structure* argumentsStructure() const { return m_argumentsStructure.get(); }
367     Structure* originalArrayStructureForIndexingType(IndexingType indexingType) const
368     {
369         ASSERT(indexingType & IsArray);
370         return m_originalArrayStructureForIndexingShape[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
371     }
372     Structure* arrayStructureForIndexingTypeDuringAllocation(IndexingType indexingType) const
373     {
374         ASSERT(indexingType & IsArray);
375         return m_arrayStructureForIndexingShapeDuringAllocation[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
376     }
377     Structure* arrayStructureForProfileDuringAllocation(ArrayAllocationProfile* profile) const
378     {
379         return arrayStructureForIndexingTypeDuringAllocation(ArrayAllocationProfile::selectIndexingTypeFor(profile));
380     }
381         
382     bool isOriginalArrayStructure(Structure* structure)
383     {
384         return originalArrayStructureForIndexingType(structure->indexingType() | IsArray) == structure;
385     }
386         
387     Structure* booleanObjectStructure() const { return m_booleanObjectStructure.get(); }
388     Structure* callbackConstructorStructure() const { return m_callbackConstructorStructure.get(); }
389     Structure* callbackFunctionStructure() const { return m_callbackFunctionStructure.get(); }
390     Structure* callbackObjectStructure() const { return m_callbackObjectStructure.get(); }
391 #if JSC_OBJC_API_ENABLED
392     Structure* objcCallbackFunctionStructure() const { return m_objcCallbackFunctionStructure.get(); }
393     Structure* objcWrapperObjectStructure() const { return m_objcWrapperObjectStructure.get(); }
394 #endif
395     Structure* dateStructure() const { return m_dateStructure.get(); }
396     Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(); }
397     Structure* errorStructure() const { return m_errorStructure.get(); }
398     Structure* functionStructure() const { return m_functionStructure.get(); }
399     Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(); }
400     Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(); }
401     PropertyOffset functionNameOffset() const { return m_functionNameOffset; }
402     Structure* numberObjectStructure() const { return m_numberObjectStructure.get(); }
403     Structure* privateNameStructure() const { return m_privateNameStructure.get(); }
404     Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
405     Structure* mapStructure() const { return m_mapStructure.get(); }
406     Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
407     Structure* regExpStructure() const { return m_regExpStructure.get(); }
408     Structure* setStructure() const { return m_setStructure.get(); }
409     Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
410     Structure* iteratorResultStructure() const { return m_iteratorResultStructure.get(); }
411     static ptrdiff_t iteratorResultStructureOffset() { return OBJECT_OFFSETOF(JSGlobalObject, m_iteratorResultStructure); }
412
413 #if ENABLE(PROMISES)
414     Structure* promiseStructure() const { return m_promiseStructure.get(); }
415 #endif // ENABLE(PROMISES)
416
417     JS_EXPORT_PRIVATE void setRemoteDebuggingEnabled(bool);
418     JS_EXPORT_PRIVATE bool remoteDebuggingEnabled() const;
419
420     void setName(const String&);
421     const String& name() const { return m_name; }
422
423     JSArrayBufferPrototype* arrayBufferPrototype() const { return m_arrayBufferPrototype.get(); }
424
425 #define DEFINE_ACCESSORS_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
426     Structure* properName ## Structure() { return m_ ## properName ## Structure.get(); }
427
428     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
429
430 #undef DEFINE_ACCESSORS_FOR_SIMPLE_TYPE
431
432     Structure* typedArrayStructure(TypedArrayType type) const
433     {
434         return m_typedArrays[toIndex(type)].structure.get();
435     }
436     bool isOriginalTypedArrayStructure(Structure* structure)
437     {
438         TypedArrayType type = structure->classInfo()->typedArrayStorageType;
439         if (type == NotTypedArray)
440             return false;
441         return typedArrayStructure(type) == structure;
442     }
443
444     void* actualPointerFor(Special::Pointer pointer)
445     {
446         ASSERT(pointer < Special::TableSize);
447         return m_specialPointers[pointer];
448     }
449
450     WatchpointSet* masqueradesAsUndefinedWatchpoint() { return m_masqueradesAsUndefinedWatchpoint.get(); }
451     WatchpointSet* havingABadTimeWatchpoint() { return m_havingABadTimeWatchpoint.get(); }
452     WatchpointSet* varInjectionWatchpoint() { return m_varInjectionWatchpoint.get(); }
453         
454     bool isHavingABadTime() const
455     {
456         return m_havingABadTimeWatchpoint->hasBeenInvalidated();
457     }
458         
459     void haveABadTime(VM&);
460         
461     bool objectPrototypeIsSane();
462     bool arrayPrototypeChainIsSane();
463     bool stringPrototypeChainIsSane();
464
465     void setProfileGroup(unsigned value) { createRareDataIfNeeded(); m_rareData->profileGroup = value; }
466     unsigned profileGroup() const
467     { 
468         if (!m_rareData)
469             return 0;
470         return m_rareData->profileGroup;
471     }
472
473     Debugger* debugger() const { return m_debugger; }
474     void setDebugger(Debugger* debugger) { m_debugger = debugger; }
475
476     const GlobalObjectMethodTable* globalObjectMethodTable() const { return m_globalObjectMethodTable; }
477
478     static bool allowsAccessFrom(const JSGlobalObject*, ExecState*) { return true; }
479     static bool supportsProfiling(const JSGlobalObject*) { return false; }
480     static bool supportsRichSourceInfo(const JSGlobalObject*) { return true; }
481
482     JS_EXPORT_PRIVATE ExecState* globalExec();
483
484     static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
485     static bool shouldInterruptScriptBeforeTimeout(const JSGlobalObject*) { return false; }
486     static bool javaScriptExperimentsEnabled(const JSGlobalObject*) { return false; }
487
488     void queueMicrotask(PassRefPtr<Microtask>);
489
490     bool evalEnabled() const { return m_evalEnabled; }
491     const String& evalDisabledErrorMessage() const { return m_evalDisabledErrorMessage; }
492     void setEvalEnabled(bool enabled, const String& errorMessage = String())
493     {
494         m_evalEnabled = enabled;
495         m_evalDisabledErrorMessage = errorMessage;
496     }
497
498     void resetPrototype(VM&, JSValue prototype);
499
500     VM& vm() const { return *Heap::heap(this)->vm(); }
501     JSObject* globalThis() const;
502     JS_EXPORT_PRIVATE void setGlobalThis(VM&, JSObject* globalThis);
503
504     static Structure* createStructure(VM& vm, JSValue prototype)
505     {
506         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
507     }
508
509     void registerWeakMap(OpaqueJSWeakObjectMap* map)
510     {
511         createRareDataIfNeeded();
512         m_rareData->weakMaps.add(map);
513     }
514
515     void unregisterWeakMap(OpaqueJSWeakObjectMap* map)
516     {
517         if (m_rareData)
518             m_rareData->weakMaps.remove(map);
519     }
520
521     OpaqueJSClassDataMap& opaqueJSClassData()
522     {
523         createRareDataIfNeeded();
524         return m_rareData->opaqueJSClassData;
525     }
526
527     double weakRandomNumber() { return m_weakRandom.get(); }
528     unsigned weakRandomInteger() { return m_weakRandom.getUint32(); }
529
530     UnlinkedProgramCodeBlock* createProgramCodeBlock(CallFrame*, ProgramExecutable*, JSObject** exception);
531     UnlinkedEvalCodeBlock* createEvalCodeBlock(CallFrame*, EvalExecutable*);
532
533 protected:
534
535     static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | Base::StructureFlags;
536
537     struct GlobalPropertyInfo {
538         GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
539             : identifier(i)
540             , value(v)
541             , attributes(a)
542         {
543         }
544
545         const Identifier identifier;
546         JSValue value;
547         unsigned attributes;
548     };
549     JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
550
551     JS_EXPORT_PRIVATE static JSC::JSValue toThis(JSC::JSCell*, JSC::ExecState*, ECMAMode);
552
553 private:
554     friend class LLIntOffsetsExtractor;
555         
556     // FIXME: Fold reset into init.
557     JS_EXPORT_PRIVATE void init(JSObject* thisValue);
558     void reset(JSValue prototype);
559
560     void createThrowTypeError(VM&);
561
562     JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
563 };
564
565 JSGlobalObject* asGlobalObject(JSValue);
566
567 inline JSGlobalObject* asGlobalObject(JSValue value)
568 {
569     ASSERT(asObject(value)->isGlobalObject());
570     return jsCast<JSGlobalObject*>(asObject(value));
571 }
572
573 inline bool JSGlobalObject::hasOwnPropertyForWrite(ExecState* exec, PropertyName propertyName)
574 {
575     PropertySlot slot(this);
576     if (Base::getOwnPropertySlot(this, exec, propertyName, slot))
577         return true;
578     bool slotIsWriteable;
579     return symbolTableGet(this, propertyName, slot, slotIsWriteable);
580 }
581
582 inline bool JSGlobalObject::symbolTableHasProperty(PropertyName propertyName)
583 {
584     SymbolTableEntry entry = symbolTable()->inlineGet(propertyName.publicName());
585     return !entry.isNull();
586 }
587
588 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, unsigned initialLength = 0)
589 {
590     return ArrayAllocationProfile::updateLastAllocationFor(profile, JSArray::create(exec->vm(), initialLength >= MIN_SPARSE_ARRAY_INDEX ? globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage) : globalObject->arrayStructureForProfileDuringAllocation(profile), initialLength));
591 }
592
593 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, unsigned initialLength = 0)
594 {
595     return constructEmptyArray(exec, profile, exec->lexicalGlobalObject(), initialLength);
596 }
597  
598 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const ArgList& values)
599 {
600     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values));
601 }
602
603 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const ArgList& values)
604 {
605     return constructArray(exec, profile, exec->lexicalGlobalObject(), values);
606 }
607
608 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length)
609 {
610     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values, length));
611 }
612
613 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length)
614 {
615     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, length);
616 }
617
618 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length)
619 {
620     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArrayNegativeIndexed(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values, length));
621 }
622
623 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length)
624 {
625     return constructArrayNegativeIndexed(exec, profile, exec->lexicalGlobalObject(), values, length);
626 }
627
628 inline JSObject* JSScope::globalThis()
629
630     return globalObject()->globalThis();
631 }
632
633 inline JSObject* JSGlobalObject::globalThis() const
634
635     return m_globalThis.get();
636 }
637
638 } // namespace JSC
639
640 #endif // JSGlobalObject_h