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