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