[INTL] Implement supportedLocalesOf on Intl Constructors
[WebKit.git] / Source / JavaScriptCore / runtime / JSGlobalObject.h
1 /*
2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  *  Copyright (C) 2007, 2008, 2009, 2014, 2015 Apple Inc. All rights reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Library General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Library General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Library General Public License
16  *  along with this library; see the file COPYING.LIB.  If not, write to
17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  *  Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #ifndef JSGlobalObject_h
23 #define JSGlobalObject_h
24
25 #include "ArrayAllocationProfile.h"
26 #include "JSArray.h"
27 #include "JSArrayBufferPrototype.h"
28 #include "JSClassRef.h"
29 #include "JSGlobalLexicalEnvironment.h"
30 #include "JSProxy.h"
31 #include "JSSegmentedVariableObject.h"
32 #include "JSWeakObjectMapRefInternal.h"
33 #include "NumberPrototype.h"
34 #include "RuntimeFlags.h"
35 #include "SpecialPointer.h"
36 #include "StringPrototype.h"
37 #include "StructureChain.h"
38 #include "StructureRareDataInlines.h"
39 #include "SymbolPrototype.h"
40 #include "TemplateRegistry.h"
41 #include "VM.h"
42 #include "VariableEnvironment.h"
43 #include "Watchpoint.h"
44 #include <JavaScriptCore/JSBase.h>
45 #include <array>
46 #include <wtf/HashSet.h>
47 #include <wtf/PassRefPtr.h>
48 #include <wtf/RandomNumber.h>
49
50 struct OpaqueJSClass;
51 struct OpaqueJSClassContextData;
52
53 namespace Inspector {
54 class JSGlobalObjectInspectorController;
55 }
56
57 namespace JSC {
58
59 class ArrayPrototype;
60 class BooleanPrototype;
61 class ConsoleClient;
62 class Debugger;
63 class ErrorConstructor;
64 class ErrorPrototype;
65 class EvalCodeBlock;
66 class EvalExecutable;
67 class FunctionCodeBlock;
68 class FunctionExecutable;
69 class FunctionPrototype;
70 class GetterSetter;
71 class GlobalCodeBlock;
72 class InputCursor;
73 class JSGlobalObjectDebuggable;
74 class JSPromise;
75 class JSPromiseConstructor;
76 class JSPromisePrototype;
77 class JSInternalPromise;
78 class JSStack;
79 class LLIntOffsetsExtractor;
80 class Microtask;
81 class ModuleLoaderObject;
82 class ModuleProgramExecutable;
83 class NativeErrorConstructor;
84 class ObjectConstructor;
85 class ProgramCodeBlock;
86 class ProgramExecutable;
87 class RegExpConstructor;
88 class RegExpPrototype;
89 class SourceCode;
90 class UnlinkedModuleProgramCodeBlock;
91 class NullGetterFunction;
92 class NullSetterFunction;
93 enum class ThisTDZMode;
94 struct ActivationStackNode;
95 struct HashTable;
96
97 #define DEFINE_STANDARD_BUILTIN(macro, upperName, lowerName) macro(upperName, lowerName, lowerName, JS ## upperName, upperName)
98
99 #define FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
100     macro(Set, set, set, JSSet, Set) \
101     macro(Map, map, map, JSMap, Map) \
102     macro(Date, date, date, DateInstance, Date) \
103     macro(String, string, stringObject, StringObject, String) \
104     macro(Symbol, symbol, symbolObject, SymbolObject, Symbol) \
105     macro(Boolean, boolean, booleanObject, BooleanObject, Boolean) \
106     macro(Number, number, numberObject, NumberObject, Number) \
107     macro(Error, error, error, ErrorInstance, Error) \
108     macro(JSPromise, promise, promise, JSPromise, Promise) \
109     macro(JSArrayBuffer, arrayBuffer, arrayBuffer, JSArrayBuffer, ArrayBuffer) \
110     DEFINE_STANDARD_BUILTIN(macro, WeakMap, weakMap) \
111     DEFINE_STANDARD_BUILTIN(macro, WeakSet, weakSet) \
112
113 #define FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(macro) \
114     DEFINE_STANDARD_BUILTIN(macro, ArrayIterator, arrayIterator) \
115     DEFINE_STANDARD_BUILTIN(macro, MapIterator, mapIterator) \
116     DEFINE_STANDARD_BUILTIN(macro, SetIterator, setIterator) \
117     DEFINE_STANDARD_BUILTIN(macro, StringIterator, stringIterator) \
118
119 #define FOR_EACH_BUILTIN_ITERATOR_TYPE(macro) \
120     DEFINE_STANDARD_BUILTIN(macro, Iterator, iterator) \
121     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(macro) \
122
123 #define FOR_EACH_SIMPLE_BUILTIN_TYPE(macro) \
124     FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
125     macro(JSInternalPromise, internalPromise, internalPromise, JSInternalPromise, InternalPromise) \
126
127 #define DECLARE_SIMPLE_BUILTIN_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
128     class JS ## capitalName; \
129     class capitalName ## Prototype; \
130     class capitalName ## Constructor;
131
132 class IteratorPrototype;
133 FOR_EACH_SIMPLE_BUILTIN_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
134 FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
135
136 #undef DECLARE_SIMPLE_BUILTIN_TYPE
137
138 typedef Vector<ExecState*, 16> ExecStateStack;
139
140 struct GlobalObjectMethodTable {
141     typedef bool (*AllowsAccessFromFunctionPtr)(const JSGlobalObject*, ExecState*);
142     AllowsAccessFromFunctionPtr allowsAccessFrom;
143
144     typedef bool (*SupportsProfilingFunctionPtr)(const JSGlobalObject*); 
145     SupportsProfilingFunctionPtr supportsProfiling;
146
147     typedef bool (*SupportsRichSourceInfoFunctionPtr)(const JSGlobalObject*);
148     SupportsRichSourceInfoFunctionPtr supportsRichSourceInfo;
149
150     typedef bool (*ShouldInterruptScriptFunctionPtr)(const JSGlobalObject*);
151     ShouldInterruptScriptFunctionPtr shouldInterruptScript;
152
153     typedef RuntimeFlags (*JavaScriptRuntimeFlagsFunctionPtr)(const JSGlobalObject*);
154     JavaScriptRuntimeFlagsFunctionPtr javaScriptRuntimeFlags;
155
156     typedef void (*QueueTaskToEventLoopFunctionPtr)(const JSGlobalObject*, PassRefPtr<Microtask>);
157     QueueTaskToEventLoopFunctionPtr queueTaskToEventLoop;
158
159     typedef bool (*ShouldInterruptScriptBeforeTimeoutPtr)(const JSGlobalObject*);
160     ShouldInterruptScriptBeforeTimeoutPtr shouldInterruptScriptBeforeTimeout;
161
162     typedef JSInternalPromise* (*ModuleLoaderResolvePtr)(JSGlobalObject*, ExecState*, JSValue, JSValue);
163     ModuleLoaderResolvePtr moduleLoaderResolve;
164
165     typedef JSInternalPromise* (*ModuleLoaderFetchPtr)(JSGlobalObject*, ExecState*, JSValue);
166     ModuleLoaderFetchPtr moduleLoaderFetch;
167
168     typedef JSInternalPromise* (*ModuleLoaderTranslatePtr)(JSGlobalObject*, ExecState*, JSValue, JSValue);
169     ModuleLoaderTranslatePtr moduleLoaderTranslate;
170
171     typedef JSInternalPromise* (*ModuleLoaderInstantiatePtr)(JSGlobalObject*, ExecState*, JSValue, JSValue);
172     ModuleLoaderInstantiatePtr moduleLoaderInstantiate;
173 };
174
175 class JSGlobalObject : public JSSegmentedVariableObject {
176 private:
177     typedef HashSet<RefPtr<OpaqueJSWeakObjectMap>> WeakMapSet;
178     typedef HashMap<OpaqueJSClass*, std::unique_ptr<OpaqueJSClassContextData>> OpaqueJSClassDataMap;
179
180     struct JSGlobalObjectRareData {
181         JSGlobalObjectRareData()
182             : profileGroup(0)
183         {
184         }
185
186         WeakMapSet weakMaps;
187         unsigned profileGroup;
188         
189         OpaqueJSClassDataMap opaqueJSClassData;
190     };
191
192 protected:
193     Register m_globalCallFrame[JSStack::CallFrameHeaderSize];
194
195     WriteBarrier<JSObject> m_globalThis;
196
197     WriteBarrier<JSGlobalLexicalEnvironment> m_globalLexicalEnvironment;
198     WriteBarrier<JSObject> m_globalCallee;
199     WriteBarrier<RegExpConstructor> m_regExpConstructor;
200     WriteBarrier<ErrorConstructor> m_errorConstructor;
201     WriteBarrier<NativeErrorConstructor> m_evalErrorConstructor;
202     WriteBarrier<NativeErrorConstructor> m_rangeErrorConstructor;
203     WriteBarrier<NativeErrorConstructor> m_referenceErrorConstructor;
204     WriteBarrier<NativeErrorConstructor> m_syntaxErrorConstructor;
205     WriteBarrier<NativeErrorConstructor> m_typeErrorConstructor;
206     WriteBarrier<NativeErrorConstructor> m_URIErrorConstructor;
207     WriteBarrier<ObjectConstructor> m_objectConstructor;
208     WriteBarrier<JSPromiseConstructor> m_promiseConstructor;
209     WriteBarrier<JSInternalPromiseConstructor> m_internalPromiseConstructor;
210
211     WriteBarrier<NullGetterFunction> m_nullGetterFunction;
212     WriteBarrier<NullSetterFunction> m_nullSetterFunction;
213
214     WriteBarrier<JSFunction> m_parseIntFunction;
215
216     WriteBarrier<JSFunction> m_evalFunction;
217     WriteBarrier<JSFunction> m_callFunction;
218     WriteBarrier<JSFunction> m_applyFunction;
219     WriteBarrier<JSFunction> m_definePropertyFunction;
220     WriteBarrier<JSFunction> m_arrayProtoValuesFunction;
221     WriteBarrier<JSFunction> m_initializePromiseFunction;
222     WriteBarrier<JSFunction> m_newPromiseCapabilityFunction;
223     WriteBarrier<GetterSetter> m_throwTypeErrorGetterSetter;
224
225     WriteBarrier<ModuleLoaderObject> m_moduleLoader;
226
227     WriteBarrier<ObjectPrototype> m_objectPrototype;
228     WriteBarrier<FunctionPrototype> m_functionPrototype;
229     WriteBarrier<ArrayPrototype> m_arrayPrototype;
230     WriteBarrier<RegExpPrototype> m_regExpPrototype;
231     WriteBarrier<IteratorPrototype> m_iteratorPrototype;
232
233     WriteBarrier<Structure> m_debuggerScopeStructure;
234     WriteBarrier<Structure> m_withScopeStructure;
235     WriteBarrier<Structure> m_strictEvalActivationStructure;
236     WriteBarrier<Structure> m_lexicalEnvironmentStructure;
237     WriteBarrier<Structure> m_moduleEnvironmentStructure;
238     WriteBarrier<Structure> m_directArgumentsStructure;
239     WriteBarrier<Structure> m_scopedArgumentsStructure;
240     WriteBarrier<Structure> m_outOfBandArgumentsStructure;
241         
242     // Lists the actual structures used for having these particular indexing shapes.
243     WriteBarrier<Structure> m_originalArrayStructureForIndexingShape[NumberOfIndexingShapes];
244     // Lists the structures we should use during allocation for these particular indexing shapes.
245     WriteBarrier<Structure> m_arrayStructureForIndexingShapeDuringAllocation[NumberOfIndexingShapes];
246
247     WriteBarrier<Structure> m_callbackConstructorStructure;
248     WriteBarrier<Structure> m_callbackFunctionStructure;
249     WriteBarrier<Structure> m_callbackObjectStructure;
250     WriteBarrier<Structure> m_propertyNameIteratorStructure;
251 #if JSC_OBJC_API_ENABLED
252     WriteBarrier<Structure> m_objcCallbackFunctionStructure;
253     WriteBarrier<Structure> m_objcWrapperObjectStructure;
254 #endif
255     WriteBarrier<Structure> m_nullPrototypeObjectStructure;
256     WriteBarrier<Structure> m_calleeStructure;
257     WriteBarrier<Structure> m_functionStructure;
258     WriteBarrier<Structure> m_boundFunctionStructure;
259     WriteBarrier<Structure> m_arrowFunctionStructure;
260     WriteBarrier<Structure> m_nativeStdFunctionStructure;
261     WriteBarrier<Structure> m_namedFunctionStructure;
262     PropertyOffset m_functionNameOffset;
263     WriteBarrier<Structure> m_privateNameStructure;
264     WriteBarrier<Structure> m_regExpStructure;
265     WriteBarrier<Structure> m_consoleStructure;
266     WriteBarrier<Structure> m_dollarVMStructure;
267     WriteBarrier<Structure> m_internalFunctionStructure;
268     WriteBarrier<Structure> m_iteratorResultStructure;
269     WriteBarrier<Structure> m_regExpMatchesArrayStructure;
270     WriteBarrier<Structure> m_moduleRecordStructure;
271     WriteBarrier<Structure> m_moduleNamespaceObjectStructure;
272 #if ENABLE(WEBASSEMBLY)
273     WriteBarrier<Structure> m_wasmModuleStructure;
274 #endif
275
276 #define DEFINE_STORAGE_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
277     WriteBarrier<capitalName ## Prototype> m_ ## lowerName ## Prototype; \
278     WriteBarrier<Structure> m_ ## properName ## Structure;
279
280     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
281     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
282
283 #undef DEFINE_STORAGE_FOR_SIMPLE_TYPE
284
285     struct TypedArrayData {
286         WriteBarrier<JSObject> prototype;
287         WriteBarrier<Structure> structure;
288     };
289     
290     std::array<TypedArrayData, NUMBER_OF_TYPED_ARRAY_TYPES> m_typedArrays;
291
292     JSCell* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
293     JSCell* m_linkTimeConstants[LinkTimeConstantCount];
294
295     String m_name;
296
297     Debugger* m_debugger;
298
299     VM& m_vm;
300
301 #if ENABLE(WEB_REPLAY)
302     RefPtr<InputCursor> m_inputCursor;
303 #endif
304
305 #if ENABLE(REMOTE_INSPECTOR)
306     std::unique_ptr<Inspector::JSGlobalObjectInspectorController> m_inspectorController;
307     std::unique_ptr<JSGlobalObjectDebuggable> m_inspectorDebuggable;
308 #endif
309
310 #if ENABLE(INTL)
311     HashSet<String> m_intlCollatorAvailableLocales;
312     HashSet<String> m_intlDateTimeFormatAvailableLocales;
313     HashSet<String> m_intlNumberFormatAvailableLocales;
314 #endif // ENABLE(INTL)
315
316     RefPtr<WatchpointSet> m_masqueradesAsUndefinedWatchpoint;
317     RefPtr<WatchpointSet> m_havingABadTimeWatchpoint;
318     RefPtr<WatchpointSet> m_varInjectionWatchpoint;
319
320     std::unique_ptr<JSGlobalObjectRareData> m_rareData;
321
322     WeakRandom m_weakRandom;
323
324     TemplateRegistry m_templateRegistry;
325
326     bool m_evalEnabled;
327     String m_evalDisabledErrorMessage;
328     RuntimeFlags m_runtimeFlags;
329     ConsoleClient* m_consoleClient;
330
331     static JS_EXPORTDATA const GlobalObjectMethodTable s_globalObjectMethodTable;
332     const GlobalObjectMethodTable* m_globalObjectMethodTable;
333
334     void createRareDataIfNeeded()
335     {
336         if (m_rareData)
337             return;
338         m_rareData = std::make_unique<JSGlobalObjectRareData>();
339     }
340         
341 public:
342     typedef JSSegmentedVariableObject Base;
343     static const unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames;
344
345     static JSGlobalObject* create(VM& vm, Structure* structure)
346     {
347         JSGlobalObject* globalObject = new (NotNull, allocateCell<JSGlobalObject>(vm.heap)) JSGlobalObject(vm, structure);
348         globalObject->finishCreation(vm);
349         vm.heap.addFinalizer(globalObject, destroy);
350         return globalObject;
351     }
352
353     DECLARE_EXPORT_INFO;
354
355     bool hasDebugger() const { return m_debugger; }
356     bool hasProfiler() const { return globalObjectMethodTable()->supportsProfiling(this); }
357     const RuntimeFlags& runtimeFlags() const { return m_runtimeFlags; }
358
359 protected:
360     JS_EXPORT_PRIVATE explicit JSGlobalObject(VM&, Structure*, const GlobalObjectMethodTable* = 0);
361
362     void finishCreation(VM& vm)
363     {
364         Base::finishCreation(vm);
365         structure()->setGlobalObject(vm, this);
366         m_runtimeFlags = m_globalObjectMethodTable->javaScriptRuntimeFlags(this);
367         init(vm);
368         setGlobalThis(vm, JSProxy::create(vm, JSProxy::createStructure(vm, this, prototype(), PureForwardingProxyType), this));
369     }
370
371     void finishCreation(VM& vm, JSObject* thisValue)
372     {
373         Base::finishCreation(vm);
374         structure()->setGlobalObject(vm, this);
375         m_runtimeFlags = m_globalObjectMethodTable->javaScriptRuntimeFlags(this);
376         init(vm);
377         setGlobalThis(vm, thisValue);
378     }
379
380     void addGlobalVar(const Identifier&);
381
382 public:
383     JS_EXPORT_PRIVATE ~JSGlobalObject();
384     JS_EXPORT_PRIVATE static void destroy(JSCell*);
385     // We don't need a destructor because we use a finalizer instead.
386     static const bool needsDestruction = false;
387
388     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
389
390     JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
391     bool hasOwnPropertyForWrite(ExecState*, PropertyName);
392     JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
393
394     JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, PropertyName, JSObject* getterFunc, unsigned attributes);
395     JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, PropertyName, JSObject* setterFunc, unsigned attributes);
396     JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
397
398     void addVar(ExecState* exec, const Identifier& propertyName)
399     {
400         if (!hasProperty(exec, propertyName))
401             addGlobalVar(propertyName);
402     }
403     void addFunction(ExecState*, const Identifier&);
404
405     JSScope* globalScope() { return m_globalLexicalEnvironment.get(); }
406     JSGlobalLexicalEnvironment* globalLexicalEnvironment() { return m_globalLexicalEnvironment.get(); }
407
408     // The following accessors return pristine values, even if a script 
409     // replaces the global object's associated property.
410
411     RegExpConstructor* regExpConstructor() const { return m_regExpConstructor.get(); }
412
413     ErrorConstructor* errorConstructor() const { return m_errorConstructor.get(); }
414     ObjectConstructor* objectConstructor() const { return m_objectConstructor.get(); }
415     JSPromiseConstructor* promiseConstructor() const { return m_promiseConstructor.get(); }
416     JSInternalPromiseConstructor* internalPromiseConstructor() const { return m_internalPromiseConstructor.get(); }
417     NativeErrorConstructor* evalErrorConstructor() const { return m_evalErrorConstructor.get(); }
418     NativeErrorConstructor* rangeErrorConstructor() const { return m_rangeErrorConstructor.get(); }
419     NativeErrorConstructor* referenceErrorConstructor() const { return m_referenceErrorConstructor.get(); }
420     NativeErrorConstructor* syntaxErrorConstructor() const { return m_syntaxErrorConstructor.get(); }
421     NativeErrorConstructor* typeErrorConstructor() const { return m_typeErrorConstructor.get(); }
422     NativeErrorConstructor* URIErrorConstructor() const { return m_URIErrorConstructor.get(); }
423
424     NullGetterFunction* nullGetterFunction() const { return m_nullGetterFunction.get(); }
425     NullSetterFunction* nullSetterFunction() const { return m_nullSetterFunction.get(); }
426
427     JSFunction* parseIntFunction() const { return m_parseIntFunction.get(); }
428
429     JSFunction* evalFunction() const { return m_evalFunction.get(); }
430     JSFunction* callFunction() const { return m_callFunction.get(); }
431     JSFunction* applyFunction() const { return m_applyFunction.get(); }
432     JSFunction* definePropertyFunction() const { return m_definePropertyFunction.get(); }
433     JSFunction* arrayProtoValuesFunction() const { return m_arrayProtoValuesFunction.get(); }
434     JSFunction* initializePromiseFunction() const { return m_initializePromiseFunction.get(); }
435     JSFunction* newPromiseCapabilityFunction() const { return m_newPromiseCapabilityFunction.get(); }
436     GetterSetter* throwTypeErrorGetterSetter(VM& vm)
437     {
438         if (!m_throwTypeErrorGetterSetter)
439             createThrowTypeError(vm);
440         return m_throwTypeErrorGetterSetter.get();
441     }
442
443     ModuleLoaderObject* moduleLoader() const { return m_moduleLoader.get(); }
444
445     ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
446     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
447     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
448     BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
449     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
450     SymbolPrototype* symbolPrototype() const { return m_symbolPrototype.get(); }
451     NumberPrototype* numberPrototype() const { return m_numberPrototype.get(); }
452     DatePrototype* datePrototype() const { return m_datePrototype.get(); }
453     RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
454     ErrorPrototype* errorPrototype() const { return m_errorPrototype.get(); }
455     IteratorPrototype* iteratorPrototype() const { return m_iteratorPrototype.get(); }
456
457     Structure* debuggerScopeStructure() const { return m_debuggerScopeStructure.get(); }
458     Structure* withScopeStructure() const { return m_withScopeStructure.get(); }
459     Structure* strictEvalActivationStructure() const { return m_strictEvalActivationStructure.get(); }
460     Structure* activationStructure() const { return m_lexicalEnvironmentStructure.get(); }
461     Structure* moduleEnvironmentStructure() const { return m_moduleEnvironmentStructure.get(); }
462     Structure* directArgumentsStructure() const { return m_directArgumentsStructure.get(); }
463     Structure* scopedArgumentsStructure() const { return m_scopedArgumentsStructure.get(); }
464     Structure* outOfBandArgumentsStructure() const { return m_outOfBandArgumentsStructure.get(); }
465     Structure* originalArrayStructureForIndexingType(IndexingType indexingType) const
466     {
467         ASSERT(indexingType & IsArray);
468         return m_originalArrayStructureForIndexingShape[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
469     }
470     Structure* arrayStructureForIndexingTypeDuringAllocation(IndexingType indexingType) const
471     {
472         ASSERT(indexingType & IsArray);
473         return m_arrayStructureForIndexingShapeDuringAllocation[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
474     }
475     Structure* arrayStructureForProfileDuringAllocation(ArrayAllocationProfile* profile) const
476     {
477         return arrayStructureForIndexingTypeDuringAllocation(ArrayAllocationProfile::selectIndexingTypeFor(profile));
478     }
479         
480     bool isOriginalArrayStructure(Structure* structure)
481     {
482         return originalArrayStructureForIndexingType(structure->indexingType() | IsArray) == structure;
483     }
484         
485     Structure* booleanObjectStructure() const { return m_booleanObjectStructure.get(); }
486     Structure* callbackConstructorStructure() const { return m_callbackConstructorStructure.get(); }
487     Structure* callbackFunctionStructure() const { return m_callbackFunctionStructure.get(); }
488     Structure* callbackObjectStructure() const { return m_callbackObjectStructure.get(); }
489     Structure* propertyNameIteratorStructure() const { return m_propertyNameIteratorStructure.get(); }
490 #if JSC_OBJC_API_ENABLED
491     Structure* objcCallbackFunctionStructure() const { return m_objcCallbackFunctionStructure.get(); }
492     Structure* objcWrapperObjectStructure() const { return m_objcWrapperObjectStructure.get(); }
493 #endif
494     Structure* dateStructure() const { return m_dateStructure.get(); }
495     Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(); }
496     Structure* errorStructure() const { return m_errorStructure.get(); }
497     Structure* calleeStructure() const { return m_calleeStructure.get(); }
498     Structure* functionStructure() const { return m_functionStructure.get(); }
499     Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(); }
500     Structure* arrowFunctionStructure() const { return m_arrowFunctionStructure.get(); }
501     Structure* nativeStdFunctionStructure() const { return m_nativeStdFunctionStructure.get(); }
502     Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(); }
503     PropertyOffset functionNameOffset() const { return m_functionNameOffset; }
504     Structure* numberObjectStructure() const { return m_numberObjectStructure.get(); }
505     Structure* privateNameStructure() const { return m_privateNameStructure.get(); }
506     Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
507     Structure* mapStructure() const { return m_mapStructure.get(); }
508     Structure* regExpStructure() const { return m_regExpStructure.get(); }
509     Structure* setStructure() const { return m_setStructure.get(); }
510     Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
511     Structure* symbolObjectStructure() const { return m_symbolObjectStructure.get(); }
512     Structure* iteratorResultStructure() const { return m_iteratorResultStructure.get(); }
513     static ptrdiff_t iteratorResultStructureOffset() { return OBJECT_OFFSETOF(JSGlobalObject, m_iteratorResultStructure); }
514     Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
515     Structure* moduleRecordStructure() const { return m_moduleRecordStructure.get(); }
516     Structure* moduleNamespaceObjectStructure() const { return m_moduleNamespaceObjectStructure.get(); }
517 #if ENABLE(WEBASSEMBLY)
518     Structure* wasmModuleStructure() const { return m_wasmModuleStructure.get(); }
519 #endif
520
521     JS_EXPORT_PRIVATE void setRemoteDebuggingEnabled(bool);
522     JS_EXPORT_PRIVATE bool remoteDebuggingEnabled() const;
523
524 #if ENABLE(WEB_REPLAY)
525     JS_EXPORT_PRIVATE void setInputCursor(PassRefPtr<InputCursor>);
526     InputCursor& inputCursor() const { return *m_inputCursor; }
527 #endif
528
529 #if ENABLE(REMOTE_INSPECTOR)
530     Inspector::JSGlobalObjectInspectorController& inspectorController() const { return *m_inspectorController.get(); }
531     JSGlobalObjectDebuggable& inspectorDebuggable() { return *m_inspectorDebuggable.get(); }
532 #endif
533
534 #if ENABLE(INTL)
535     const HashSet<String>& intlCollatorAvailableLocales();
536     const HashSet<String>& intlDateTimeFormatAvailableLocales();
537     const HashSet<String>& intlNumberFormatAvailableLocales();
538 #endif // ENABLE(INTL)
539
540     void setConsoleClient(ConsoleClient* consoleClient) { m_consoleClient = consoleClient; }
541     ConsoleClient* consoleClient() const { return m_consoleClient; }
542
543     void setName(const String&);
544     const String& name() const { return m_name; }
545
546     JSArrayBufferPrototype* arrayBufferPrototype() const { return m_arrayBufferPrototype.get(); }
547
548 #define DEFINE_ACCESSORS_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
549     Structure* properName ## Structure() { return m_ ## properName ## Structure.get(); }
550
551     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
552     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
553
554 #undef DEFINE_ACCESSORS_FOR_SIMPLE_TYPE
555
556     Structure* typedArrayStructure(TypedArrayType type) const
557     {
558         return m_typedArrays[toIndex(type)].structure.get();
559     }
560     bool isOriginalTypedArrayStructure(Structure* structure)
561     {
562         TypedArrayType type = structure->classInfo()->typedArrayStorageType;
563         if (type == NotTypedArray)
564             return false;
565         return typedArrayStructure(type) == structure;
566     }
567
568     JSCell* actualPointerFor(Special::Pointer pointer)
569     {
570         ASSERT(pointer < Special::TableSize);
571         return m_specialPointers[pointer];
572     }
573     JSCell* jsCellForLinkTimeConstant(LinkTimeConstant type)
574     {
575         unsigned index = static_cast<unsigned>(type);
576         ASSERT(index < LinkTimeConstantCount);
577         return m_linkTimeConstants[index];
578     }
579
580     WatchpointSet* masqueradesAsUndefinedWatchpoint() { return m_masqueradesAsUndefinedWatchpoint.get(); }
581     WatchpointSet* havingABadTimeWatchpoint() { return m_havingABadTimeWatchpoint.get(); }
582     WatchpointSet* varInjectionWatchpoint() { return m_varInjectionWatchpoint.get(); }
583         
584     bool isHavingABadTime() const
585     {
586         return m_havingABadTimeWatchpoint->hasBeenInvalidated();
587     }
588         
589     void haveABadTime(VM&);
590         
591     bool objectPrototypeIsSane();
592     bool arrayPrototypeChainIsSane();
593     bool stringPrototypeChainIsSane();
594
595     void setProfileGroup(unsigned value) { createRareDataIfNeeded(); m_rareData->profileGroup = value; }
596     unsigned profileGroup() const
597     { 
598         if (!m_rareData)
599             return 0;
600         return m_rareData->profileGroup;
601     }
602
603     Debugger* debugger() const { return m_debugger; }
604     void setDebugger(Debugger* debugger) { m_debugger = debugger; }
605
606     const GlobalObjectMethodTable* globalObjectMethodTable() const { return m_globalObjectMethodTable; }
607
608     static bool allowsAccessFrom(const JSGlobalObject*, ExecState*) { return true; }
609     static bool supportsProfiling(const JSGlobalObject*) { return false; }
610     static bool supportsRichSourceInfo(const JSGlobalObject*) { return true; }
611
612     JS_EXPORT_PRIVATE ExecState* globalExec();
613
614     static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
615     static bool shouldInterruptScriptBeforeTimeout(const JSGlobalObject*) { return false; }
616     static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags(); }
617
618     void queueMicrotask(PassRefPtr<Microtask>);
619
620     bool evalEnabled() const { return m_evalEnabled; }
621     const String& evalDisabledErrorMessage() const { return m_evalDisabledErrorMessage; }
622     void setEvalEnabled(bool enabled, const String& errorMessage = String())
623     {
624         m_evalEnabled = enabled;
625         m_evalDisabledErrorMessage = errorMessage;
626     }
627
628     void resetPrototype(VM&, JSValue prototype);
629
630     VM& vm() const { return m_vm; }
631     JSObject* globalThis() const;
632
633     static Structure* createStructure(VM& vm, JSValue prototype)
634     {
635         Structure* result = Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
636         result->setTransitionWatchpointIsLikelyToBeFired(true);
637         return result;
638     }
639
640     void registerWeakMap(OpaqueJSWeakObjectMap* map)
641     {
642         createRareDataIfNeeded();
643         m_rareData->weakMaps.add(map);
644     }
645
646     void unregisterWeakMap(OpaqueJSWeakObjectMap* map)
647     {
648         if (m_rareData)
649             m_rareData->weakMaps.remove(map);
650     }
651
652     OpaqueJSClassDataMap& opaqueJSClassData()
653     {
654         createRareDataIfNeeded();
655         return m_rareData->opaqueJSClassData;
656     }
657
658     TemplateRegistry& templateRegistry() { return m_templateRegistry; }
659
660     double weakRandomNumber() { return m_weakRandom.get(); }
661     unsigned weakRandomInteger() { return m_weakRandom.getUint32(); }
662
663     UnlinkedProgramCodeBlock* createProgramCodeBlock(CallFrame*, ProgramExecutable*, JSObject** exception);
664     UnlinkedEvalCodeBlock* createEvalCodeBlock(CallFrame*, EvalExecutable*, ThisTDZMode, const VariableEnvironment*);
665     UnlinkedModuleProgramCodeBlock* createModuleProgramCodeBlock(CallFrame*, ModuleProgramExecutable*);
666
667 protected:
668     struct GlobalPropertyInfo {
669         GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
670             : identifier(i)
671             , value(v)
672             , attributes(a)
673         {
674         }
675
676         const Identifier identifier;
677         JSValue value;
678         unsigned attributes;
679     };
680     JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
681
682     JS_EXPORT_PRIVATE static JSC::JSValue toThis(JSC::JSCell*, JSC::ExecState*, ECMAMode);
683
684 private:
685     friend class LLIntOffsetsExtractor;
686
687     JS_EXPORT_PRIVATE void setGlobalThis(VM&, JSObject* globalThis);
688
689     JS_EXPORT_PRIVATE void init(VM&);
690
691     void createThrowTypeError(VM&);
692
693     JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
694 };
695
696 JSGlobalObject* asGlobalObject(JSValue);
697
698 inline JSGlobalObject* asGlobalObject(JSValue value)
699 {
700     ASSERT(asObject(value)->isGlobalObject());
701     return jsCast<JSGlobalObject*>(asObject(value));
702 }
703
704 inline bool JSGlobalObject::hasOwnPropertyForWrite(ExecState* exec, PropertyName propertyName)
705 {
706     PropertySlot slot(this);
707     if (Base::getOwnPropertySlot(this, exec, propertyName, slot))
708         return true;
709     bool slotIsWriteable;
710     return symbolTableGet(this, propertyName, slot, slotIsWriteable);
711 }
712
713 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, unsigned initialLength = 0)
714 {
715     return ArrayAllocationProfile::updateLastAllocationFor(profile, JSArray::create(exec->vm(), initialLength >= MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH ? globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage) : globalObject->arrayStructureForProfileDuringAllocation(profile), initialLength));
716 }
717
718 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, unsigned initialLength = 0)
719 {
720     return constructEmptyArray(exec, profile, exec->lexicalGlobalObject(), initialLength);
721 }
722  
723 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const ArgList& values)
724 {
725     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values));
726 }
727
728 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const ArgList& values)
729 {
730     return constructArray(exec, profile, exec->lexicalGlobalObject(), values);
731 }
732
733 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length)
734 {
735     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values, length));
736 }
737
738 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length)
739 {
740     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, length);
741 }
742
743 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length)
744 {
745     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArrayNegativeIndexed(exec, globalObject->arrayStructureForProfileDuringAllocation(profile), values, length));
746 }
747
748 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length)
749 {
750     return constructArrayNegativeIndexed(exec, profile, exec->lexicalGlobalObject(), values, length);
751 }
752
753 inline JSObject* ExecState::globalThisValue() const
754 {
755     return lexicalGlobalObject()->globalThis();
756 }
757
758 inline JSObject* JSScope::globalThis()
759
760     return globalObject()->globalThis();
761 }
762
763 inline JSObject* JSGlobalObject::globalThis() const
764
765     return m_globalThis.get();
766 }
767
768 } // namespace JSC
769
770 #endif // JSGlobalObject_h