Source/JavaScriptCore/runtime/JSGlobalObject.h

   1 /*
   2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   3  *  Copyright (C) 2007, 2008, 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 #ifndef JSGlobalObject_h
  23 #define JSGlobalObject_h
  24
  25 #include "ArrayAllocationProfile.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 "NumberPrototype.h"
  35 #include "RuntimeFlags.h"
  36 #include "SpecialPointer.h"
  37 #include "StringPrototype.h"
  38 #include "SymbolPrototype.h"
  39 #include "TemplateRegistry.h"
  40 #include "VM.h"
  41 #include "Watchpoint.h"
  42 #include <JavaScriptCore/JSBase.h>
  43 #include <array>
  44 #include <wtf/HashSet.h>
  45 #include <wtf/PassRefPtr.h>
  46
  47 struct OpaqueJSClass;
  48 struct OpaqueJSClassContextData;
  49
  50 namespace Inspector {
  51 class JSGlobalObjectInspectorController;
  52 }
  53
  54 namespace JSC {
  55
  56 class ArrayPrototype;
  57 class BooleanPrototype;
  58 class ConsoleClient;
  59 class Debugger;
  60 class ErrorConstructor;
  61 class ErrorPrototype;
  62 class EvalCodeBlock;
  63 class EvalExecutable;
  64 class FunctionCodeBlock;
  65 class FunctionExecutable;
  66 class FunctionPrototype;
  67 class GeneratorPrototype;
  68 class GeneratorFunctionPrototype;
  69 class GetterSetter;
  70 class GlobalCodeBlock;
  71 class InputCursor;
  72 class JSGlobalObjectDebuggable;
  73 class JSInternalPromise;
  74 class JSPromise;
  75 class JSPromiseConstructor;
  76 class JSPromisePrototype;
  77 class JSStack;
  78 class LLIntOffsetsExtractor;
  79 class Microtask;
  80 class ModuleLoaderObject;
  81 class ModuleProgramExecutable;
  82 class NativeErrorConstructor;
  83 class NullGetterFunction;
  84 class NullSetterFunction;
  85 class ObjectConstructor;
  86 class ProgramCodeBlock;
  87 class ProgramExecutable;
  88 class RegExpConstructor;
  89 class RegExpPrototype;
  90 class SourceCode;
  91 class UnlinkedModuleProgramCodeBlock;
  92 class VariableEnvironment;
  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 (*SupportsLegacyProfilingFunctionPtr)(const JSGlobalObject*);
 145     SupportsLegacyProfilingFunctionPtr supportsLegacyProfiling;
 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     typedef JSValue (*ModuleLoaderEvaluatePtr)(JSGlobalObject*, ExecState*, JSValue, JSValue);
 175     ModuleLoaderEvaluatePtr moduleLoaderEvaluate;
 176
 177     typedef String (*DefaultLanguageFunctionPtr)();
 178     DefaultLanguageFunctionPtr defaultLanguage;
 179 };
 180
 181 class JSGlobalObject : public JSSegmentedVariableObject {
 182 private:
 183     typedef HashSet<RefPtr<OpaqueJSWeakObjectMap>> WeakMapSet;
 184     typedef HashMap<OpaqueJSClass*, std::unique_ptr<OpaqueJSClassContextData>> OpaqueJSClassDataMap;
 185
 186     struct JSGlobalObjectRareData {
 187         WTF_MAKE_FAST_ALLOCATED;
 188     public:
 189         JSGlobalObjectRareData()
 190             : profileGroup(0)
 191         {
 192         }
 193
 194         WeakMapSet weakMaps;
 195         unsigned profileGroup;
 196
 197         OpaqueJSClassDataMap opaqueJSClassData;
 198     };
 199
 200 protected:
 201     Register m_globalCallFrame[JSStack::CallFrameHeaderSize];
 202
 203     WriteBarrier<JSObject> m_globalThis;
 204
 205     WriteBarrier<JSGlobalLexicalEnvironment> m_globalLexicalEnvironment;
 206     WriteBarrier<JSObject> m_globalCallee;
 207     WriteBarrier<RegExpConstructor> m_regExpConstructor;
 208     WriteBarrier<ErrorConstructor> m_errorConstructor;
 209     WriteBarrier<NativeErrorConstructor> m_evalErrorConstructor;
 210     WriteBarrier<NativeErrorConstructor> m_rangeErrorConstructor;
 211     WriteBarrier<NativeErrorConstructor> m_referenceErrorConstructor;
 212     WriteBarrier<NativeErrorConstructor> m_syntaxErrorConstructor;
 213     WriteBarrier<NativeErrorConstructor> m_typeErrorConstructor;
 214     WriteBarrier<NativeErrorConstructor> m_URIErrorConstructor;
 215     WriteBarrier<ObjectConstructor> m_objectConstructor;
 216     WriteBarrier<JSPromiseConstructor> m_promiseConstructor;
 217     WriteBarrier<JSInternalPromiseConstructor> m_internalPromiseConstructor;
 218
 219     WriteBarrier<NullGetterFunction> m_nullGetterFunction;
 220     WriteBarrier<NullSetterFunction> m_nullSetterFunction;
 221
 222     WriteBarrier<JSFunction> m_parseIntFunction;
 223
 224     WriteBarrier<JSFunction> m_evalFunction;
 225     WriteBarrier<JSFunction> m_callFunction;
 226     WriteBarrier<JSFunction> m_applyFunction;
 227     WriteBarrier<JSFunction> m_definePropertyFunction;
 228     WriteBarrier<JSFunction> m_arrayProtoValuesFunction;
 229     WriteBarrier<JSFunction> m_initializePromiseFunction;
 230     WriteBarrier<JSFunction> m_newPromiseCapabilityFunction;
 231     WriteBarrier<JSFunction> m_functionProtoHasInstanceSymbolFunction;
 232     WriteBarrier<JSObject> m_regExpProtoExec;
 233     WriteBarrier<JSObject> m_regExpProtoSymbolReplace;
 234     WriteBarrier<JSObject> m_regExpProtoGlobalGetter;
 235     WriteBarrier<JSObject> m_regExpProtoUnicodeGetter;
 236     WriteBarrier<GetterSetter> m_throwTypeErrorGetterSetter;
 237     WriteBarrier<GetterSetter> m_throwTypeErrorArgumentsAndCallerGetterSetter;
 238
 239     WriteBarrier<ModuleLoaderObject> m_moduleLoader;
 240
 241     WriteBarrier<ObjectPrototype> m_objectPrototype;
 242     WriteBarrier<FunctionPrototype> m_functionPrototype;
 243     WriteBarrier<ArrayPrototype> m_arrayPrototype;
 244     WriteBarrier<RegExpPrototype> m_regExpPrototype;
 245     WriteBarrier<IteratorPrototype> m_iteratorPrototype;
 246     WriteBarrier<GeneratorFunctionPrototype> m_generatorFunctionPrototype;
 247     WriteBarrier<GeneratorPrototype> m_generatorPrototype;
 248
 249     WriteBarrier<Structure> m_debuggerScopeStructure;
 250     WriteBarrier<Structure> m_withScopeStructure;
 251     WriteBarrier<Structure> m_strictEvalActivationStructure;
 252     WriteBarrier<Structure> m_lexicalEnvironmentStructure;
 253     WriteBarrier<Structure> m_moduleEnvironmentStructure;
 254     WriteBarrier<Structure> m_directArgumentsStructure;
 255     WriteBarrier<Structure> m_scopedArgumentsStructure;
 256     WriteBarrier<Structure> m_clonedArgumentsStructure;
 257
 258     // Lists the actual structures used for having these particular indexing shapes.
 259     WriteBarrier<Structure> m_originalArrayStructureForIndexingShape[NumberOfIndexingShapes];
 260     // Lists the structures we should use during allocation for these particular indexing shapes.
 261     // These structures will differ from the originals list above when we are having a bad time.
 262     WriteBarrier<Structure> m_arrayStructureForIndexingShapeDuringAllocation[NumberOfIndexingShapes];
 263
 264     WriteBarrier<Structure> m_callbackConstructorStructure;
 265     WriteBarrier<Structure> m_callbackFunctionStructure;
 266     WriteBarrier<Structure> m_callbackObjectStructure;
 267     WriteBarrier<Structure> m_propertyNameIteratorStructure;
 268 #if JSC_OBJC_API_ENABLED
 269     WriteBarrier<Structure> m_objcCallbackFunctionStructure;
 270     WriteBarrier<Structure> m_objcWrapperObjectStructure;
 271 #endif
 272     WriteBarrier<Structure> m_nullPrototypeObjectStructure;
 273     WriteBarrier<Structure> m_calleeStructure;
 274     WriteBarrier<Structure> m_functionStructure;
 275     WriteBarrier<Structure> m_boundFunctionStructure;
 276     WriteBarrier<Structure> m_boundSlotBaseFunctionStructure;
 277     WriteBarrier<Structure> m_getterSetterStructure;
 278     WriteBarrier<Structure> m_nativeStdFunctionStructure;
 279     WriteBarrier<Structure> m_namedFunctionStructure;
 280     PropertyOffset m_functionNameOffset;
 281     WriteBarrier<Structure> m_privateNameStructure;
 282     WriteBarrier<Structure> m_regExpStructure;
 283     WriteBarrier<Structure> m_generatorFunctionStructure;
 284     WriteBarrier<Structure> m_dollarVMStructure;
 285     WriteBarrier<Structure> m_internalFunctionStructure;
 286     WriteBarrier<Structure> m_iteratorResultObjectStructure;
 287     WriteBarrier<Structure> m_regExpMatchesArrayStructure;
 288     WriteBarrier<Structure> m_regExpMatchesArraySlowPutStructure;
 289     WriteBarrier<Structure> m_moduleRecordStructure;
 290     WriteBarrier<Structure> m_moduleNamespaceObjectStructure;
 291     WriteBarrier<Structure> m_proxyObjectStructure;
 292     WriteBarrier<Structure> m_callableProxyObjectStructure;
 293     WriteBarrier<Structure> m_proxyRevokeStructure;
 294 #if ENABLE(WEBASSEMBLY)
 295     WriteBarrier<Structure> m_wasmModuleStructure;
 296 #endif
 297
 298 #define DEFINE_STORAGE_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
 299     WriteBarrier<capitalName ## Prototype> m_ ## lowerName ## Prototype; \
 300     WriteBarrier<Structure> m_ ## properName ## Structure;
 301
 302     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
 303     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
 304
 305 #undef DEFINE_STORAGE_FOR_SIMPLE_TYPE
 306
 307     struct TypedArrayData {
 308         WriteBarrier<JSObject> prototype;
 309         WriteBarrier<InternalFunction> constructor;
 310         WriteBarrier<Structure> structure;
 311     };
 312
 313     std::array<TypedArrayData, NUMBER_OF_TYPED_ARRAY_TYPES> m_typedArrays;
 314
 315     JSCell* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
 316     JSCell* m_linkTimeConstants[LinkTimeConstantCount];
 317
 318     String m_name;
 319
 320     Debugger* m_debugger;
 321
 322     VM& m_vm;
 323
 324 #if ENABLE(WEB_REPLAY)
 325     RefPtr<InputCursor> m_inputCursor;
 326 #endif
 327
 328 #if ENABLE(REMOTE_INSPECTOR)
 329     std::unique_ptr<Inspector::JSGlobalObjectInspectorController> m_inspectorController;
 330     std::unique_ptr<JSGlobalObjectDebuggable> m_inspectorDebuggable;
 331 #endif
 332
 333 #if ENABLE(INTL)
 334     HashSet<String> m_intlCollatorAvailableLocales;
 335     HashSet<String> m_intlDateTimeFormatAvailableLocales;
 336     HashSet<String> m_intlNumberFormatAvailableLocales;
 337 #endif // ENABLE(INTL)
 338
 339     RefPtr<WatchpointSet> m_masqueradesAsUndefinedWatchpoint;
 340     RefPtr<WatchpointSet> m_havingABadTimeWatchpoint;
 341     RefPtr<WatchpointSet> m_varInjectionWatchpoint;
 342
 343     std::unique_ptr<JSGlobalObjectRareData> m_rareData;
 344
 345     WeakRandom m_weakRandom;
 346
 347     TemplateRegistry m_templateRegistry;
 348
 349     bool m_evalEnabled;
 350     String m_evalDisabledErrorMessage;
 351     RuntimeFlags m_runtimeFlags;
 352     ConsoleClient* m_consoleClient;
 353
 354     static JS_EXPORTDATA const GlobalObjectMethodTable s_globalObjectMethodTable;
 355     const GlobalObjectMethodTable* m_globalObjectMethodTable;
 356
 357     void createRareDataIfNeeded()
 358     {
 359         if (m_rareData)
 360             return;
 361         m_rareData = std::make_unique<JSGlobalObjectRareData>();
 362     }
 363
 364 public:
 365     typedef JSSegmentedVariableObject Base;
 366     static const unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames | OverridesToThis;
 367
 368     static JSGlobalObject* create(VM& vm, Structure* structure)
 369     {
 370         JSGlobalObject* globalObject = new (NotNull, allocateCell<JSGlobalObject>(vm.heap)) JSGlobalObject(vm, structure);
 371         globalObject->finishCreation(vm);
 372         vm.heap.addFinalizer(globalObject, destroy);
 373         return globalObject;
 374     }
 375
 376     DECLARE_EXPORT_INFO;
 377
 378     bool hasDebugger() const;
 379     bool hasInteractiveDebugger() const;
 380     bool hasLegacyProfiler() const;
 381     const RuntimeFlags& runtimeFlags() const { return m_runtimeFlags; }
 382
 383 protected:
 384     JS_EXPORT_PRIVATE explicit JSGlobalObject(VM&, Structure*, const GlobalObjectMethodTable* = 0);
 385
 386     void finishCreation(VM& vm)
 387     {
 388         Base::finishCreation(vm);
 389         structure()->setGlobalObject(vm, this);
 390         m_runtimeFlags = m_globalObjectMethodTable->javaScriptRuntimeFlags(this);
 391         init(vm);
 392         setGlobalThis(vm, JSProxy::create(vm, JSProxy::createStructure(vm, this, getPrototypeDirect(), PureForwardingProxyType), this));
 393     }
 394
 395     void finishCreation(VM& vm, JSObject* thisValue)
 396     {
 397         Base::finishCreation(vm);
 398         structure()->setGlobalObject(vm, this);
 399         m_runtimeFlags = m_globalObjectMethodTable->javaScriptRuntimeFlags(this);
 400         init(vm);
 401         setGlobalThis(vm, thisValue);
 402     }
 403
 404     void addGlobalVar(const Identifier&);
 405
 406 public:
 407     JS_EXPORT_PRIVATE ~JSGlobalObject();
 408     JS_EXPORT_PRIVATE static void destroy(JSCell*);
 409     // We don't need a destructor because we use a finalizer instead.
 410     static const bool needsDestruction = false;
 411
 412     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
 413
 414     JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
 415     JS_EXPORT_PRIVATE static bool put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
 416
 417     JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, PropertyName, JSObject* getterFunc, unsigned attributes);
 418     JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, PropertyName, JSObject* setterFunc, unsigned attributes);
 419     JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
 420
 421     void addVar(ExecState* exec, const Identifier& propertyName)
 422     {
 423         if (!hasProperty(exec, propertyName))
 424             addGlobalVar(propertyName);
 425     }
 426     void addFunction(ExecState*, const Identifier&);
 427
 428     JSScope* globalScope() { return m_globalLexicalEnvironment.get(); }
 429     JSGlobalLexicalEnvironment* globalLexicalEnvironment() { return m_globalLexicalEnvironment.get(); }
 430
 431     // The following accessors return pristine values, even if a script
 432     // replaces the global object's associated property.
 433
 434     RegExpConstructor* regExpConstructor() const { return m_regExpConstructor.get(); }
 435
 436     ErrorConstructor* errorConstructor() const { return m_errorConstructor.get(); }
 437     ObjectConstructor* objectConstructor() const { return m_objectConstructor.get(); }
 438     JSPromiseConstructor* promiseConstructor() const { return m_promiseConstructor.get(); }
 439     JSInternalPromiseConstructor* internalPromiseConstructor() const { return m_internalPromiseConstructor.get(); }
 440     NativeErrorConstructor* evalErrorConstructor() const { return m_evalErrorConstructor.get(); }
 441     NativeErrorConstructor* rangeErrorConstructor() const { return m_rangeErrorConstructor.get(); }
 442     NativeErrorConstructor* referenceErrorConstructor() const { return m_referenceErrorConstructor.get(); }
 443     NativeErrorConstructor* syntaxErrorConstructor() const { return m_syntaxErrorConstructor.get(); }
 444     NativeErrorConstructor* typeErrorConstructor() const { return m_typeErrorConstructor.get(); }
 445     NativeErrorConstructor* URIErrorConstructor() const { return m_URIErrorConstructor.get(); }
 446
 447     NullGetterFunction* nullGetterFunction() const { return m_nullGetterFunction.get(); }
 448     NullSetterFunction* nullSetterFunction() const { return m_nullSetterFunction.get(); }
 449
 450     JSFunction* parseIntFunction() const { return m_parseIntFunction.get(); }
 451
 452     JSFunction* evalFunction() const { return m_evalFunction.get(); }
 453     JSFunction* callFunction() const { return m_callFunction.get(); }
 454     JSFunction* applyFunction() const { return m_applyFunction.get(); }
 455     JSFunction* definePropertyFunction() const { return m_definePropertyFunction.get(); }
 456     JSFunction* arrayProtoValuesFunction() const { return m_arrayProtoValuesFunction.get(); }
 457     JSFunction* initializePromiseFunction() const { return m_initializePromiseFunction.get(); }
 458     JSFunction* newPromiseCapabilityFunction() const { return m_newPromiseCapabilityFunction.get(); }
 459     JSFunction* functionProtoHasInstanceSymbolFunction() const { return m_functionProtoHasInstanceSymbolFunction.get(); }
 460     JSObject* regExpProtoExecFunction() const { return m_regExpProtoExec.get(); }
 461     JSObject* regExpProtoSymbolReplaceFunction() const { return m_regExpProtoSymbolReplace.get(); }
 462     JSObject* regExpProtoGlobalGetter() const { return m_regExpProtoGlobalGetter.get(); }
 463     JSObject* regExpProtoUnicodeGetter() const { return m_regExpProtoUnicodeGetter.get(); }
 464     GetterSetter* throwTypeErrorGetterSetter(VM& vm)
 465     {
 466         if (!m_throwTypeErrorGetterSetter)
 467             createThrowTypeError(vm);
 468         return m_throwTypeErrorGetterSetter.get();
 469     }
 470
 471     GetterSetter* throwTypeErrorArgumentsAndCallerGetterSetter(VM& vm)
 472     {
 473         if (!m_throwTypeErrorArgumentsAndCallerGetterSetter)
 474             createThrowTypeErrorArgumentsAndCaller(vm);
 475         return m_throwTypeErrorArgumentsAndCallerGetterSetter.get();
 476     }
 477
 478     ModuleLoaderObject* moduleLoader() const { return m_moduleLoader.get(); }
 479
 480     ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
 481     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
 482     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
 483     BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
 484     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
 485     SymbolPrototype* symbolPrototype() const { return m_symbolPrototype.get(); }
 486     NumberPrototype* numberPrototype() const { return m_numberPrototype.get(); }
 487     DatePrototype* datePrototype() const { return m_datePrototype.get(); }
 488     RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
 489     ErrorPrototype* errorPrototype() const { return m_errorPrototype.get(); }
 490     IteratorPrototype* iteratorPrototype() const { return m_iteratorPrototype.get(); }
 491     GeneratorFunctionPrototype* generatorFunctionPrototype() const { return m_generatorFunctionPrototype.get(); }
 492     GeneratorPrototype* generatorPrototype() const { return m_generatorPrototype.get(); }
 493
 494     Structure* debuggerScopeStructure() const { return m_debuggerScopeStructure.get(); }
 495     Structure* withScopeStructure() const { return m_withScopeStructure.get(); }
 496     Structure* strictEvalActivationStructure() const { return m_strictEvalActivationStructure.get(); }
 497     Structure* activationStructure() const { return m_lexicalEnvironmentStructure.get(); }
 498     Structure* moduleEnvironmentStructure() const { return m_moduleEnvironmentStructure.get(); }
 499     Structure* directArgumentsStructure() const { return m_directArgumentsStructure.get(); }
 500     Structure* scopedArgumentsStructure() const { return m_scopedArgumentsStructure.get(); }
 501     Structure* clonedArgumentsStructure() const { return m_clonedArgumentsStructure.get(); }
 502     Structure* originalArrayStructureForIndexingType(IndexingType indexingType) const
 503     {
 504         ASSERT(indexingType & IsArray);
 505         return m_originalArrayStructureForIndexingShape[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
 506     }
 507     Structure* arrayStructureForIndexingTypeDuringAllocation(IndexingType indexingType) const
 508     {
 509         ASSERT(indexingType & IsArray);
 510         return m_arrayStructureForIndexingShapeDuringAllocation[(indexingType & IndexingShapeMask) >> IndexingShapeShift].get();
 511     }
 512     Structure* arrayStructureForIndexingTypeDuringAllocation(ExecState* exec, IndexingType indexingType, JSValue newTarget) const
 513     {
 514         return InternalFunction::createSubclassStructure(exec, newTarget, arrayStructureForIndexingTypeDuringAllocation(indexingType));
 515     }
 516     Structure* arrayStructureForProfileDuringAllocation(ExecState* exec, ArrayAllocationProfile* profile, JSValue newTarget) const
 517     {
 518         return arrayStructureForIndexingTypeDuringAllocation(exec, ArrayAllocationProfile::selectIndexingTypeFor(profile), newTarget);
 519     }
 520
 521     bool isOriginalArrayStructure(Structure* structure)
 522     {
 523         return originalArrayStructureForIndexingType(structure->indexingType() | IsArray) == structure;
 524     }
 525
 526     Structure* booleanObjectStructure() const { return m_booleanObjectStructure.get(); }
 527     Structure* callbackConstructorStructure() const { return m_callbackConstructorStructure.get(); }
 528     Structure* callbackFunctionStructure() const { return m_callbackFunctionStructure.get(); }
 529     Structure* callbackObjectStructure() const { return m_callbackObjectStructure.get(); }
 530     Structure* propertyNameIteratorStructure() const { return m_propertyNameIteratorStructure.get(); }
 531 #if JSC_OBJC_API_ENABLED
 532     Structure* objcCallbackFunctionStructure() const { return m_objcCallbackFunctionStructure.get(); }
 533     Structure* objcWrapperObjectStructure() const { return m_objcWrapperObjectStructure.get(); }
 534 #endif
 535     Structure* dateStructure() const { return m_dateStructure.get(); }
 536     Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(); }
 537     Structure* errorStructure() const { return m_errorStructure.get(); }
 538     Structure* calleeStructure() const { return m_calleeStructure.get(); }
 539     Structure* functionStructure() const { return m_functionStructure.get(); }
 540     Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(); }
 541     Structure* boundSlotBaseFunctionStructure() const { return m_boundSlotBaseFunctionStructure.get(); }
 542     Structure* getterSetterStructure() const { return m_getterSetterStructure.get(); }
 543     Structure* nativeStdFunctionStructure() const { return m_nativeStdFunctionStructure.get(); }
 544     Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(); }
 545     PropertyOffset functionNameOffset() const { return m_functionNameOffset; }
 546     Structure* numberObjectStructure() const { return m_numberObjectStructure.get(); }
 547     Structure* privateNameStructure() const { return m_privateNameStructure.get(); }
 548     Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
 549     Structure* mapStructure() const { return m_mapStructure.get(); }
 550     Structure* regExpStructure() const { return m_regExpStructure.get(); }
 551     Structure* generatorFunctionStructure() const { return m_generatorFunctionStructure.get(); }
 552     Structure* setStructure() const { return m_setStructure.get(); }
 553     Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
 554     Structure* symbolObjectStructure() const { return m_symbolObjectStructure.get(); }
 555     Structure* iteratorResultObjectStructure() const { return m_iteratorResultObjectStructure.get(); }
 556     Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
 557     Structure* moduleRecordStructure() const { return m_moduleRecordStructure.get(); }
 558     Structure* moduleNamespaceObjectStructure() const { return m_moduleNamespaceObjectStructure.get(); }
 559     Structure* proxyObjectStructure() const { return m_proxyObjectStructure.get(); }
 560     Structure* callableProxyObjectStructure() const { return m_callableProxyObjectStructure.get(); }
 561     Structure* proxyRevokeStructure() const { return m_proxyRevokeStructure.get(); }
 562 #if ENABLE(WEBASSEMBLY)
 563     Structure* wasmModuleStructure() const { return m_wasmModuleStructure.get(); }
 564 #endif
 565
 566     JS_EXPORT_PRIVATE void setRemoteDebuggingEnabled(bool);
 567     JS_EXPORT_PRIVATE bool remoteDebuggingEnabled() const;
 568
 569 #if ENABLE(WEB_REPLAY)
 570     JS_EXPORT_PRIVATE void setInputCursor(PassRefPtr<InputCursor>);
 571     InputCursor& inputCursor() const { return *m_inputCursor; }
 572 #endif
 573
 574 #if ENABLE(REMOTE_INSPECTOR)
 575     Inspector::JSGlobalObjectInspectorController& inspectorController() const { return *m_inspectorController.get(); }
 576     JSGlobalObjectDebuggable& inspectorDebuggable() { return *m_inspectorDebuggable.get(); }
 577 #endif
 578
 579 #if ENABLE(INTL)
 580     const HashSet<String>& intlCollatorAvailableLocales();
 581     const HashSet<String>& intlDateTimeFormatAvailableLocales();
 582     const HashSet<String>& intlNumberFormatAvailableLocales();
 583 #endif // ENABLE(INTL)
 584
 585     void setConsoleClient(ConsoleClient* consoleClient) { m_consoleClient = consoleClient; }
 586     ConsoleClient* consoleClient() const { return m_consoleClient; }
 587
 588     void setName(const String&);
 589     const String& name() const { return m_name; }
 590
 591     JSArrayBufferPrototype* arrayBufferPrototype() const { return m_arrayBufferPrototype.get(); }
 592
 593 #define DEFINE_ACCESSORS_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
 594     Structure* properName ## Structure() { return m_ ## properName ## Structure.get(); }
 595
 596     FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
 597     FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
 598
 599 #undef DEFINE_ACCESSORS_FOR_SIMPLE_TYPE
 600
 601     Structure* typedArrayStructure(TypedArrayType type) const
 602     {
 603         return m_typedArrays[toIndex(type)].structure.get();
 604     }
 605     bool isOriginalTypedArrayStructure(Structure* structure)
 606     {
 607         TypedArrayType type = structure->classInfo()->typedArrayStorageType;
 608         if (type == NotTypedArray)
 609             return false;
 610         return typedArrayStructure(type) == structure;
 611     }
 612
 613     JSObject* typedArrayConstructor(TypedArrayType type) const
 614     {
 615         return m_typedArrays[toIndex(type)].constructor.get();
 616     }
 617
 618     JSCell* actualPointerFor(Special::Pointer pointer)
 619     {
 620         ASSERT(pointer < Special::TableSize);
 621         return m_specialPointers[pointer];
 622     }
 623     JSCell* jsCellForLinkTimeConstant(LinkTimeConstant type)
 624     {
 625         unsigned index = static_cast<unsigned>(type);
 626         ASSERT(index < LinkTimeConstantCount);
 627         return m_linkTimeConstants[index];
 628     }
 629
 630     WatchpointSet* masqueradesAsUndefinedWatchpoint() { return m_masqueradesAsUndefinedWatchpoint.get(); }
 631     WatchpointSet* havingABadTimeWatchpoint() { return m_havingABadTimeWatchpoint.get(); }
 632     WatchpointSet* varInjectionWatchpoint() { return m_varInjectionWatchpoint.get(); }
 633
 634     bool isHavingABadTime() const
 635     {
 636         return m_havingABadTimeWatchpoint->hasBeenInvalidated();
 637     }
 638
 639     void haveABadTime(VM&);
 640
 641     bool objectPrototypeIsSane();
 642     bool arrayPrototypeChainIsSane();
 643     bool stringPrototypeChainIsSane();
 644
 645     void setProfileGroup(unsigned value) { createRareDataIfNeeded(); m_rareData->profileGroup = value; }
 646     unsigned profileGroup() const
 647     {
 648         if (!m_rareData)
 649             return 0;
 650         return m_rareData->profileGroup;
 651     }
 652
 653     Debugger* debugger() const { return m_debugger; }
 654     void setDebugger(Debugger* debugger) { m_debugger = debugger; }
 655
 656     const GlobalObjectMethodTable* globalObjectMethodTable() const { return m_globalObjectMethodTable; }
 657
 658     static bool allowsAccessFrom(const JSGlobalObject*, ExecState*) { return true; }
 659     static bool supportsLegacyProfiling(const JSGlobalObject*) { return false; }
 660     static bool supportsRichSourceInfo(const JSGlobalObject*) { return true; }
 661
 662     JS_EXPORT_PRIVATE ExecState* globalExec();
 663
 664     static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
 665     static bool shouldInterruptScriptBeforeTimeout(const JSGlobalObject*) { return false; }
 666     static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags(); }
 667
 668     void queueMicrotask(PassRefPtr<Microtask>);
 669
 670     bool evalEnabled() const { return m_evalEnabled; }
 671     const String& evalDisabledErrorMessage() const { return m_evalDisabledErrorMessage; }
 672     void setEvalEnabled(bool enabled, const String& errorMessage = String())
 673     {
 674         m_evalEnabled = enabled;
 675         m_evalDisabledErrorMessage = errorMessage;
 676     }
 677
 678     void resetPrototype(VM&, JSValue prototype);
 679
 680     VM& vm() const { return m_vm; }
 681     JSObject* globalThis() const;
 682
 683     static Structure* createStructure(VM& vm, JSValue prototype)
 684     {
 685         Structure* result = Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
 686         result->setTransitionWatchpointIsLikelyToBeFired(true);
 687         return result;
 688     }
 689
 690     void registerWeakMap(OpaqueJSWeakObjectMap* map)
 691     {
 692         createRareDataIfNeeded();
 693         m_rareData->weakMaps.add(map);
 694     }
 695
 696     void unregisterWeakMap(OpaqueJSWeakObjectMap* map)
 697     {
 698         if (m_rareData)
 699             m_rareData->weakMaps.remove(map);
 700     }
 701
 702     OpaqueJSClassDataMap& opaqueJSClassData()
 703     {
 704         createRareDataIfNeeded();
 705         return m_rareData->opaqueJSClassData;
 706     }
 707
 708     TemplateRegistry& templateRegistry() { return m_templateRegistry; }
 709
 710     static ptrdiff_t weakRandomOffset() { return OBJECT_OFFSETOF(JSGlobalObject, m_weakRandom); }
 711     double weakRandomNumber() { return m_weakRandom.get(); }
 712     unsigned weakRandomInteger() { return m_weakRandom.getUint32(); }
 713
 714     UnlinkedProgramCodeBlock* createProgramCodeBlock(CallFrame*, ProgramExecutable*, JSObject** exception);
 715     UnlinkedEvalCodeBlock* createEvalCodeBlock(CallFrame*, EvalExecutable*, ThisTDZMode, const VariableEnvironment*);
 716     UnlinkedModuleProgramCodeBlock* createModuleProgramCodeBlock(CallFrame*, ModuleProgramExecutable*);
 717
 718 protected:
 719     struct GlobalPropertyInfo {
 720         GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
 721             : identifier(i)
 722             , value(v)
 723             , attributes(a)
 724         {
 725         }
 726
 727         const Identifier identifier;
 728         JSValue value;
 729         unsigned attributes;
 730     };
 731     JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
 732
 733     JS_EXPORT_PRIVATE static JSC::JSValue toThis(JSC::JSCell*, JSC::ExecState*, ECMAMode);
 734
 735 private:
 736     friend class LLIntOffsetsExtractor;
 737
 738     JS_EXPORT_PRIVATE void setGlobalThis(VM&, JSObject* globalThis);
 739
 740     JS_EXPORT_PRIVATE void init(VM&);
 741
 742     void createThrowTypeError(VM&);
 743     void createThrowTypeErrorArgumentsAndCaller(VM&);
 744
 745     JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
 746 };
 747
 748 JSGlobalObject* asGlobalObject(JSValue);
 749
 750 inline JSGlobalObject* asGlobalObject(JSValue value)
 751 {
 752     ASSERT(asObject(value)->isGlobalObject());
 753     return jsCast<JSGlobalObject*>(asObject(value));
 754 }
 755
 756 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, unsigned initialLength = 0, JSValue newTarget = JSValue())
 757 {
 758     Structure* structure;
 759     if (initialLength >= MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH)
 760         structure = globalObject->arrayStructureForIndexingTypeDuringAllocation(exec, ArrayWithArrayStorage, newTarget);
 761     else
 762         structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
 763     if (exec->hadException())
 764         return nullptr;
 765
 766     return ArrayAllocationProfile::updateLastAllocationFor(profile, JSArray::create(exec->vm(), structure, initialLength));
 767 }
 768
 769 inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, unsigned initialLength = 0, JSValue newTarget = JSValue())
 770 {
 771     return constructEmptyArray(exec, profile, exec->lexicalGlobalObject(), initialLength, newTarget);
 772 }
 773
 774 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const ArgList& values, JSValue newTarget = JSValue())
 775 {
 776     Structure* structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
 777     if (exec->hadException())
 778         return nullptr;
 779     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, structure, values));
 780 }
 781
 782 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const ArgList& values, JSValue newTarget = JSValue())
 783 {
 784     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, newTarget);
 785 }
 786
 787 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
 788 {
 789     Structure* structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
 790     if (exec->hadException())
 791         return nullptr;
 792     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArray(exec, structure, values, length));
 793 }
 794
 795 inline JSArray* constructArray(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
 796 {
 797     return constructArray(exec, profile, exec->lexicalGlobalObject(), values, length, newTarget);
 798 }
 799
 800 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
 801 {
 802     Structure* structure = globalObject->arrayStructureForProfileDuringAllocation(exec, profile, newTarget);
 803     if (exec->hadException())
 804         return nullptr;
 805     return ArrayAllocationProfile::updateLastAllocationFor(profile, constructArrayNegativeIndexed(exec, structure, values, length));
 806 }
 807
 808 inline JSArray* constructArrayNegativeIndexed(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, unsigned length, JSValue newTarget = JSValue())
 809 {
 810     return constructArrayNegativeIndexed(exec, profile, exec->lexicalGlobalObject(), values, length, newTarget);
 811 }
 812
 813 inline JSObject* ExecState::globalThisValue() const
 814 {
 815     return lexicalGlobalObject()->globalThis();
 816 }
 817
 818 inline JSObject* JSScope::globalThis()
 819 {
 820     return globalObject()->globalThis();
 821 }
 822
 823 inline JSObject* JSGlobalObject::globalThis() const
 824 {
 825     return m_globalThis.get();
 826 }
 827
 828 } // namespace JSC
 829
 830 #endif // JSGlobalObject_h