/*
* Copyright (C) 2007 Eric Seidel <eric@webkit.org>
- * Copyright (C) 2007, 2008, 2009, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008, 2009, 2014, 2015 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
#include "JSSegmentedVariableObject.h"
#include "JSWeakObjectMapRefInternal.h"
#include "NumberPrototype.h"
+#include "RuntimeFlags.h"
#include "SpecialPointer.h"
#include "StringPrototype.h"
#include "StructureChain.h"
#include "StructureRareDataInlines.h"
+#include "SymbolPrototype.h"
+#include "TemplateRegistry.h"
#include "VM.h"
#include "Watchpoint.h"
#include <JavaScriptCore/JSBase.h>
#include <array>
#include <wtf/HashSet.h>
-#include <wtf/OwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RandomNumber.h>
class RegExpConstructor;
class RegExpPrototype;
class SourceCode;
+class NullGetterFunction;
+class NullSetterFunction;
+enum class ThisTDZMode;
struct ActivationStackNode;
struct HashTable;
#define DEFINE_STANDARD_BUILTIN(macro, upperName, lowerName) macro(upperName, lowerName, lowerName, JS ## upperName, upperName)
-
+
+#define FOR_EACH_EXPERIMENTAL_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
+ macro(Symbol, symbol, symbolObject, SymbolObject, Symbol) \
+
#define FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
macro(Set, set, set, JSSet, Set) \
macro(Map, map, map, JSMap, Map) \
macro(Error, error, error, ErrorInstance, Error) \
macro(JSArrayBuffer, arrayBuffer, arrayBuffer, JSArrayBuffer, ArrayBuffer) \
DEFINE_STANDARD_BUILTIN(macro, WeakMap, weakMap) \
+ DEFINE_STANDARD_BUILTIN(macro, WeakSet, weakSet) \
-#define FOR_EACH_SIMPLE_BUILTIN_TYPE(macro) \
- FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
+#define FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(macro) \
DEFINE_STANDARD_BUILTIN(macro, ArrayIterator, arrayIterator) \
- DEFINE_STANDARD_BUILTIN(macro, ArgumentsIterator, argumentsIterator) \
DEFINE_STANDARD_BUILTIN(macro, MapIterator, mapIterator) \
DEFINE_STANDARD_BUILTIN(macro, SetIterator, setIterator) \
+ DEFINE_STANDARD_BUILTIN(macro, StringIterator, stringIterator) \
+#define FOR_EACH_BUILTIN_ITERATOR_TYPE(macro) \
+ DEFINE_STANDARD_BUILTIN(macro, Iterator, iterator) \
+ FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(macro) \
+
+#define FOR_EACH_SIMPLE_BUILTIN_TYPE(macro) \
+ FOR_EACH_SIMPLE_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
+ FOR_EACH_EXPERIMENTAL_BUILTIN_TYPE_WITH_CONSTRUCTOR(macro) \
#define DECLARE_SIMPLE_BUILTIN_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
class JS ## capitalName; \
class capitalName ## Prototype; \
class capitalName ## Constructor;
+class IteratorPrototype;
FOR_EACH_SIMPLE_BUILTIN_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
+FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DECLARE_SIMPLE_BUILTIN_TYPE)
#undef DECLARE_SIMPLE_BUILTIN_TYPE
typedef bool (*ShouldInterruptScriptFunctionPtr)(const JSGlobalObject*);
ShouldInterruptScriptFunctionPtr shouldInterruptScript;
- typedef bool (*JavaScriptExperimentsEnabledFunctionPtr)(const JSGlobalObject*);
- JavaScriptExperimentsEnabledFunctionPtr javaScriptExperimentsEnabled;
+ typedef RuntimeFlags (*JavaScriptRuntimeFlagsFunctionPtr)(const JSGlobalObject*);
+ JavaScriptRuntimeFlagsFunctionPtr javaScriptRuntimeFlags;
typedef void (*QueueTaskToEventLoopFunctionPtr)(const JSGlobalObject*, PassRefPtr<Microtask>);
QueueTaskToEventLoopFunctionPtr queueTaskToEventLoop;
WriteBarrier<JSObject> m_globalThis;
+ WriteBarrier<JSObject> m_globalCallee;
WriteBarrier<RegExpConstructor> m_regExpConstructor;
WriteBarrier<ErrorConstructor> m_errorConstructor;
WriteBarrier<NativeErrorConstructor> m_evalErrorConstructor;
#endif
WriteBarrier<ObjectConstructor> m_objectConstructor;
+ WriteBarrier<NullGetterFunction> m_nullGetterFunction;
+ WriteBarrier<NullSetterFunction> m_nullSetterFunction;
+
+ WriteBarrier<JSFunction> m_parseIntFunction;
+
WriteBarrier<JSFunction> m_evalFunction;
WriteBarrier<JSFunction> m_callFunction;
WriteBarrier<JSFunction> m_applyFunction;
+ WriteBarrier<JSFunction> m_definePropertyFunction;
+ WriteBarrier<JSFunction> m_arrayProtoValuesFunction;
+#if ENABLE(PROMISES)
+ WriteBarrier<JSFunction> m_initializePromiseFunction;
+ WriteBarrier<JSFunction> m_newPromiseDeferredFunction;
+#endif
WriteBarrier<GetterSetter> m_throwTypeErrorGetterSetter;
WriteBarrier<ObjectPrototype> m_objectPrototype;
WriteBarrier<FunctionPrototype> m_functionPrototype;
WriteBarrier<ArrayPrototype> m_arrayPrototype;
WriteBarrier<RegExpPrototype> m_regExpPrototype;
+ WriteBarrier<IteratorPrototype> m_iteratorPrototype;
#if ENABLE(PROMISES)
WriteBarrier<JSPromisePrototype> m_promisePrototype;
#endif
+ WriteBarrier<Structure> m_debuggerScopeStructure;
WriteBarrier<Structure> m_withScopeStructure;
WriteBarrier<Structure> m_strictEvalActivationStructure;
- WriteBarrier<Structure> m_activationStructure;
- WriteBarrier<Structure> m_nameScopeStructure;
- WriteBarrier<Structure> m_argumentsStructure;
+ WriteBarrier<Structure> m_lexicalEnvironmentStructure;
+ WriteBarrier<Structure> m_catchScopeStructure;
+ WriteBarrier<Structure> m_functionNameScopeStructure;
+ WriteBarrier<Structure> m_directArgumentsStructure;
+ WriteBarrier<Structure> m_scopedArgumentsStructure;
+ WriteBarrier<Structure> m_outOfBandArgumentsStructure;
// Lists the actual structures used for having these particular indexing shapes.
WriteBarrier<Structure> m_originalArrayStructureForIndexingShape[NumberOfIndexingShapes];
WriteBarrier<Structure> m_objcWrapperObjectStructure;
#endif
WriteBarrier<Structure> m_nullPrototypeObjectStructure;
+ WriteBarrier<Structure> m_calleeStructure;
WriteBarrier<Structure> m_functionStructure;
WriteBarrier<Structure> m_boundFunctionStructure;
WriteBarrier<Structure> m_namedFunctionStructure;
PropertyOffset m_functionNameOffset;
WriteBarrier<Structure> m_privateNameStructure;
- WriteBarrier<Structure> m_regExpMatchesArrayStructure;
WriteBarrier<Structure> m_regExpStructure;
WriteBarrier<Structure> m_consoleStructure;
+ WriteBarrier<Structure> m_dollarVMStructure;
WriteBarrier<Structure> m_internalFunctionStructure;
WriteBarrier<Structure> m_iteratorResultStructure;
+ WriteBarrier<Structure> m_regExpMatchesArrayStructure;
+
#if ENABLE(PROMISES)
WriteBarrier<Structure> m_promiseStructure;
#endif // ENABLE(PROMISES)
WriteBarrier<Structure> m_ ## properName ## Structure;
FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
+ FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
#undef DEFINE_STORAGE_FOR_SIMPLE_TYPE
};
std::array<TypedArrayData, NUMBER_OF_TYPED_ARRAY_TYPES> m_typedArrays;
-
- void* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
+
+ JSCell* m_specialPointers[Special::TableSize]; // Special pointers used by the LLInt and JIT.
+ JSCell* m_linkTimeConstants[LinkTimeConstantCount];
String m_name;
RefPtr<WatchpointSet> m_havingABadTimeWatchpoint;
RefPtr<WatchpointSet> m_varInjectionWatchpoint;
- OwnPtr<JSGlobalObjectRareData> m_rareData;
+ std::unique_ptr<JSGlobalObjectRareData> m_rareData;
WeakRandom m_weakRandom;
+ TemplateRegistry m_templateRegistry;
+
bool m_evalEnabled;
String m_evalDisabledErrorMessage;
- bool m_experimentsEnabled;
+ RuntimeFlags m_runtimeFlags;
ConsoleClient* m_consoleClient;
static JS_EXPORTDATA const GlobalObjectMethodTable s_globalObjectMethodTable;
{
if (m_rareData)
return;
- m_rareData = adoptPtr(new JSGlobalObjectRareData);
+ m_rareData = std::make_unique<JSGlobalObjectRareData>();
}
public:
typedef JSSegmentedVariableObject Base;
+ static const unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames;
- static JSGlobalObject* create(VM& vm, Structure* structure)
+ static JSGlobalObject* create(VM& vm, Structure* structure, const GlobalObjectMethodTable* globalObjectMethodTable = nullptr)
{
- JSGlobalObject* globalObject = new (NotNull, allocateCell<JSGlobalObject>(vm.heap)) JSGlobalObject(vm, structure);
+ JSGlobalObject* globalObject = new (NotNull, allocateCell<JSGlobalObject>(vm.heap)) JSGlobalObject(vm, structure, globalObjectMethodTable);
globalObject->finishCreation(vm);
vm.heap.addFinalizer(globalObject, destroy);
return globalObject;
bool hasDebugger() const { return m_debugger; }
bool hasProfiler() const { return globalObjectMethodTable()->supportsProfiling(this); }
+ const RuntimeFlags& runtimeFlags() const { return m_runtimeFlags; }
protected:
JS_EXPORT_PRIVATE explicit JSGlobalObject(VM&, Structure*, const GlobalObjectMethodTable* = 0);
{
Base::finishCreation(vm);
structure()->setGlobalObject(vm, this);
- m_experimentsEnabled = m_globalObjectMethodTable->javaScriptExperimentsEnabled(this);
- init();
+ m_runtimeFlags = m_globalObjectMethodTable->javaScriptRuntimeFlags(this);
+ init(vm);
setGlobalThis(vm, JSProxy::create(vm, JSProxy::createStructure(vm, this, prototype(), PureForwardingProxyType), this));
}
{
Base::finishCreation(vm);
structure()->setGlobalObject(vm, this);
- m_experimentsEnabled = m_globalObjectMethodTable->javaScriptExperimentsEnabled(this);
- init();
+ m_runtimeFlags = m_globalObjectMethodTable->javaScriptRuntimeFlags(this);
+ init(vm);
setGlobalThis(vm, thisValue);
}
- struct NewGlobalVar {
- int registerNumber;
- VariableWatchpointSet* set;
- };
- NewGlobalVar addGlobalVar(const Identifier&, ConstantMode);
+ void addGlobalVar(const Identifier&, ConstantMode);
public:
JS_EXPORT_PRIVATE ~JSGlobalObject();
if (!hasProperty(exec, propertyName))
addGlobalVar(propertyName, IsConstant);
}
- void addFunction(ExecState*, const Identifier&, JSValue);
+ void addFunction(ExecState*, const Identifier&);
// The following accessors return pristine values, even if a script
// replaces the global object's associated property.
JSPromiseConstructor* promiseConstructor() const { return m_promiseConstructor.get(); }
#endif
+ NullGetterFunction* nullGetterFunction() const { return m_nullGetterFunction.get(); }
+ NullSetterFunction* nullSetterFunction() const { return m_nullSetterFunction.get(); }
+
+ JSFunction* parseIntFunction() const { return m_parseIntFunction.get(); }
+
JSFunction* evalFunction() const { return m_evalFunction.get(); }
JSFunction* callFunction() const { return m_callFunction.get(); }
JSFunction* applyFunction() const { return m_applyFunction.get(); }
+ JSFunction* definePropertyFunction() const { return m_definePropertyFunction.get(); }
+ JSFunction* arrayProtoValuesFunction() const { return m_arrayProtoValuesFunction.get(); }
+#if ENABLE(PROMISES)
+ JSFunction* initializePromiseFunction() const { return m_initializePromiseFunction.get(); }
+ JSFunction* newPromiseDeferredFunction() const { return m_newPromiseDeferredFunction.get(); }
+#endif
GetterSetter* throwTypeErrorGetterSetter(VM& vm)
{
if (!m_throwTypeErrorGetterSetter)
ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
+ SymbolPrototype* symbolPrototype() const { return m_symbolPrototype.get(); }
NumberPrototype* numberPrototype() const { return m_numberPrototype.get(); }
DatePrototype* datePrototype() const { return m_datePrototype.get(); }
RegExpPrototype* regExpPrototype() const { return m_regExpPrototype.get(); }
ErrorPrototype* errorPrototype() const { return m_errorPrototype.get(); }
+ IteratorPrototype* iteratorPrototype() const { return m_iteratorPrototype.get(); }
#if ENABLE(PROMISES)
JSPromisePrototype* promisePrototype() const { return m_promisePrototype.get(); }
#endif
+ Structure* debuggerScopeStructure() const { return m_debuggerScopeStructure.get(); }
Structure* withScopeStructure() const { return m_withScopeStructure.get(); }
Structure* strictEvalActivationStructure() const { return m_strictEvalActivationStructure.get(); }
- Structure* activationStructure() const { return m_activationStructure.get(); }
- Structure* nameScopeStructure() const { return m_nameScopeStructure.get(); }
- Structure* argumentsStructure() const { return m_argumentsStructure.get(); }
+ Structure* activationStructure() const { return m_lexicalEnvironmentStructure.get(); }
+ Structure* catchScopeStructure() const { return m_catchScopeStructure.get(); }
+ Structure* functionNameScopeStructure() const { return m_functionNameScopeStructure.get(); }
+ Structure* directArgumentsStructure() const { return m_directArgumentsStructure.get(); }
+ Structure* scopedArgumentsStructure() const { return m_scopedArgumentsStructure.get(); }
+ Structure* outOfBandArgumentsStructure() const { return m_outOfBandArgumentsStructure.get(); }
Structure* originalArrayStructureForIndexingType(IndexingType indexingType) const
{
ASSERT(indexingType & IsArray);
Structure* dateStructure() const { return m_dateStructure.get(); }
Structure* nullPrototypeObjectStructure() const { return m_nullPrototypeObjectStructure.get(); }
Structure* errorStructure() const { return m_errorStructure.get(); }
+ Structure* calleeStructure() const { return m_calleeStructure.get(); }
Structure* functionStructure() const { return m_functionStructure.get(); }
Structure* boundFunctionStructure() const { return m_boundFunctionStructure.get(); }
Structure* namedFunctionStructure() const { return m_namedFunctionStructure.get(); }
Structure* privateNameStructure() const { return m_privateNameStructure.get(); }
Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
Structure* mapStructure() const { return m_mapStructure.get(); }
- Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
Structure* regExpStructure() const { return m_regExpStructure.get(); }
Structure* setStructure() const { return m_setStructure.get(); }
Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
+ Structure* symbolObjectStructure() const { return m_symbolObjectStructure.get(); }
Structure* iteratorResultStructure() const { return m_iteratorResultStructure.get(); }
static ptrdiff_t iteratorResultStructureOffset() { return OBJECT_OFFSETOF(JSGlobalObject, m_iteratorResultStructure); }
+ Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
#if ENABLE(PROMISES)
Structure* promiseStructure() const { return m_promiseStructure.get(); }
JSGlobalObjectDebuggable& inspectorDebuggable() { return *m_inspectorDebuggable.get(); }
#endif
- JS_EXPORT_PRIVATE void setConsoleClient(ConsoleClient* consoleClient) { m_consoleClient = consoleClient; }
+ void setConsoleClient(ConsoleClient* consoleClient) { m_consoleClient = consoleClient; }
ConsoleClient* consoleClient() const { return m_consoleClient; }
void setName(const String&);
Structure* properName ## Structure() { return m_ ## properName ## Structure.get(); }
FOR_EACH_SIMPLE_BUILTIN_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
+ FOR_EACH_BUILTIN_DERIVED_ITERATOR_TYPE(DEFINE_ACCESSORS_FOR_SIMPLE_TYPE)
#undef DEFINE_ACCESSORS_FOR_SIMPLE_TYPE
return typedArrayStructure(type) == structure;
}
- void* actualPointerFor(Special::Pointer pointer)
+ JSCell* actualPointerFor(Special::Pointer pointer)
{
ASSERT(pointer < Special::TableSize);
return m_specialPointers[pointer];
}
+ JSCell* jsCellForLinkTimeConstant(LinkTimeConstant type)
+ {
+ unsigned index = static_cast<unsigned>(type);
+ ASSERT(index < LinkTimeConstantCount);
+ return m_linkTimeConstants[index];
+ }
WatchpointSet* masqueradesAsUndefinedWatchpoint() { return m_masqueradesAsUndefinedWatchpoint.get(); }
WatchpointSet* havingABadTimeWatchpoint() { return m_havingABadTimeWatchpoint.get(); }
static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
static bool shouldInterruptScriptBeforeTimeout(const JSGlobalObject*) { return false; }
- static bool javaScriptExperimentsEnabled(const JSGlobalObject*) { return false; }
+ static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags(); }
void queueMicrotask(PassRefPtr<Microtask>);
return m_rareData->opaqueJSClassData;
}
+ TemplateRegistry& templateRegistry() { return m_templateRegistry; }
+
double weakRandomNumber() { return m_weakRandom.get(); }
unsigned weakRandomInteger() { return m_weakRandom.getUint32(); }
UnlinkedProgramCodeBlock* createProgramCodeBlock(CallFrame*, ProgramExecutable*, JSObject** exception);
- UnlinkedEvalCodeBlock* createEvalCodeBlock(CallFrame*, EvalExecutable*);
+ UnlinkedEvalCodeBlock* createEvalCodeBlock(CallFrame*, EvalExecutable*, ThisTDZMode);
protected:
-
- static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | Base::StructureFlags;
-
struct GlobalPropertyInfo {
GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
: identifier(i)
JS_EXPORT_PRIVATE void setGlobalThis(VM&, JSObject* globalThis);
- // FIXME: Fold reset into init.
- JS_EXPORT_PRIVATE void init();
- void reset(JSValue prototype);
+ JS_EXPORT_PRIVATE void init(VM&);
void createThrowTypeError(VM&);
inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, unsigned initialLength = 0)
{
- return ArrayAllocationProfile::updateLastAllocationFor(profile, JSArray::create(exec->vm(), initialLength >= MIN_SPARSE_ARRAY_INDEX ? globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage) : globalObject->arrayStructureForProfileDuringAllocation(profile), initialLength));
+ return ArrayAllocationProfile::updateLastAllocationFor(profile, JSArray::create(exec->vm(), initialLength >= MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH ? globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage) : globalObject->arrayStructureForProfileDuringAllocation(profile), initialLength));
}
inline JSArray* constructEmptyArray(ExecState* exec, ArrayAllocationProfile* profile, unsigned initialLength = 0)
return constructArrayNegativeIndexed(exec, profile, exec->lexicalGlobalObject(), values, length);
}
+inline JSObject* ExecState::globalThisValue() const
+{
+ return lexicalGlobalObject()->globalThis();
+}
+
inline JSObject* JSScope::globalThis()
{
return globalObject()->globalThis();
projects / apple / javascriptcore.git / blobdiff