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