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