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