Remove excessive headers from JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSGlobalObject.h
1 /*
2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  *  Copyright (C) 2007-2017 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 #pragma once
23
24 #include "ArrayAllocationProfile.h"
25 #include "ArrayBufferSharingMode.h"
26 #include "ExceptionHelpers.h"
27 #include "InternalFunction.h"
28 #include "JSArray.h"
29 #include "JSArrayBufferPrototype.h"
30 #include "JSClassRef.h"
31 #include "JSGlobalLexicalEnvironment.h"
32 #include "JSSegmentedVariableObject.h"
33 #include "JSWeakObjectMapRefInternal.h"
34 #include "LazyProperty.h"
35 #include "LazyClassStructure.h"
36 #include "NumberPrototype.h"
37 #include "RuntimeFlags.h"
38 #include "SpecialPointer.h"
39 #include "StringPrototype.h"
40 #include "SymbolPrototype.h"
41 #include "TemplateRegistry.h"
42 #include "VM.h"
43 #include "Watchpoint.h"
44 #include <JavaScriptCore/JSBase.h>
45 #include <array>
46 #include <wtf/HashSet.h>
47 #include <wtf/RetainPtr.h>
48
49 struct OpaqueJSClass;
50 struct OpaqueJSClassContextData;
51 OBJC_CLASS JSWrapperMap;
52
53 namespace Inspector {
54 class JSGlobalObjectInspectorController;
55 }
56
57 namespace JSC {
58 class ArrayConstructor;
59 class ArrayPrototype;
60 class AsyncFunctionPrototype;
61 class BooleanPrototype;
62 class ConsoleClient;
63 class Debugger;
64 class ErrorConstructor;
65 class ErrorPrototype;
66 class EvalCodeBlock;
67 class EvalExecutable;
68 class FunctionConstructor;
69 class FunctionPrototype;
70 class GeneratorPrototype;
71 class GeneratorFunctionPrototype;
72 class GetterSetter;
73 class GlobalCodeBlock;
74 class IndirectEvalExecutable;
75 class InputCursor;
76 class JSArrayBuffer;
77 class JSArrayBufferConstructor;
78 class JSArrayBufferPrototype;
79 class JSGlobalObjectDebuggable;
80 class JSInternalPromise;
81 class JSModuleLoader;
82 class JSPromise;
83 class JSPromiseConstructor;
84 class JSPromisePrototype;
85 class JSSharedArrayBuffer;
86 class JSSharedArrayBufferConstructor;
87 class JSSharedArrayBufferPrototype;
88 class JSTypedArrayViewConstructor;
89 class JSTypedArrayViewPrototype;
90 class DirectEvalExecutable;
91 class LLIntOffsetsExtractor;
92 class MapPrototype;
93 class Microtask;
94 class ModuleLoaderPrototype;
95 class ModuleProgramExecutable;
96 class NativeErrorConstructor;
97 class NullGetterFunction;
98 class NullSetterFunction;
99 class ObjectConstructor;
100 class ProgramCodeBlock;
101 class ProgramExecutable;
102 class RegExpConstructor;
103 class RegExpPrototype;
104 class SetPrototype;
105 class SourceCode;
106 class SourceOrigin;
107 class UnlinkedModuleProgramCodeBlock;
108 class VariableEnvironment;
109 struct ActivationStackNode;
110 struct HashTable;
111
112 template<typename Watchpoint> class ObjectPropertyChangeAdaptiveWatchpoint;
113
114 #define DEFINE_STANDARD_BUILTIN(macro, upperName, lowerName) macro(upperName, lowerName, lowerName, JS ## upperName, upperName, object)
115
116 #define FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
117     macro(String, string, stringObject, StringObject, String, object) \
118     macro(Symbol, symbol, symbolObject, SymbolObject, Symbol, object) \
119     macro(Number, number, numberObject, NumberObject, Number, object) \
120     macro(Error, error, error, ErrorInstance, Error, object) \
121     macro(Map, map, map, JSMap, Map, object) \
122     macro(Set, set, set, JSSet, Set, object) \
123     macro(JSPromise, promise, promise, JSPromise, Promise, object)
124
125 #define FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(macro) \
126     macro(MapIterator, mapIterator, mapIterator, JSMapIterator, MapIterator, iterator) \
127     macro(SetIterator, setIterator, setIterator, JSSetIterator, SetIterator, iterator) \
128     macro(StringIterator, stringIterator, stringIterator, JSStringIterator, StringIterator, iterator) \
129
130 #define FOR_EACH_SIMPLE_BUILTIN_TYPE(macro) \
131     FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
132     macro(JSInternalPromise, internalPromise, internalPromise, JSInternalPromise, InternalPromise, object) \
133
134 #define FOR_EACH_LAZY_BUILTIN_TYPE(macro) \
135     macro(Date, date, date, DateInstance, Date, object) \
136     macro(Boolean, boolean, booleanObject, BooleanObject, Boolean, object) \
137     DEFINE_STANDARD_BUILTIN(macro, WeakMap, weakMap) \
138     DEFINE_STANDARD_BUILTIN(macro, WeakSet, weakSet) \
139
140 #if ENABLE(WEBASSEMBLY)
141 #define FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(macro) \
142     macro(WebAssemblyCompileError, webAssemblyCompileError, WebAssemblyCompileError, WebAssemblyCompileError, CompileError, error) \
143     macro(WebAssemblyInstance,     webAssemblyInstance,     WebAssemblyInstance,     WebAssemblyInstance,     Instance,     object) \
144     macro(WebAssemblyLinkError,    webAssemblyLinkError,    WebAssemblyLinkError,    WebAssemblyLinkError,    LinkError,    error) \
145     macro(WebAssemblyMemory,       webAssemblyMemory,       WebAssemblyMemory,       WebAssemblyMemory,       Memory,       object) \
146     macro(WebAssemblyModule,       webAssemblyModule,       WebAssemblyModule,       WebAssemblyModule,       Module,       object) \
147     macro(WebAssemblyRuntimeError, webAssemblyRuntimeError, WebAssemblyRuntimeError, WebAssemblyRuntimeError, RuntimeError, error) \
148     macro(WebAssemblyTable,        webAssemblyTable,        WebAssemblyTable,        WebAssemblyTable,        Table,        object)
149 #else
150 #define FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(macro)
151 #endif // ENABLE(WEBASSEMBLY)
152
153 #define DECLARE_SIMPLE_BUILTIN_TYPE(capitalName, lowerName, properName, instanceType, jsName, prototypeBase) \
154     class JS ## capitalName; \
155     class capitalName ## Prototype; \
156     class capitalName ## Constructor;
157
158 class IteratorPrototype;
159 FOR_EACH_SIMPLE_BUILTIN_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
160 FOR_EACH_LAZY_BUILTIN_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
161 FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
162 FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
163
164 #undef DECLARE_SIMPLE_BUILTIN_TYPE
165
166 enum class JSPromiseRejectionOperation : unsigned {
167     Reject, // When a promise is rejected without any handlers.
168     Handle, // When a handler is added to a rejected promise for the first time.
169 };
170
171 struct GlobalObjectMethodTable {
172     typedef bool (*SupportsRichSourceInfoFunctionPtr)(const JSGlobalObject*);
173     SupportsRichSourceInfoFunctionPtr supportsRichSourceInfo;
174
175     typedef bool (*ShouldInterruptScriptFunctionPtr)(const JSGlobalObject*);
176     ShouldInterruptScriptFunctionPtr shouldInterruptScript;
177
178     typedef RuntimeFlags (*JavaScriptRuntimeFlagsFunctionPtr)(const JSGlobalObject*);
179     JavaScriptRuntimeFlagsFunctionPtr javaScriptRuntimeFlags;
180
181     typedef void (*QueueTaskToEventLoopFunctionPtr)(JSGlobalObject&, Ref<Microtask>&&);
182     QueueTaskToEventLoopFunctionPtr queueTaskToEventLoop;
183
184     typedef bool (*ShouldInterruptScriptBeforeTimeoutPtr)(const JSGlobalObject*);
185     ShouldInterruptScriptBeforeTimeoutPtr shouldInterruptScriptBeforeTimeout;
186
187     typedef JSInternalPromise* (*ModuleLoaderImportModulePtr)(JSGlobalObject*, ExecState*, JSModuleLoader*, JSString*, const SourceOrigin&);
188     ModuleLoaderImportModulePtr moduleLoaderImportModule;
189
190     typedef JSInternalPromise* (*ModuleLoaderResolvePtr)(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
191     ModuleLoaderResolvePtr moduleLoaderResolve;
192
193     typedef JSInternalPromise* (*ModuleLoaderFetchPtr)(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue);
194     ModuleLoaderFetchPtr moduleLoaderFetch;
195
196     typedef JSInternalPromise* (*ModuleLoaderInstantiatePtr)(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
197     ModuleLoaderInstantiatePtr moduleLoaderInstantiate;
198
199     typedef JSValue (*ModuleLoaderEvaluatePtr)(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
200     ModuleLoaderEvaluatePtr moduleLoaderEvaluate;
201
202     typedef void (*PromiseRejectionTrackerPtr)(JSGlobalObject*, ExecState*, JSPromise*, JSPromiseRejectionOperation);
203     PromiseRejectionTrackerPtr promiseRejectionTracker;
204
205     typedef String (*DefaultLanguageFunctionPtr)();
206     DefaultLanguageFunctionPtr defaultLanguage;
207 };
208
209 class JSGlobalObject : public JSSegmentedVariableObject {
210 private:
211     typedef HashSet<RefPtr<OpaqueJSWeakObjectMap>> WeakMapSet;
212     typedef HashMap<OpaqueJSClass*, std::unique_ptr<OpaqueJSClassContextData>> OpaqueJSClassDataMap;
213
214     struct JSGlobalObjectRareData {
215         WTF_MAKE_FAST_ALLOCATED;
216     public:
217         JSGlobalObjectRareData()
218             : profileGroup(0)
219         {
220         }
221
222         WeakMapSet weakMaps;
223         unsigned profileGroup;
224         
225         OpaqueJSClassDataMap opaqueJSClassData;
226     };
227
228 // Our hashtable code-generator tries to access these properties, so we make them public.
229 // However, we'd like it better if they could be protected.
230 public:
231     template<typename T> using Initializer = typename LazyProperty<JSGlobalObject, T>::Initializer;
232     
233     Register m_globalCallFrame[CallFrame::headerSizeInRegisters];
234
235     WriteBarrier<JSObject> m_globalThis;
236
237     WriteBarrier<JSGlobalLexicalEnvironment> m_globalLexicalEnvironment;
238     WriteBarrier<JSScope> m_globalScopeExtension;
239     WriteBarrier<JSObject> m_globalCallee;
240     WriteBarrier<RegExpConstructor> m_regExpConstructor;
241     WriteBarrier<ErrorConstructor> m_errorConstructor;
242     WriteBarrier<Structure> m_nativeErrorPrototypeStructure;
243     WriteBarrier<Structure> m_nativeErrorStructure;
244     LazyProperty<JSGlobalObject, NativeErrorConstructor> m_evalErrorConstructor;
245     WriteBarrier<NativeErrorConstructor> m_rangeErrorConstructor;
246     LazyProperty<JSGlobalObject, NativeErrorConstructor> m_referenceErrorConstructor;
247     LazyProperty<JSGlobalObject, NativeErrorConstructor> m_syntaxErrorConstructor;
248     WriteBarrier<NativeErrorConstructor> m_typeErrorConstructor;
249     LazyProperty<JSGlobalObject, NativeErrorConstructor> m_URIErrorConstructor;
250     WriteBarrier<ObjectConstructor> m_objectConstructor;
251     WriteBarrier<ArrayConstructor> m_arrayConstructor;
252     WriteBarrier<JSPromiseConstructor> m_promiseConstructor;
253     WriteBarrier<JSInternalPromiseConstructor> m_internalPromiseConstructor;
254
255     WriteBarrier<NullGetterFunction> m_nullGetterFunction;
256     WriteBarrier<NullSetterFunction> m_nullSetterFunction;
257
258     WriteBarrier<JSFunction> m_parseIntFunction;
259     WriteBarrier<JSFunction> m_parseFloatFunction;
260
261     WriteBarrier<JSFunction> m_evalFunction;
262     WriteBarrier<JSFunction> m_callFunction;
263     WriteBarrier<JSFunction> m_applyFunction;
264     WriteBarrier<JSFunction> m_throwTypeErrorFunction;
265     LazyProperty<JSGlobalObject, JSFunction> m_arrayProtoToStringFunction;
266     LazyProperty<JSGlobalObject, JSFunction> m_arrayProtoValuesFunction;
267     LazyProperty<JSGlobalObject, JSFunction> m_initializePromiseFunction;
268     LazyProperty<JSGlobalObject, JSFunction> m_iteratorProtocolFunction;
269     LazyProperty<JSGlobalObject, JSFunction> m_promiseResolveFunction;
270     WriteBarrier<JSFunction> m_objectProtoValueOfFunction;
271     WriteBarrier<JSFunction> m_newPromiseCapabilityFunction;
272     WriteBarrier<JSFunction> m_functionProtoHasInstanceSymbolFunction;
273     LazyProperty<JSGlobalObject, GetterSetter> m_throwTypeErrorGetterSetter;
274     WriteBarrier<JSObject> m_regExpProtoExec;
275     WriteBarrier<JSObject> m_regExpProtoSymbolReplace;
276     WriteBarrier<JSObject> m_regExpProtoGlobalGetter;
277     WriteBarrier<JSObject> m_regExpProtoUnicodeGetter;
278     WriteBarrier<GetterSetter> m_throwTypeErrorArgumentsCalleeAndCallerGetterSetter;
279
280     WriteBarrier<JSModuleLoader> m_moduleLoader;
281
282     WriteBarrier<ObjectPrototype> m_objectPrototype;
283     WriteBarrier<FunctionPrototype> m_functionPrototype;
284     WriteBarrier<ArrayPrototype> m_arrayPrototype;
285     WriteBarrier<RegExpPrototype> m_regExpPrototype;
286     WriteBarrier<IteratorPrototype> m_iteratorPrototype;
287     WriteBarrier<GeneratorFunctionPrototype> m_generatorFunctionPrototype;
288     WriteBarrier<GeneratorPrototype> m_generatorPrototype;
289     WriteBarrier<ModuleLoaderPrototype> m_moduleLoaderPrototype;
290
291     LazyProperty<JSGlobalObject, Structure> m_debuggerScopeStructure;
292     LazyProperty<JSGlobalObject, Structure> m_withScopeStructure;
293     WriteBarrier<Structure> m_strictEvalActivationStructure;
294     WriteBarrier<Structure> m_lexicalEnvironmentStructure;
295     LazyProperty<JSGlobalObject, Structure> m_moduleEnvironmentStructure;
296     WriteBarrier<Structure> m_directArgumentsStructure;
297     WriteBarrier<Structure> m_scopedArgumentsStructure;
298     WriteBarrier<Structure> m_clonedArgumentsStructure;
299
300     WriteBarrier<Structure> m_objectStructureForObjectConstructor;
301         
302     // Lists the actual structures used for having these particular indexing shapes.
303     WriteBarrier<Structure> m_originalArrayStructureForIndexingShape[NumberOfIndexingShapes];
304     // Lists the structures we should use during allocation for these particular indexing shapes.
305     // These structures will differ from the originals list above when we are having a bad time.
306     WriteBarrier<Structure> m_arrayStructureForIndexingShapeDuringAllocation[NumberOfIndexingShapes];
307
308     LazyProperty<JSGlobalObject, Structure> m_callbackConstructorStructure;
309     LazyProperty<JSGlobalObject, Structure> m_callbackFunctionStructure;
310     LazyProperty<JSGlobalObject, Structure> m_callbackObjectStructure;
311     WriteBarrier<Structure> m_propertyNameIteratorStructure;
312 #if JSC_OBJC_API_ENABLED
313     LazyProperty<JSGlobalObject, Structure> m_objcCallbackFunctionStructure;
314     LazyProperty<JSGlobalObject, Structure> m_objcWrapperObjectStructure;
315 #endif
316     LazyProperty<JSGlobalObject, Structure> m_nullPrototypeObjectStructure;
317     WriteBarrier<Structure> m_calleeStructure;
318     WriteBarrier<Structure> m_functionStructure;
319     LazyProperty<JSGlobalObject, Structure> m_boundFunctionStructure;
320     LazyProperty<JSGlobalObject, Structure> m_customGetterSetterFunctionStructure;
321     WriteBarrier<Structure> m_getterSetterStructure;
322     LazyProperty<JSGlobalObject, Structure> m_nativeStdFunctionStructure;
323     LazyProperty<JSGlobalObject, Structure> m_namedFunctionStructure;
324     PropertyOffset m_functionNameOffset;
325     WriteBarrier<Structure> m_privateNameStructure;
326     WriteBarrier<Structure> m_regExpStructure;
327     WriteBarrier<AsyncFunctionPrototype> m_asyncFunctionPrototype;
328     WriteBarrier<Structure> m_asyncFunctionStructure;
329     WriteBarrier<Structure> m_generatorFunctionStructure;
330     WriteBarrier<Structure> m_dollarVMStructure;
331     WriteBarrier<Structure> m_iteratorResultObjectStructure;
332     WriteBarrier<Structure> m_regExpMatchesArrayStructure;
333     WriteBarrier<Structure> m_moduleRecordStructure;
334     WriteBarrier<Structure> m_moduleNamespaceObjectStructure;
335     WriteBarrier<Structure> m_proxyObjectStructure;
336     WriteBarrier<Structure> m_callableProxyObjectStructure;
337     WriteBarrier<Structure> m_proxyRevokeStructure;
338     WriteBarrier<Structure> m_moduleLoaderStructure;
339     WriteBarrier<JSArrayBufferPrototype> m_arrayBufferPrototype;
340     WriteBarrier<Structure> m_arrayBufferStructure;
341     WriteBarrier<JSArrayBufferPrototype> m_sharedArrayBufferPrototype;
342     WriteBarrier<Structure> m_sharedArrayBufferStructure;
343
344 #define DEFINE_STORAGE_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName, prototypeBase) \
345     WriteBarrier<capitalName ## Prototype> m_ ## lowerName ## Prototype; \
346     WriteBarrier<Structure> m_ ## properName ## Structure;
347
348     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
349     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
350     
351 #if ENABLE(WEBASSEMBLY)
352     WriteBarrier<Structure> m_webAssemblyStructure;
353     WriteBarrier<Structure> m_webAssemblyModuleRecordStructure;
354     WriteBarrier<Structure> m_webAssemblyFunctionStructure;
355     WriteBarrier<Structure> m_webAssemblyWrapperFunctionStructure;
356     WriteBarrier<Structure> m_webAssemblyToJSCalleeStructure;
357     FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
358 #endif // ENABLE(WEBASSEMBLY)
359
360 #undef DEFINE_STORAGE_FOR_SIMPLE_TYPE
361
362 #define DEFINE_STORAGE_FOR_LAZY_TYPE(capitalName, lowerName, properName, instanceType, jsName, prototypeBase) \
363     LazyClassStructure m_ ## properName ## Structure;
364     FOR_EACH_LAZY_BUILTIN_TYPE(DEFINE_STORAGE_FOR_LAZY_TYPE)
365 #undef DEFINE_STORAGE_FOR_LAZY_TYPE
366
367     WriteBarrier<GetterSetter> m_speciesGetterSetter;
368     
369     LazyProperty<JSGlobalObject, JSTypedArrayViewPrototype> m_typedArrayProto;
370     LazyProperty<JSGlobalObject, JSTypedArrayViewConstructor> m_typedArraySuperConstructor;
371     
372 #define DECLARE_TYPED_ARRAY_TYPE_STRUCTURE(name) LazyClassStructure m_typedArray ## name;
373     FOR_EACH_TYPED_ARRAY_TYPE(DECLARE_TYPED_ARRAY_TYPE_STRUCTURE)
374 #undef DECLARE_TYPED_ARRAY_TYPE_STRUCTURE
375
376     JSCell* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
377     JSCell* m_linkTimeConstants[LinkTimeConstantCount];
378
379     String m_name;
380
381     Debugger* m_debugger;
382
383     VM& m_vm;
384
385 #if ENABLE(WEB_REPLAY)
386     Ref<InputCursor> m_inputCursor;
387 #endif
388
389 #if ENABLE(REMOTE_INSPECTOR)
390     std::unique_ptr<Inspector::JSGlobalObjectInspectorController> m_inspectorController;
391     std::unique_ptr<JSGlobalObjectDebuggable> m_inspectorDebuggable;
392 #endif
393
394 #if ENABLE(INTL)
395     HashSet<String> m_intlCollatorAvailableLocales;
396     HashSet<String> m_intlDateTimeFormatAvailableLocales;
397     HashSet<String> m_intlNumberFormatAvailableLocales;
398 #endif // ENABLE(INTL)
399
400     RefPtr<WatchpointSet> m_masqueradesAsUndefinedWatchpoint;
401     RefPtr<WatchpointSet> m_havingABadTimeWatchpoint;
402     RefPtr<WatchpointSet> m_varInjectionWatchpoint;
403
404     std::unique_ptr<JSGlobalObjectRareData> m_rareData;
405
406     WeakRandom m_weakRandom;
407
408     InlineWatchpointSet& arrayIteratorProtocolWatchpoint() { return m_arrayIteratorProtocolWatchpoint; }
409     InlineWatchpointSet& mapIteratorProtocolWatchpoint() { return m_mapIteratorProtocolWatchpoint; }
410     InlineWatchpointSet& setIteratorProtocolWatchpoint() { return m_setIteratorProtocolWatchpoint; }
411     InlineWatchpointSet& mapSetWatchpoint() { return m_mapSetWatchpoint; }
412     InlineWatchpointSet& setAddWatchpoint() { return m_setAddWatchpoint; }
413     InlineWatchpointSet& arraySpeciesWatchpoint() { return m_arraySpeciesWatchpoint; }
414     // If this hasn't been invalidated, it means the array iterator protocol
415     // is not observable to user code yet.
416     InlineWatchpointSet m_arrayIteratorProtocolWatchpoint;
417     InlineWatchpointSet m_mapIteratorProtocolWatchpoint;
418     InlineWatchpointSet m_setIteratorProtocolWatchpoint;
419     InlineWatchpointSet m_mapSetWatchpoint;
420     InlineWatchpointSet m_setAddWatchpoint;
421     InlineWatchpointSet m_arraySpeciesWatchpoint;
422     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_arrayPrototypeSymbolIteratorWatchpoint;
423     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_arrayIteratorPrototypeNext;
424     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_mapPrototypeSymbolIteratorWatchpoint;
425     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_mapIteratorPrototypeNextWatchpoint;
426     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_setPrototypeSymbolIteratorWatchpoint;
427     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_setIteratorPrototypeNextWatchpoint;
428     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_mapPrototypeSetWatchpoint;
429     std::unique_ptr<ObjectPropertyChangeAdaptiveWatchpoint<InlineWatchpointSet>> m_setPrototypeAddWatchpoint;
430
431     bool isArrayPrototypeIteratorProtocolFastAndNonObservable();
432     bool isMapPrototypeIteratorProtocolFastAndNonObservable();
433     bool isSetPrototypeIteratorProtocolFastAndNonObservable();
434     bool isMapPrototypeSetFastAndNonObservable();
435     bool isSetPrototypeAddFastAndNonObservable();
436
437     TemplateRegistry m_templateRegistry;
438
439     bool m_evalEnabled;
440     String m_evalDisabledErrorMessage;
441     RuntimeFlags m_runtimeFlags;
442     ConsoleClient* m_consoleClient;
443
444     static JS_EXPORTDATA const GlobalObjectMethodTable s_globalObjectMethodTable;
445     const GlobalObjectMethodTable* m_globalObjectMethodTable;
446
447     void createRareDataIfNeeded()
448     {
449         if (m_rareData)
450             return;
451         m_rareData = std::make_unique<JSGlobalObjectRareData>();
452     }
453         
454 public:
455     typedef JSSegmentedVariableObject Base;
456     static const unsigned StructureFlags = Base::StructureFlags | HasStaticPropertyTable | OverridesGetOwnPropertySlot | OverridesGetPropertyNames | OverridesToThis | IsImmutablePrototypeExoticObject;
457
458     JS_EXPORT_PRIVATE static JSGlobalObject* create(VM&, Structure*);
459
460     DECLARE_EXPORT_INFO;
461
462     bool hasDebugger() const;
463     bool hasInteractiveDebugger() const;
464     const RuntimeFlags& runtimeFlags() const { return m_runtimeFlags; }
465
466 protected:
467     JS_EXPORT_PRIVATE explicit JSGlobalObject(VM&, Structure*, const GlobalObjectMethodTable* = 0);
468
469     JS_EXPORT_PRIVATE void finishCreation(VM&);
470
471     JS_EXPORT_PRIVATE void finishCreation(VM&, JSObject*);
472
473     void addGlobalVar(const Identifier&);
474
475 public:
476     JS_EXPORT_PRIVATE ~JSGlobalObject();
477     JS_EXPORT_PRIVATE static void destroy(JSCell*);
478
479     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
480
481     JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
482     JS_EXPORT_PRIVATE static bool put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
483
484     JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, PropertyName, JSObject* getterFunc, unsigned attributes);
485     JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, PropertyName, JSObject* setterFunc, unsigned attributes);
486     JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
487
488     void addVar(ExecState* exec, const Identifier& propertyName)
489     {
490         if (!hasProperty(exec, propertyName))
491             addGlobalVar(propertyName);
492     }
493     void addFunction(ExecState*, const Identifier&);
494
495     JSScope* globalScope() { return m_globalLexicalEnvironment.get(); }
496     JSGlobalLexicalEnvironment* globalLexicalEnvironment() { return m_globalLexicalEnvironment.get(); }
497
498     JSScope* globalScopeExtension() { return m_globalScopeExtension.get(); }
499     void setGlobalScopeExtension(JSScope*);
500     void clearGlobalScopeExtension();
501
502     // The following accessors return pristine values, even if a script 
503     // replaces the global object's associated property.
504
505     GetterSetter* speciesGetterSetter() const { return m_speciesGetterSetter.get(); }
506
507     RegExpConstructor* regExpConstructor() const { return m_regExpConstructor.get(); }
508
509     ErrorConstructor* errorConstructor() const { return m_errorConstructor.get(); }
510     ArrayConstructor* arrayConstructor() const { return m_arrayConstructor.get(); }
511     ObjectConstructor* objectConstructor() const { return m_objectConstructor.get(); }
512     JSPromiseConstructor* promiseConstructor() const { return m_promiseConstructor.get(); }
513     JSInternalPromiseConstructor* internalPromiseConstructor() const { return m_internalPromiseConstructor.get(); }
514     NativeErrorConstructor* evalErrorConstructor() const { return m_evalErrorConstructor.get(this); }
515     NativeErrorConstructor* rangeErrorConstructor() const { return m_rangeErrorConstructor.get(); }
516     NativeErrorConstructor* referenceErrorConstructor() const { return m_referenceErrorConstructor.get(this); }
517     NativeErrorConstructor* syntaxErrorConstructor() const { return m_syntaxErrorConstructor.get(this); }
518     NativeErrorConstructor* typeErrorConstructor() const { return m_typeErrorConstructor.get(); }
519     NativeErrorConstructor* URIErrorConstructor() const { return m_URIErrorConstructor.get(this); }
520
521     NullGetterFunction* nullGetterFunction() const { return m_nullGetterFunction.get(); }
522     NullSetterFunction* nullSetterFunction() const { return m_nullSetterFunction.get(); }
523
524     JSFunction* parseIntFunction() const { return m_parseIntFunction.get(); }
525     JSFunction* parseFloatFunction() const { return m_parseFloatFunction.get(); }
526
527     JSFunction* evalFunction() const { return m_evalFunction.get(); }
528     JSFunction* callFunction() const { return m_callFunction.get(); }
529     JSFunction* applyFunction() const { return m_applyFunction.get(); }
530     JSFunction* throwTypeErrorFunction() const { return m_throwTypeErrorFunction.get(); }
531     JSFunction* arrayProtoToStringFunction() const { return m_arrayProtoToStringFunction.get(this); }
532     JSFunction* arrayProtoValuesFunction() const { return m_arrayProtoValuesFunction.get(this); }
533     JSFunction* initializePromiseFunction() const { return m_initializePromiseFunction.get(this); }
534     JSFunction* iteratorProtocolFunction() const { return m_iteratorProtocolFunction.get(this); }
535     JSFunction* promiseResolveFunction() const { return m_promiseResolveFunction.get(this); }
536     JSFunction* objectProtoValueOfFunction() const { return m_objectProtoValueOfFunction.get(); }
537     JSFunction* newPromiseCapabilityFunction() const { return m_newPromiseCapabilityFunction.get(); }
538     JSFunction* functionProtoHasInstanceSymbolFunction() const { return m_functionProtoHasInstanceSymbolFunction.get(); }
539     JSObject* regExpProtoExecFunction() const { return m_regExpProtoExec.get(); }
540     JSObject* regExpProtoSymbolReplaceFunction() const { return m_regExpProtoSymbolReplace.get(); }
541     JSObject* regExpProtoGlobalGetter() const { return m_regExpProtoGlobalGetter.get(); }
542     JSObject* regExpProtoUnicodeGetter() const { return m_regExpProtoUnicodeGetter.get(); }
543     GetterSetter* throwTypeErrorArgumentsCalleeAndCallerGetterSetter()
544     {
545         return m_throwTypeErrorArgumentsCalleeAndCallerGetterSetter.get();
546     }
547     
548     JSModuleLoader* moduleLoader() const { return m_moduleLoader.get(); }
549
550     ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
551     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
552     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
553     JSObject* booleanPrototype() const { return m_booleanObjectStructure.prototype(this); }
554     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
555     SymbolPrototype* symbolPrototype() const { return m_symbolPrototype.get(); }
556     JSObject* numberPrototype() const { return m_numberPrototype.get(); }
557     JSObject* datePrototype() const { return m_dateStructure.prototype(this); }
558     RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
559     ErrorPrototype* errorPrototype() const { return m_errorPrototype.get(); }
560     IteratorPrototype* iteratorPrototype() const { return m_iteratorPrototype.get(); }
561     GeneratorFunctionPrototype* generatorFunctionPrototype() const { return m_generatorFunctionPrototype.get(); }
562     GeneratorPrototype* generatorPrototype() const { return m_generatorPrototype.get(); }
563     AsyncFunctionPrototype* asyncFunctionPrototype() const { return m_asyncFunctionPrototype.get(); }
564     MapPrototype* mapPrototype() const { return m_mapPrototype.get(); }
565     // Workaround for the name conflict between JSCell::setPrototype.
566     SetPrototype* jsSetPrototype() const { return m_setPrototype.get(); }
567
568     Structure* debuggerScopeStructure() const { return m_debuggerScopeStructure.get(this); }
569     Structure* withScopeStructure() const { return m_withScopeStructure.get(this); }
570     Structure* strictEvalActivationStructure() const { return m_strictEvalActivationStructure.get(); }
571     Structure* activationStructure() const { return m_lexicalEnvironmentStructure.get(); }
572     Structure* moduleEnvironmentStructure() const { return m_moduleEnvironmentStructure.get(this); }
573     Structure* directArgumentsStructure() const { return m_directArgumentsStructure.get(); }
574     Structure* scopedArgumentsStructure() const { return m_scopedArgumentsStructure.get(); }
575     Structure* clonedArgumentsStructure() const { return m_clonedArgumentsStructure.get(); }
576     Structure* objectStructureForObjectConstructor() const { return m_objectStructureForObjectConstructor.get(); }
577     Structure* originalArrayStructureForIndexingType(IndexingType indexingType) const
578     {
579         ASSERT(indexingType & IsArray);
580         return m_originalArrayStructureForIndexingShape[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
581     }
582     Structure* arrayStructureForIndexingTypeDuringAllocation(IndexingType indexingType) const
583     {
584         ASSERT(indexingType & IsArray);
585         return m_arrayStructureForIndexingShapeDuringAllocation[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
586     }
587     Structure* arrayStructureForIndexingTypeDuringAllocation(ExecState* exec, IndexingType indexingType, JSValue newTarget) const
588     {
589         return InternalFunction::createSubclassStructure(exec, newTarget, arrayStructureForIndexingTypeDuringAllocation(indexingType));
590     }
591     Structure* arrayStructureForProfileDuringAllocation(ExecState* exec, ArrayAllocationProfile* profile, JSValue newTarget) const
592     {
593         return arrayStructureForIndexingTypeDuringAllocation(exec, ArrayAllocationProfile::selectIndexingTypeFor(profile), newTarget);
594     }
595         
596     bool isOriginalArrayStructure(Structure* structure)
597     {
598         return originalArrayStructureForIndexingType(structure->indexingType() | IsArray) == structure;
599     }
600         
601     Structure* booleanObjectStructure() const { return m_booleanObjectStructure.get(this); }
602     Structure* callbackConstructorStructure() const { return m_callbackConstructorStructure.get(this); }
603     Structure* callbackFunctionStructure() const { return m_callbackFunctionStructure.get(this); }
604     Structure* callbackObjectStructure() const { return m_callbackObjectStructure.get(this); }
605     Structure* propertyNameIteratorStructure() const { return m_propertyNameIteratorStructure.get(); }
606 #if JSC_OBJC_API_ENABLED
607     Structure* objcCallbackFunctionStructure() const { return m_objcCallbackFunctionStructure.get(this); }
608     Structure* objcWrapperObjectStructure() const { return m_objcWrapperObjectStructure.get(this); }
609 #endif
610     Structure* dateStructure() const { return m_dateStructure.get(this); }
611     Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(this); }
612     Structure* errorStructure() const { return m_errorStructure.get(); }
613     Structure* calleeStructure() const { return m_calleeStructure.get(); }
614     Structure* functionStructure() const { return m_functionStructure.get(); }
615     Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(this); }
616     Structure* customGetterSetterFunctionStructure() const { return m_customGetterSetterFunctionStructure.get(this); }
617     Structure* getterSetterStructure() const { return m_getterSetterStructure.get(); }
618     Structure* nativeStdFunctionStructure() const { return m_nativeStdFunctionStructure.get(this); }
619     Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(this); }
620     PropertyOffset functionNameOffset() const { return m_functionNameOffset; }
621     Structure* numberObjectStructure() const { return m_numberObjectStructure.get(); }
622     Structure* privateNameStructure() const { return m_privateNameStructure.get(); }
623     Structure* mapStructure() const { return m_mapStructure.get(); }
624     Structure* regExpStructure() const { return m_regExpStructure.get(); }
625     Structure* generatorFunctionStructure() const { return m_generatorFunctionStructure.get(); }
626     Structure* asyncFunctionStructure() const { return m_asyncFunctionStructure.get(); }
627     Structure* setStructure() const { return m_setStructure.get(); }
628     Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
629     Structure* symbolObjectStructure() const { return m_symbolObjectStructure.get(); }
630     Structure* iteratorResultObjectStructure() const { return m_iteratorResultObjectStructure.get(); }
631     Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
632     Structure* moduleRecordStructure() const { return m_moduleRecordStructure.get(); }
633     Structure* moduleNamespaceObjectStructure() const { return m_moduleNamespaceObjectStructure.get(); }
634     Structure* proxyObjectStructure() const { return m_proxyObjectStructure.get(); }
635     Structure* callableProxyObjectStructure() const { return m_callableProxyObjectStructure.get(); }
636     Structure* proxyRevokeStructure() const { return m_proxyRevokeStructure.get(); }
637     Structure* moduleLoaderStructure() const { return m_moduleLoaderStructure.get(); }
638     Structure* restParameterStructure() const { return arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous); }
639 #if ENABLE(WEBASSEMBLY)
640     Structure* webAssemblyModuleRecordStructure() const { return m_webAssemblyModuleRecordStructure.get(); }
641     Structure* webAssemblyFunctionStructure() const { return m_webAssemblyFunctionStructure.get(); }
642     Structure* webAssemblyWrapperFunctionStructure() const { return m_webAssemblyWrapperFunctionStructure.get(); }
643     Structure* webAssemblyToJSCalleeStructure() const { return m_webAssemblyToJSCalleeStructure.get(); }
644 #endif // ENABLE(WEBASSEMBLY)
645
646     JS_EXPORT_PRIVATE void setRemoteDebuggingEnabled(bool);
647     JS_EXPORT_PRIVATE bool remoteDebuggingEnabled() const;
648
649 #if ENABLE(WEB_REPLAY)
650     JS_EXPORT_PRIVATE void setInputCursor(Ref<InputCursor>&&);
651     InputCursor& inputCursor() const { return m_inputCursor.get(); }
652 #endif
653
654 #if ENABLE(REMOTE_INSPECTOR)
655     Inspector::JSGlobalObjectInspectorController& inspectorController() const { return *m_inspectorController.get(); }
656     JSGlobalObjectDebuggable& inspectorDebuggable() { return *m_inspectorDebuggable.get(); }
657 #endif
658
659 #if ENABLE(INTL)
660     const HashSet<String>& intlCollatorAvailableLocales();
661     const HashSet<String>& intlDateTimeFormatAvailableLocales();
662     const HashSet<String>& intlNumberFormatAvailableLocales();
663 #endif // ENABLE(INTL)
664
665     void setConsoleClient(ConsoleClient* consoleClient) { m_consoleClient = consoleClient; }
666     ConsoleClient* consoleClient() const { return m_consoleClient; }
667
668     void setName(const String&);
669     const String& name() const { return m_name; }
670
671     JSArrayBufferPrototype* arrayBufferPrototype(ArrayBufferSharingMode sharingMode) const
672     {
673         switch (sharingMode) {
674         case ArrayBufferSharingMode::Default:
675             return m_arrayBufferPrototype.get();
676         case ArrayBufferSharingMode::Shared:
677             return m_sharedArrayBufferPrototype.get();
678         }
679     }
680     Structure* arrayBufferStructure(ArrayBufferSharingMode sharingMode) const
681     {
682         switch (sharingMode) {
683         case ArrayBufferSharingMode::Default:
684             return m_arrayBufferStructure.get();
685         case ArrayBufferSharingMode::Shared:
686             return m_sharedArrayBufferStructure.get();
687         }
688         RELEASE_ASSERT_NOT_REACHED();
689         return nullptr;
690     }
691
692 #define DEFINE_ACCESSORS_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName, prototypeBase) \
693     Structure* properName ## Structure() { return m_ ## properName ## Structure.get(); }
694
695     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
696     FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
697     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
698
699 #undef DEFINE_ACCESSORS_FOR_SIMPLE_TYPE
700
701 #define DEFINE_ACCESSORS_FOR_LAZY_TYPE(capitalName, lowerName, properName, instanceType, jsName, prototypeBase) \
702     Structure* properName ## Structure() { return m_ ## properName ## Structure.get(this); }
703
704     FOR_EACH_LAZY_BUILTIN_TYPE(DEFINE_ACCESSORS_FOR_LAZY_TYPE)
705
706 #undef DEFINE_ACCESSORS_FOR_LAZY_TYPE
707
708     LazyClassStructure& lazyTypedArrayStructure(TypedArrayType type)
709     {
710         switch (type) {
711         case NotTypedArray:
712             RELEASE_ASSERT_NOT_REACHED();
713             return m_typedArrayInt8;
714 #define TYPED_ARRAY_TYPE_CASE(name) case Type ## name: return m_typedArray ## name;
715             FOR_EACH_TYPED_ARRAY_TYPE(TYPED_ARRAY_TYPE_CASE)
716 #undef TYPED_ARRAY_TYPE_CASE
717         }
718         RELEASE_ASSERT_NOT_REACHED();
719         return m_typedArrayInt8;
720     }
721     const LazyClassStructure& lazyTypedArrayStructure(TypedArrayType type) const
722     {
723         return const_cast<const LazyClassStructure&>(const_cast<JSGlobalObject*>(this)->lazyTypedArrayStructure(type));
724     }
725     
726     Structure* typedArrayStructure(TypedArrayType type) const
727     {
728         return lazyTypedArrayStructure(type).get(this);
729     }
730     Structure* typedArrayStructureConcurrently(TypedArrayType type) const
731     {
732         return lazyTypedArrayStructure(type).getConcurrently();
733     }
734     bool isOriginalTypedArrayStructure(Structure* structure)
735     {
736         TypedArrayType type = structure->classInfo()->typedArrayStorageType;
737         if (type == NotTypedArray)
738             return false;
739         return typedArrayStructureConcurrently(type) == structure;
740     }
741
742     JSObject* typedArrayConstructor(TypedArrayType type) const
743     {
744         return lazyTypedArrayStructure(type).constructor(this);
745     }
746
747     JSCell* actualPointerFor(Special::Pointer pointer)
748     {
749         ASSERT(pointer < Special::TableSize);
750         return m_specialPointers[pointer];
751     }
752     JSCell* jsCellForLinkTimeConstant(LinkTimeConstant type)
753     {
754         unsigned index = static_cast<unsigned>(type);
755         ASSERT(index < LinkTimeConstantCount);
756         return m_linkTimeConstants[index];
757     }
758
759     WatchpointSet* masqueradesAsUndefinedWatchpoint() { return m_masqueradesAsUndefinedWatchpoint.get(); }
760     WatchpointSet* havingABadTimeWatchpoint() { return m_havingABadTimeWatchpoint.get(); }
761     WatchpointSet* varInjectionWatchpoint() { return m_varInjectionWatchpoint.get(); }
762         
763     bool isHavingABadTime() const
764     {
765         return m_havingABadTimeWatchpoint->hasBeenInvalidated();
766     }
767         
768     void haveABadTime(VM&);
769         
770     bool objectPrototypeIsSane();
771     bool arrayPrototypeChainIsSane();
772     bool stringPrototypeChainIsSane();
773
774     void setProfileGroup(unsigned value) { createRareDataIfNeeded(); m_rareData->profileGroup = value; }
775     unsigned profileGroup() const
776     { 
777         if (!m_rareData)
778             return 0;
779         return m_rareData->profileGroup;
780     }
781
782     Debugger* debugger() const { return m_debugger; }
783     void setDebugger(Debugger* debugger) { m_debugger = debugger; }
784
785     const GlobalObjectMethodTable* globalObjectMethodTable() const { return m_globalObjectMethodTable; }
786
787     static bool supportsRichSourceInfo(const JSGlobalObject*) { return true; }
788
789     JS_EXPORT_PRIVATE ExecState* globalExec();
790
791     static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
792     static bool shouldInterruptScriptBeforeTimeout(const JSGlobalObject*) { return false; }
793     static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags(); }
794
795     void queueMicrotask(Ref<Microtask>&&);
796
797     bool evalEnabled() const { return m_evalEnabled; }
798     const String& evalDisabledErrorMessage() const { return m_evalDisabledErrorMessage; }
799     void setEvalEnabled(bool enabled, const String& errorMessage = String())
800     {
801         m_evalEnabled = enabled;
802         m_evalDisabledErrorMessage = errorMessage;
803     }
804
805     void resetPrototype(VM&, JSValue prototype);
806
807     VM& vm() const { return m_vm; }
808     JSObject* globalThis() const;
809
810     static Structure* createStructure(VM& vm, JSValue prototype)
811     {
812         Structure* result = Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
813         result->setTransitionWatchpointIsLikelyToBeFired(true);
814         return result;
815     }
816
817     void registerWeakMap(OpaqueJSWeakObjectMap* map)
818     {
819         createRareDataIfNeeded();
820         m_rareData->weakMaps.add(map);
821     }
822
823     void unregisterWeakMap(OpaqueJSWeakObjectMap* map)
824     {
825         if (m_rareData)
826             m_rareData->weakMaps.remove(map);
827     }
828
829     OpaqueJSClassDataMap& opaqueJSClassData()
830     {
831         createRareDataIfNeeded();
832         return m_rareData->opaqueJSClassData;
833     }
834
835     TemplateRegistry& templateRegistry() { return m_templateRegistry; }
836
837     static ptrdiff_t weakRandomOffset() { return OBJECT_OFFSETOF(JSGlobalObject, m_weakRandom); }
838     double weakRandomNumber() { return m_weakRandom.get(); }
839     unsigned weakRandomInteger() { return m_weakRandom.getUint32(); }
840     WeakRandom& weakRandom() { return m_weakRandom; }
841
842     bool needsSiteSpecificQuirks() const { return m_needsSiteSpecificQuirks; }
843
844 #if JSC_OBJC_API_ENABLED
845     JSWrapperMap* wrapperMap() const { return m_wrapperMap.get(); }
846     void setWrapperMap(JSWrapperMap* map) { m_wrapperMap = map; }
847 #endif
848
849 protected:
850     struct GlobalPropertyInfo {
851         GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
852             : identifier(i)
853             , value(v)
854             , attributes(a)
855         {
856         }
857
858         const Identifier identifier;
859         JSValue value;
860         unsigned attributes;
861     };
862     JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
863
864     JS_EXPORT_PRIVATE static JSC::JSValue toThis(JSC::JSCell*, JSC::ExecState*, ECMAMode);
865
866     void setNeedsSiteSpecificQuirks(bool needQuirks) { m_needsSiteSpecificQuirks = needQuirks; }
867
868 private:
869     friend class LLIntOffsetsExtractor;
870
871     JS_EXPORT_PRIVATE void setGlobalThis(VM&, JSObject* globalThis);
872
873     JS_EXPORT_PRIVATE void init(VM&);
874
875     JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
876
877     bool m_needsSiteSpecificQuirks { false };
878 #if JSC_OBJC_API_ENABLED
879     RetainPtr<JSWrapperMap> m_wrapperMap;
880 #endif
881 };
882
883 JSGlobalObject* asGlobalObject(JSValue);
884
885 inline JSGlobalObject* asGlobalObject(JSValue value)
886 {
887     ASSERT(asObject(value)->isGlobalObject());
888     return jsCast<JSGlobalObject*>(asObject(value));
889 }
890
891 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, unsigned initialLength = 0, JSValue newTarget = JSValue())
892 {
893     VM& vm = globalObject->vm();
894     auto scope = DECLARE_THROW_SCOPE(vm);
895     Structure* structure;
896     if (initialLength >= MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH)
897         structure = globalObject->arrayStructureForIndexingTypeDuringAllocation(exec, ArrayWithArrayStorage, newTarget);
898     else
899         structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
900     RETURN_IF_EXCEPTION(scope, nullptr);
901
902     JSArray* result = JSArray::tryCreate(vm, structure, initialLength);
903     if (UNLIKELY(!result)) {
904         throwOutOfMemoryError(exec, scope);
905         return nullptr;
906     }
907     return ArrayAllocationProfile::updateLastAllocationFor(profile, result);
908 }
909
910 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, unsigned initialLength = 0, JSValue newTarget = JSValue())
911 {
912     return constructEmptyArray(exec, profile, exec->lexicalGlobalObject(), initialLength, newTarget);
913 }
914  
915 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const ArgList& values, JSValue newTarget = JSValue())
916 {
917     VM& vm = globalObject->vm();
918     auto scope = DECLARE_THROW_SCOPE(vm);
919     Structure* structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
920     RETURN_IF_EXCEPTION(scope, nullptr);
921     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, structure, values));
922 }
923
924 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const ArgList& values, JSValue newTarget = JSValue())
925 {
926     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, newTarget);
927 }
928
929 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
930 {
931     VM& vm = globalObject->vm();
932     auto scope = DECLARE_THROW_SCOPE(vm);
933     Structure* structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
934     RETURN_IF_EXCEPTION(scope, nullptr);
935     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, structure, values, length));
936 }
937
938 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
939 {
940     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, length, newTarget);
941 }
942
943 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
944 {
945     VM& vm = globalObject->vm();
946     auto scope = DECLARE_THROW_SCOPE(vm);
947     Structure* structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
948     RETURN_IF_EXCEPTION(scope, nullptr);
949     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArrayNegativeIndexed(exec, structure, values, length));
950 }
951
952 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
953 {
954     return constructArrayNegativeIndexed(exec, profile, exec->lexicalGlobalObject(), values, length, newTarget);
955 }
956
957 inline JSObject* ExecState::globalThisValue() const
958 {
959     return lexicalGlobalObject()->globalThis();
960 }
961
962 inline JSObject* JSScope::globalThis()
963
964     return globalObject()->globalThis();
965 }
966
967 inline JSObject* JSGlobalObject::globalThis() const
968
969     return m_globalThis.get();
970 }
971
972 } // namespace JSC