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