diff --git a/Source/JavaScriptCore/CMakeLists.txt b/Source/JavaScriptCore/CMakeLists.txt index c782ef073f71f..57d789769f413 100644 --- a/Source/JavaScriptCore/CMakeLists.txt +++ b/Source/JavaScriptCore/CMakeLists.txt @@ -1421,6 +1421,8 @@ set(JavaScriptCore_PRIVATE_FRAMEWORK_HEADERS runtime/JSCJSValueInlines.h runtime/JSCJSValuePropertyInlines.h runtime/JSCJSValueStructure.h + runtime/JSCPrimordials.h + runtime/JSCPrimordialsTable.h runtime/JSCallee.h runtime/JSCalleeInlines.h runtime/JSCast.h diff --git a/Source/JavaScriptCore/Sources.txt b/Source/JavaScriptCore/Sources.txt index be2d8aff65d46..012c5da4e857d 100644 --- a/Source/JavaScriptCore/Sources.txt +++ b/Source/JavaScriptCore/Sources.txt @@ -908,6 +908,7 @@ runtime/JSBoundFunction.cpp runtime/JSCBytecodeCacheVersion.cpp runtime/JSCConfig.cpp runtime/JSCJSValue.cpp +runtime/JSCPrimordials.cpp runtime/JSCPtrTag.cpp runtime/JSCallee.cpp runtime/JSCell.cpp diff --git a/Source/JavaScriptCore/builtins/BuiltinNames.cpp b/Source/JavaScriptCore/builtins/BuiltinNames.cpp index 2217a75d6a825..6ed0e506959c3 100644 --- a/Source/JavaScriptCore/builtins/BuiltinNames.cpp +++ b/Source/JavaScriptCore/builtins/BuiltinNames.cpp @@ -40,6 +40,11 @@ JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_BUILTIN_STATIC_ #define INITIALIZE_BUILTIN_PRIVATE_NAMES(name) SymbolImpl::StaticSymbolImpl name##PrivateName { #name, SymbolImpl::s_flagIsPrivate }; JSC_FOREACH_BUILTIN_FUNCTION_NAME(INITIALIZE_BUILTIN_PRIVATE_NAMES) JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(INITIALIZE_BUILTIN_PRIVATE_NAMES) +#if USE(BUN_JSC_ADDITIONS) +#define INITIALIZE_PRIMORDIAL_PRIVATE_NAMES(name, key, kind) INITIALIZE_BUILTIN_PRIVATE_NAMES(name) +JSC_FOREACH_PRIMORDIAL_NAME(INITIALIZE_PRIMORDIAL_PRIVATE_NAMES) +#undef INITIALIZE_PRIMORDIAL_PRIVATE_NAMES +#endif #undef INITIALIZE_BUILTIN_PRIVATE_NAMES SymbolImpl::StaticSymbolImpl dollarVMPrivateName { "$vm", SymbolImpl::s_flagIsPrivate }; @@ -49,6 +54,10 @@ SymbolImpl::StaticSymbolImpl stackPrivateName { "stack", SymbolImpl::s_flagIsPri } // namespace Symbols #define INITIALIZE_BUILTIN_NAMES_IN_JSC(name) , m_##name(JSC::Identifier::fromString(vm, #name ""_s)) +#if USE(BUN_JSC_ADDITIONS) +#define INITIALIZE_PRIMORDIAL_NAMES_IN_JSC(name, key, kind) INITIALIZE_BUILTIN_NAMES_IN_JSC(name) +#define INITIALIZE_PRIMORDIAL_PUBLIC_TO_PRIVATE_ENTRY(name, key, kind) INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY(name) +#endif #define INITIALIZE_BUILTIN_SYMBOLS_IN_JSC(name) \ , m_##name##Symbol(JSC::Identifier::fromUid(vm, &static_cast(JSC::Symbols::name##Symbol))) \ , m_##name##SymbolPrivateIdentifier(JSC::Identifier::fromString(vm, #name ""_s)) @@ -74,6 +83,9 @@ BuiltinNames::BuiltinNames(VM& vm, CommonIdentifiers* commonIdentifiers) : m_emptyIdentifier(commonIdentifiers->emptyIdentifier) JSC_FOREACH_BUILTIN_FUNCTION_NAME(INITIALIZE_BUILTIN_NAMES_IN_JSC) JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(INITIALIZE_BUILTIN_NAMES_IN_JSC) +#if USE(BUN_JSC_ADDITIONS) + JSC_FOREACH_PRIMORDIAL_NAME(INITIALIZE_PRIMORDIAL_NAMES_IN_JSC) +#endif JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_BUILTIN_SYMBOLS_IN_JSC) , m_dollarVMName(Identifier::fromString(vm, "$vm"_s)) , m_dollarVMPrivateName(Identifier::fromUid(vm, &static_cast(Symbols::dollarVMPrivateName))) @@ -82,6 +94,9 @@ BuiltinNames::BuiltinNames(VM& vm, CommonIdentifiers* commonIdentifiers) { JSC_FOREACH_BUILTIN_FUNCTION_NAME(INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY) JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY) +#if USE(BUN_JSC_ADDITIONS) + JSC_FOREACH_PRIMORDIAL_NAME(INITIALIZE_PRIMORDIAL_PUBLIC_TO_PRIVATE_ENTRY) +#endif JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_WELL_KNOWN_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY) m_privateNameSet.add(static_cast(m_dollarVMPrivateName.impl())); } @@ -90,6 +105,10 @@ BuiltinNames::BuiltinNames(VM& vm, CommonIdentifiers* commonIdentifiers) #undef INITIALIZE_BUILTIN_SYMBOLS_IN_JSC #undef INITIALIZE_PUBLIC_TO_PRIVATE_ENTRY #undef INITIALIZE_WELL_KNOWN_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY +#if USE(BUN_JSC_ADDITIONS) +#undef INITIALIZE_PRIMORDIAL_NAMES_IN_JSC +#undef INITIALIZE_PRIMORDIAL_PUBLIC_TO_PRIVATE_ENTRY +#endif using Latin1Buffer = WTF::HashTranslatorCharBuffer; diff --git a/Source/JavaScriptCore/builtins/BuiltinNames.h b/Source/JavaScriptCore/builtins/BuiltinNames.h index 51c5992c124ca..ae38bba108c1a 100644 --- a/Source/JavaScriptCore/builtins/BuiltinNames.h +++ b/Source/JavaScriptCore/builtins/BuiltinNames.h @@ -33,6 +33,10 @@ #include #include +#if USE(BUN_JSC_ADDITIONS) +#include "JSCPrimordials.h" +#endif + namespace JSC { #define DECLARE_BUILTIN_NAMES_IN_JSC(name) const JSC::Identifier m_##name; @@ -238,6 +242,11 @@ JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(DECLARE_BUILTIN_STATIC_SYM #define DECLARE_BUILTIN_PRIVATE_NAMES(name) extern JS_EXPORT_PRIVATE SymbolImpl::StaticSymbolImpl name##PrivateName; JSC_FOREACH_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_PRIVATE_NAMES) JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(DECLARE_BUILTIN_PRIVATE_NAMES) +#if USE(BUN_JSC_ADDITIONS) +#define DECLARE_PRIMORDIAL_PRIVATE_NAMES(name, key, kind) DECLARE_BUILTIN_PRIVATE_NAMES(name) +JSC_FOREACH_PRIMORDIAL_NAME(DECLARE_PRIMORDIAL_PRIVATE_NAMES) +#undef DECLARE_PRIMORDIAL_PRIVATE_NAMES +#endif #undef DECLARE_BUILTIN_PRIVATE_NAMES extern JS_EXPORT_PRIVATE SymbolImpl::StaticSymbolImpl dollarVMPrivateName; @@ -269,6 +278,11 @@ class BuiltinNames { JSC_FOREACH_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_IDENTIFIER_ACCESSOR_IN_JSC) JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(DECLARE_BUILTIN_IDENTIFIER_ACCESSOR_IN_JSC) +#if USE(BUN_JSC_ADDITIONS) +#define DECLARE_PRIMORDIAL_IDENTIFIER_ACCESSOR(name, key, kind) DECLARE_BUILTIN_IDENTIFIER_ACCESSOR_IN_JSC(name) + JSC_FOREACH_PRIMORDIAL_NAME(DECLARE_PRIMORDIAL_IDENTIFIER_ACCESSOR) +#undef DECLARE_PRIMORDIAL_IDENTIFIER_ACCESSOR +#endif JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(DECLARE_BUILTIN_SYMBOL_ACCESSOR) const JSC::Identifier& dollarVMPublicName() const { return m_dollarVMName; } const JSC::Identifier& dollarVMPrivateName() const { return m_dollarVMPrivateName; } @@ -281,6 +295,11 @@ class BuiltinNames { Identifier m_emptyIdentifier; JSC_FOREACH_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_NAMES_IN_JSC) JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(DECLARE_BUILTIN_NAMES_IN_JSC) +#if USE(BUN_JSC_ADDITIONS) +#define DECLARE_PRIMORDIAL_NAMES(name, key, kind) DECLARE_BUILTIN_NAMES_IN_JSC(name) + JSC_FOREACH_PRIMORDIAL_NAME(DECLARE_PRIMORDIAL_NAMES) +#undef DECLARE_PRIMORDIAL_NAMES +#endif JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(DECLARE_BUILTIN_SYMBOLS_IN_JSC) const JSC::Identifier m_dollarVMName; const JSC::Identifier m_dollarVMPrivateName; diff --git a/Source/JavaScriptCore/bytecode/BytecodeIntrinsicRegistry.cpp b/Source/JavaScriptCore/bytecode/BytecodeIntrinsicRegistry.cpp index 74d5e5a1c4e4c..bd8d72e2ecf7b 100644 --- a/Source/JavaScriptCore/bytecode/BytecodeIntrinsicRegistry.cpp +++ b/Source/JavaScriptCore/bytecode/BytecodeIntrinsicRegistry.cpp @@ -67,6 +67,11 @@ BytecodeIntrinsicRegistry::BytecodeIntrinsicRegistry(VM& vm) JSC_COMMON_BYTECODE_INTRINSIC_FUNCTIONS_EACH_NAME(INITIALIZE_BYTECODE_INTRINSIC_NAMES_TO_SET) JSC_COMMON_BYTECODE_INTRINSIC_CONSTANTS_EACH_NAME(INITIALIZE_BYTECODE_INTRINSIC_NAMES_TO_SET) JSC_FOREACH_LINK_TIME_CONSTANTS(INITIALIZE_BYTECODE_INTRINSIC_NAMES_TO_SET_FOR_LINK_TIME_CONSTANT) +#if USE(BUN_JSC_ADDITIONS) +#define INITIALIZE_PRIMORDIAL_BYTECODE_INTRINSIC_NAMES(name, key, kind) INITIALIZE_BYTECODE_INTRINSIC_NAMES_TO_SET_FOR_LINK_TIME_CONSTANT(name, nullptr) + JSC_FOREACH_PRIMORDIAL_NAME(INITIALIZE_PRIMORDIAL_BYTECODE_INTRINSIC_NAMES) +#undef INITIALIZE_PRIMORDIAL_BYTECODE_INTRINSIC_NAMES +#endif m_undefined.set(m_vm, jsUndefined()); m_Infinity.set(m_vm, jsDoubleNumber(std::numeric_limits::infinity())); diff --git a/Source/JavaScriptCore/bytecode/LinkTimeConstant.cpp b/Source/JavaScriptCore/bytecode/LinkTimeConstant.cpp index 719f97568a395..086f39a6c523a 100644 --- a/Source/JavaScriptCore/bytecode/LinkTimeConstant.cpp +++ b/Source/JavaScriptCore/bytecode/LinkTimeConstant.cpp @@ -43,6 +43,11 @@ void printInternal(PrintStream& out, JSC::LinkTimeConstant constant) { switch (constant) { JSC_FOREACH_LINK_TIME_CONSTANTS(PRINT_LINK_TIME_CONSTANT) +#if USE(BUN_JSC_ADDITIONS) +#define PRINT_PRIMORDIAL_LINK_TIME_CONSTANT(name, key, kind) PRINT_LINK_TIME_CONSTANT(name, nullptr) + JSC_FOREACH_PRIMORDIAL_NAME(PRINT_PRIMORDIAL_LINK_TIME_CONSTANT) +#undef PRINT_PRIMORDIAL_LINK_TIME_CONSTANT +#endif } } diff --git a/Source/JavaScriptCore/bytecode/LinkTimeConstant.h b/Source/JavaScriptCore/bytecode/LinkTimeConstant.h index e98b0f2138e30..5123f8067d0b4 100644 --- a/Source/JavaScriptCore/bytecode/LinkTimeConstant.h +++ b/Source/JavaScriptCore/bytecode/LinkTimeConstant.h @@ -28,6 +28,10 @@ #include "JSCBuiltins.h" #include +#if USE(BUN_JSC_ADDITIONS) +#include "JSCPrimordials.h" +#endif + namespace JSC { class CodeBlock; @@ -163,10 +167,21 @@ class JSGlobalObject; #define DECLARE_LINK_TIME_CONSTANT(name, code) name, enum class LinkTimeConstant : int32_t { JSC_FOREACH_LINK_TIME_CONSTANTS(DECLARE_LINK_TIME_CONSTANT) +#if USE(BUN_JSC_ADDITIONS) +#define DECLARE_PRIMORDIAL_LINK_TIME_CONSTANT(name, key, kind) name, + JSC_FOREACH_PRIMORDIAL_NAME(DECLARE_PRIMORDIAL_LINK_TIME_CONSTANT) +#undef DECLARE_PRIMORDIAL_LINK_TIME_CONSTANT +#endif }; #undef DECLARE_LINK_TIME_CONSTANT #define COUNT_LINK_TIME_CONSTANT(name, code) 1 + +#if USE(BUN_JSC_ADDITIONS) +#define COUNT_PRIMORDIAL_LINK_TIME_CONSTANT(name, key, kind) 1 + +static constexpr unsigned numberOfLinkTimeConstants = JSC_FOREACH_LINK_TIME_CONSTANTS(COUNT_LINK_TIME_CONSTANT) JSC_FOREACH_PRIMORDIAL_NAME(COUNT_PRIMORDIAL_LINK_TIME_CONSTANT) 0; +#undef COUNT_PRIMORDIAL_LINK_TIME_CONSTANT +#else static constexpr unsigned numberOfLinkTimeConstants = JSC_FOREACH_LINK_TIME_CONSTANTS(COUNT_LINK_TIME_CONSTANT) 0; +#endif #undef COUNT_LINK_TIME_CONSTANT } // namespace JSC diff --git a/Source/JavaScriptCore/runtime/JSCPrimordials.cpp b/Source/JavaScriptCore/runtime/JSCPrimordials.cpp new file mode 100644 index 0000000000000..8ca04c84d9825 --- /dev/null +++ b/Source/JavaScriptCore/runtime/JSCPrimordials.cpp @@ -0,0 +1,452 @@ +/* + * Copyright (C) 2019 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(BUN_JSC_ADDITIONS) + +#include "JSCPrimordials.h" + +#include "GetterSetter.h" +#include "JSArray.h" +#include "JSCJSValueInlines.h" +#include "JSCustomGetterFunction.h" +#include "JSFunction.h" +#include "JSGlobalObject.h" +#include "JSObjectInlines.h" +#include "LazyPropertyInlines.h" +#include "LinkTimeConstant.h" +#include "Lookup.h" +#include "ObjectConstructor.h" +#include "PropertyDescriptor.h" +#include "Symbol.h" +#include "TopExceptionScope.h" + +namespace JSC { + +namespace Primordials { + +struct Entry { + PrimordialKind kind; + Identifier (*makeKey)(VM&); // nullptr for Self entries + ASCIILiteral name; +}; + +#define PROP(key) [](VM& vm) -> Identifier { return Identifier::fromString(vm, key ""_s); } +#define SYM(key) [](VM& vm) -> Identifier { return vm.propertyNames->key##Symbol; } +#define SELF nullptr +#define JSC_PRIMORDIAL_ENTRY(name, makeKey, kind) { PrimordialKind::kind, makeKey, #name ""_s }, +static const Entry s_entries[numberOfPrimordials] = { + JSC_FOREACH_PRIMORDIAL_NAME(JSC_PRIMORDIAL_ENTRY) +}; +#undef JSC_PRIMORDIAL_ENTRY +#undef PROP +#undef SYM +#undef SELF + +#define JSC_PRIMORDIAL_COUNT_ENTRY(name, key, kind) 1 + +#define JSC_PRIMORDIAL_HOLDER_COUNT(Holder) (JSC_FOREACH_PRIMORDIAL_##Holder(JSC_PRIMORDIAL_COUNT_ENTRY) 0), +static constexpr unsigned s_holderCounts[] = { + JSC_FOREACH_PRIMORDIAL_HOLDER(JSC_PRIMORDIAL_HOLDER_COUNT) +}; +#undef JSC_PRIMORDIAL_HOLDER_COUNT +#undef JSC_PRIMORDIAL_COUNT_ENTRY + +#define JSC_PRIMORDIAL_HOLDER_NAME(Holder) #Holder ""_s, +static const ASCIILiteral s_holderNames[] = { + JSC_FOREACH_PRIMORDIAL_HOLDER(JSC_PRIMORDIAL_HOLDER_NAME) +}; +#undef JSC_PRIMORDIAL_HOLDER_NAME + +static unsigned firstLinkTimeConstantIndex() +{ + static_assert(numberOfPrimordials <= numberOfLinkTimeConstants, "primordials must be a suffix of the link-time constants"); + return numberOfLinkTimeConstants - numberOfPrimordials; +} + +static unsigned indexFor(LinkTimeConstant constant) +{ + unsigned index = static_cast(constant) - firstLinkTimeConstantIndex(); + ASSERT(index < numberOfPrimordials); + return index; +} + +static LinkTimeConstant linkTimeConstantFor(unsigned index) +{ + return static_cast(firstLinkTimeConstantIndex() + index); +} + +static constexpr unsigned numberOfHolders = std::size(s_holderCounts); + +// s_holderBegin[h] is the first primordial index of holder h; the extra entry is the total. +static constexpr auto s_holderBegin = [] { + std::array begins { }; + for (unsigned h = 0; h < numberOfHolders; ++h) + begins[h + 1] = begins[h] + s_holderCounts[h]; + return begins; +}(); + +static PrimordialHolder holderFor(unsigned index) +{ + return static_cast(std::upper_bound(s_holderBegin.begin(), s_holderBegin.end(), index) - s_holderBegin.begin() - 1); +} + +static std::pair rangeFor(PrimordialHolder holder) +{ + unsigned h = static_cast(holder); + return { s_holderBegin[h], s_holderBegin[h + 1] }; +} + +static bool isAccessorKind(PrimordialKind kind) +{ + return kind == PrimordialKind::Getter || kind == PrimordialKind::Setter; +} + +// A table entry not matched by any of reifyStaticProperty's typed cases is a +// C++ getter/setter pair reified as a CustomGetterSetter. +static bool isCustomAccessorEntry(const HashTableValue& entry) +{ + static constexpr unsigned typedMask = PropertyAttribute::Builtin | PropertyAttribute::Function | PropertyAttribute::ConstantInteger + | PropertyAttribute::Accessor | PropertyAttribute::CellProperty | PropertyAttribute::ClassStructure | PropertyAttribute::PropertyCallback + | PropertyAttribute::DOMJITAttribute | PropertyAttribute::DOMJITFunction | PropertyAttribute::DOMAttribute; + return !(entry.attributes() & typedMask); +} + +static BuiltinGenerator builtinGeneratorFor(const HashTableValue& entry, PrimordialKind kind) +{ + switch (kind) { + case PrimordialKind::Getter: + return entry.builtinAccessorGetterGenerator(); + case PrimordialKind::Setter: + return entry.builtinAccessorSetterGenerator(); + default: + return entry.builtinGenerator(); + } +} + +// True when `function` is the exact function the (Builtin | Function | Accessor) +// table entry reifies on `holder`: same generator/native pointer AND same realm +// (a foreign realm's builtin shares the pointer but is a different value). +static bool matchesEntry(VM& vm, JSObject* holder, JSFunction* function, const HashTableValue& entry, PrimordialKind kind) +{ + if (function->globalObject() != holder->globalObject()) + return false; + unsigned attributes = entry.attributes(); + if (attributes & PropertyAttribute::Builtin) { + bool accessor = attributes & PropertyAttribute::Accessor; + if (accessor != isAccessorKind(kind)) + return false; + if (!function->isBuiltinFunction()) + return false; + return uncheckedDowncast(function->executable())->unlinkedExecutable() == builtinGeneratorFor(entry, kind)(vm)->unlinkedExecutable(); + } + NativeFunction native; + if (isAccessorKind(kind) && (attributes & PropertyAttribute::Accessor)) + native = NativeFunction(kind == PrimordialKind::Getter ? entry.accessorGetter() : entry.accessorSetter()); + else if (kind == PrimordialKind::Method && (attributes & PropertyAttribute::Function)) + native = entry.function(); + else + return false; + return function->isHostFunction() && function->nativeFunction() == native; +} + +// The JS-visible value of a holder's own property, per kind (JS accessor function, +// C++ accessor's cached wrapper or its value, or an own object/symbol). Only run at +// holder creation or by the host, so reading a custom accessor here is pristine. +static JSCell* cellForOwnProperty(VM& vm, JSGlobalObject* globalObject, JSObject* holder, const Identifier& key, JSValue value, PrimordialKind kind) +{ + if (!value) + return nullptr; + if (value.isGetterSetter()) { + auto* getterSetter = uncheckedDowncast(value.asCell()); + if (kind == PrimordialKind::Getter) + return getterSetter->getter(); + if (kind == PrimordialKind::Setter) + return getterSetter->setter(); + return nullptr; + } + if (auto* custom = value.isCell() ? dynamicDowncast(value.asCell()) : nullptr) { + if (kind == PrimordialKind::Getter) + return custom->getter() ? createCustomGetterFunction(globalObject, vm, key, custom->getter(), std::nullopt) : nullptr; + if (kind == PrimordialKind::Setter) + return custom->setter() ? createCustomSetterFunction(globalObject, vm, key, custom->setter()) : nullptr; + // A CustomValue property presents its getter's result as a data value. + if (!custom->getter()) + return nullptr; + auto catchScope = DECLARE_TOP_EXCEPTION_SCOPE(vm); + DeferTerminationForAWhile deferScope(vm); + value = JSValue::decode(custom->getter()(globalObject, JSValue::encode(holder), key)); + catchScope.assertNoExceptionExceptTermination(); + } + if (isAccessorKind(kind)) + return nullptr; + if (value.isSymbol()) + return kind == PrimordialKind::Value ? value.asCell() : nullptr; + if (!value.isCell() || !value.asCell()->isObject()) + return nullptr; + return value.asCell(); +} + +// A reified static property is trusted only if it is still the exact function +// (or accessor function) the ClassInfo table describes; anything else is user-installed. +static JSCell* cellIfMatchesEntry(VM& vm, JSObject* holder, JSValue value, const HashTableValue& entry, PrimordialKind kind) +{ + if (!value) + return nullptr; + if (isAccessorKind(kind)) { + if (!value.isGetterSetter()) + return nullptr; + auto* getterSetter = uncheckedDowncast(value.asCell()); + auto* function = dynamicDowncast(kind == PrimordialKind::Getter ? getterSetter->getter() : getterSetter->setter()); + if (!function || !matchesEntry(vm, holder, function, entry, kind)) + return nullptr; + return function; + } + auto* function = value.isCell() ? dynamicDowncast(value.asCell()) : nullptr; + if (!function || !matchesEntry(vm, holder, function, entry, kind)) + return nullptr; + return function; +} + +// Lazy cells and lazy class structures carry their own pristine source: the +// holder object's current state is irrelevant, so recompute the value directly. +static JSCell* recomputableEntryValue(VM& vm, JSObject* holder, const HashTableValue& entry) +{ + unsigned attributes = entry.attributes(); + if (attributes & PropertyAttribute::CellProperty) { + auto* property = std::bit_cast(std::bit_cast(holder) + entry.lazyCellPropertyOffset()); + return property->get(holder); + } + if (attributes & PropertyAttribute::ClassStructure) { + auto* lazyStructure = std::bit_cast(std::bit_cast(holder) + entry.lazyClassStructureOffset()); + return lazyStructure->constructor(uncheckedDowncast(holder)); + } + // A PropertyCallback that is a primordial on its own holder (the global's + // `eval`) hands back a lazily-created member the holder owns, so the call is + // idempotent; a callback that allocates would have to be a holder instead. + if (attributes & PropertyAttribute::PropertyCallback) { + auto catchScope = DECLARE_TOP_EXCEPTION_SCOPE(vm); + DeferTerminationForAWhile deferScope(vm); + JSValue value = entry.lazyPropertyCallback()(vm, holder); + catchScope.assertNoExceptionExceptTermination(); + ASSERT_WITH_MESSAGE(value == entry.lazyPropertyCallback()(vm, holder), "primordial PropertyCallback entries must be idempotent"); + return value.isCell() ? value.asCell() : nullptr; + } + return nullptr; +} + +// Builds a fresh, un-installed copy of the property from its immutable table +// entry; used when the holder's own state can't be trusted. +static JSCell* materializeFromEntry(VM& vm, JSGlobalObject* globalObject, const Identifier& key, const HashTableValue& entry, PrimordialKind kind) +{ + unsigned attributes = entry.attributes(); + if (isCustomAccessorEntry(entry)) { + if (kind == PrimordialKind::Setter) + return createCustomSetterFunction(globalObject, vm, key, entry.propertyPutter()); + return createCustomGetterFunction(globalObject, vm, key, entry.propertyGetter(), std::nullopt); + } + if (attributes & PropertyAttribute::Builtin) + return JSFunction::create(vm, globalObject, builtinGeneratorFor(entry, kind)(vm), globalObject); + if (attributes & PropertyAttribute::Accessor) { + ASSERT(isAccessorKind(kind)); + bool getter = kind == PrimordialKind::Getter; + String name = tryMakeString(getter ? "get "_s : "set "_s, String(PropertyName(key).publicName())); + return JSFunction::create(vm, globalObject, getter ? 0 : 1, name, getter ? entry.accessorGetter() : entry.accessorSetter(), ImplementationVisibility::Public); + } + // Only Function entries carry a native function to build from; the recomputable + // (CellProperty/ClassStructure/PropertyCallback) entries never reach here. + RELEASE_ASSERT(attributes & PropertyAttribute::Function); + StringImpl* name = PropertyName(key).publicName(); + if (!name) + name = vm.propertyNames->anonymous.impl(); + return JSFunction::create(vm, globalObject, entry.functionLength(), name, entry.function(), ImplementationVisibility::Public, entry.intrinsic()); +} + +// Reuses an already-reified pristine value for identity with `holder[key]`; +// reifies the (untouched) static property first if nothing has yet. +static JSCell* pristineFromHolderOwnProperty(VM& vm, JSObject* holder, const ClassInfo* entryClassInfo, const Identifier& key, const HashTableValue& entry, PrimordialKind kind) +{ + if (isCustomAccessorEntry(entry)) + return nullptr; + unsigned attributes; + PropertyOffset offset = holder->getDirectOffset(vm, key, attributes); + if (!isValidOffset(offset)) { + if (holder->staticPropertiesReified()) + return nullptr; + { + auto catchScope = DECLARE_TOP_EXCEPTION_SCOPE(vm); + DeferTerminationForAWhile deferScope(vm); + reifyStaticProperty(vm, entryClassInfo, key, entry, *holder); + catchScope.assertNoExceptionExceptTermination(); + } + offset = holder->getDirectOffset(vm, key, attributes); + if (!isValidOffset(offset)) + return nullptr; + // Just reified from the immutable table: a Value can be trusted as-is + // (there's no table-side function to compare it against). + if (kind == PrimordialKind::Value) + return cellForOwnProperty(vm, holder->globalObject(), holder, key, holder->getDirect(offset), kind); + } + return cellIfMatchesEntry(vm, holder, holder->getDirect(offset), entry, kind); +} + +JSC_DEFINE_HOST_FUNCTION(primordialUnavailableHostFunction, (JSGlobalObject* globalObject, CallFrame* callFrame)) +{ + VM& vm = globalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + String name = uncheckedDowncast(callFrame->jsCallee())->name(vm); + RETURN_IF_EXCEPTION(scope, { }); + return throwVMTypeError(globalObject, scope, makeString("primordial "_s, name, " is not available in this configuration"_s)); +} + +static JSFunction* unavailableFunction(VM& vm, JSGlobalObject* globalObject, ASCIILiteral name) +{ + return JSFunction::create(vm, globalObject, 0, name, primordialUnavailableHostFunction, ImplementationVisibility::Public); +} + +static bool isUnavailableFunction(JSCell* cell) +{ + auto* function = dynamicDowncast(cell); + return function && function->isHostFunction() && function->nativeFunction() == primordialUnavailableHostFunction; +} + +#define JSC_PRIMORDIAL_COUNT_HOLDER(Holder) 1 + +static constexpr unsigned numberOfEagerHolders = JSC_FOREACH_PRIMORDIAL_EAGER_HOLDER(JSC_PRIMORDIAL_COUNT_HOLDER) 0; +#undef JSC_PRIMORDIAL_COUNT_HOLDER + +} // namespace Primordials + +void JSGlobalObject::initializePrimordialLinkTimeConstants() +{ + using namespace Primordials; + auto materializeLater = [](const Initializer& init) { + unsigned slot = &init.property - init.owner->m_linkTimeConstants.begin(); + init.set(init.owner->materializePrimordial(init.vm, static_cast(slot))); + }; + for (unsigned i = 0; i < numberOfPrimordials; ++i) + m_linkTimeConstants[static_cast(linkTimeConstantFor(i))].initLater(materializeLater); +} + +void JSGlobalObject::snapshotEagerPrimordials(VM& vm) +{ + using namespace Primordials; + for (unsigned h = 0; h < numberOfEagerHolders; ++h) { + auto holder = static_cast(h); + snapshotPrimordialsFromHolder(vm, primordialHolderObject(vm, holder), holder); + } +} + +// Only own properties are read; static-table properties are materialized from +// the tables on first link. A namespace holder can be created more than once (a +// PropertyCallback re-run), so an existing snapshot wins unless the host overrides. +void JSGlobalObject::snapshotPrimordialsFromHolder(VM& vm, JSObject* holder, PrimordialHolder which, bool overrideExisting) +{ + using namespace Primordials; + ASSERT(holder); + auto [begin, end] = rangeFor(which); + for (unsigned i = begin; i < end; ++i) { + auto& slot = m_linkTimeConstants[static_cast(linkTimeConstantFor(i))]; + if (slot.isInitialized() && !overrideExisting) + continue; + JSCell* cell = holder; + if (s_entries[i].kind != PrimordialKind::Self) { + Identifier key = s_entries[i].makeKey(vm); + cell = cellForOwnProperty(vm, this, holder, key, holder->getDirect(vm, key), s_entries[i].kind); + } + if (!cell) + continue; + slot.set(vm, this, cell); + } +} + +void JSGlobalObject::overridePrimordialsFromHolder(VM& vm, JSObject* holder, PrimordialHolder which) +{ + snapshotPrimordialsFromHolder(vm, holder, which, true); +} + +JSCell* JSGlobalObject::materializePrimordialFromTables(VM& vm, JSObject* holder, unsigned index) +{ + using namespace Primordials; + const Entry& info = s_entries[index]; + if (info.kind == PrimordialKind::Self) + return holder; + Identifier key = info.makeKey(vm); + if (auto entry = holder->findPropertyHashEntry(key)) { + if (JSCell* cell = recomputableEntryValue(vm, holder, *entry->value)) + return cell; + if (JSCell* cell = pristineFromHolderOwnProperty(vm, holder, entry->table->classForThis, key, *entry->value, info.kind)) + return cell; + return materializeFromEntry(vm, this, key, *entry->value, info.kind); + } + return unavailableFunction(vm, this, info.name); +} + +JSCell* JSGlobalObject::materializePrimordial(VM& vm, LinkTimeConstant constant) +{ + using namespace Primordials; + unsigned index = indexFor(constant); + auto& slot = m_linkTimeConstants[static_cast(constant)]; + // Forcing a lazy holder into existence snapshots its own properties, which may + // initialize this slot. A null holder would mean an accessor re-entered its own + // lazy initializer; never cache a stub over that. + JSObject* holder = primordialHolderObject(vm, holderFor(index)); + RELEASE_ASSERT(holder); + if (slot.isInitialized()) + return slot.getInitializedOnMainThread(this); + return materializePrimordialFromTables(vm, holder, index); +} + +JSValue JSGlobalObject::auditPrimordials(JSGlobalObject* globalObject) +{ + using namespace Primordials; + VM& vm = globalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSArray* result = constructEmptyArray(globalObject, nullptr, numberOfPrimordials); + RETURN_IF_EXCEPTION(scope, { }); + static constexpr ASCIILiteral kindNames[] = { "Method"_s, "Getter"_s, "Setter"_s, "Value"_s, "Self"_s }; + for (unsigned i = 0; i < numberOfPrimordials; ++i) { + JSCell* value = globalObject->linkTimeConstant(linkTimeConstantFor(i)); + JSObject* row = constructEmptyObject(globalObject); + row->putDirect(vm, Identifier::fromString(vm, "name"_s), jsString(vm, String(s_entries[i].name))); + row->putDirect(vm, Identifier::fromString(vm, "holder"_s), jsString(vm, String(s_holderNames[static_cast(holderFor(i))]))); + row->putDirect(vm, Identifier::fromString(vm, "kind"_s), jsString(vm, String(kindNames[static_cast(s_entries[i].kind)]))); + JSValue keyValue = jsNull(); + if (s_entries[i].makeKey) { + Identifier key = s_entries[i].makeKey(vm); + keyValue = key.isSymbol() ? JSValue(Symbol::create(vm, static_cast(*key.impl()))) : jsString(vm, String(key.impl())); + } + row->putDirect(vm, Identifier::fromString(vm, "key"_s), keyValue); + row->putDirect(vm, vm.propertyNames->value, value); + row->putDirect(vm, Identifier::fromString(vm, "available"_s), jsBoolean(!isUnavailableFunction(value))); + result->putDirectIndex(globalObject, i, row); + RETURN_IF_EXCEPTION(scope, { }); + } + return result; +} + +} // namespace JSC + +#endif // USE(BUN_JSC_ADDITIONS) diff --git a/Source/JavaScriptCore/runtime/JSCPrimordials.h b/Source/JavaScriptCore/runtime/JSCPrimordials.h new file mode 100644 index 0000000000000..38cb80e2afbc9 --- /dev/null +++ b/Source/JavaScriptCore/runtime/JSCPrimordials.h @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2019 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#if USE(BUN_JSC_ADDITIONS) + +#include "JSCPrimordialsTable.h" +#include + +namespace JSC { + +// Primordials are tamper-proof references to the original ECMAScript built-ins, +// exposed to builtin JavaScript as link-time constants with Node.js's primordial +// naming, so modules ported from Node's lib/ keep their call sites: +// +// @ArrayPrototypePush.@call(array, value); // prototype method +// @ObjectDefineProperty(obj, key, desc); // static method +// @MapPrototypeGetSize.@call(map); // accessor getter +// @SymbolIterator // value +// @ArrayPrototype // a holder object itself +// +// Each primordial is a lazy link-time constant, materialized on the first +// CodeBlock link that references it. The pristine source is one of: +// +// - the holder's own property, snapshotted at the holder's creation +// (JSGlobalObject::snapshotPrimordialsFromHolder) before user code can +// reach the holder: end of JSGlobalObject::init() for the eager holders, +// and the LazyClassStructure / LazyProperty / static-table PropertyCallback +// that creates a lazy holder. This is a key lookup + getDirect + pointer +// store per entry; it does not reify, allocate on, or transition the holder. +// - the holder's ClassInfo static hash tables, which user code cannot +// mutate. A property still lazy at link time is looked up in the tables of +// the (possibly freshly created) holder. If the holder still holds the +// untouched entry, it is reified there (a one-time structure transition +// on that holder) so the primordial and the property share one identity; +// otherwise a fresh, un-installed copy is built from the immutable entry. +// - for Self entries, the holder object itself, which JSC reaches through +// its own accessors, never through the (mutable) global bindings. +// +// A key present in neither an own property nor a table is a builtin the +// current configuration does not expose (e.g. runtime-flagged); its primordial +// is a function that throws when called instead of a crash at capture time. An +// embedder that replaces a builtin during its own global setup calls +// overridePrimordialsFromHolder() so the primordial is what user code sees. +// +// The per-holder tables in JSCPrimordialsTable.h are generated by +// src/codegen/generate-primordials.ts in oven-sh/bun from Node.js's primordials +// construction applied to this engine, as +// +// JSC_FOREACH_PRIMORDIAL_(V) → V(name, key, kind) +// +// where key is PROP("string") | SYM(wellKnownSymbolName) | SELF and kind is +// Method value is a function (data property or table entry) +// Getter value is the accessor's getter function +// Setter value is the accessor's setter function +// Value value is an own object or symbol (constructor prototypes, well-known symbols) +// Self value is the holder object itself +// JSC_FOREACH_PRIMORDIAL_NAME(V) is the union whose expansion order defines each +// primordial's link-time-constant index; JSC_FOREACH_PRIMORDIAL_HOLDER(H) enumerates +// holders in that same order (eager first, then lazy). + +enum class PrimordialHolder : uint8_t { +#define DECLARE_PRIMORDIAL_HOLDER(Holder) Holder, + JSC_FOREACH_PRIMORDIAL_HOLDER(DECLARE_PRIMORDIAL_HOLDER) +#undef DECLARE_PRIMORDIAL_HOLDER +}; + +enum class PrimordialKind : uint8_t { + Method, + Getter, + Setter, + Value, + Self, +}; + +#define JSC_COUNT_PRIMORDIAL(name, key, kind) 1 + +static constexpr unsigned numberOfPrimordials = JSC_FOREACH_PRIMORDIAL_NAME(JSC_COUNT_PRIMORDIAL) 0; +#undef JSC_COUNT_PRIMORDIAL + +} // namespace JSC + +#endif // USE(BUN_JSC_ADDITIONS) diff --git a/Source/JavaScriptCore/runtime/JSCPrimordialsTable.h b/Source/JavaScriptCore/runtime/JSCPrimordialsTable.h new file mode 100644 index 0000000000000..d9a5e1b72afa9 --- /dev/null +++ b/Source/JavaScriptCore/runtime/JSCPrimordialsTable.h @@ -0,0 +1,1223 @@ +// GENERATED FILE — do not edit. Regenerate with: +// bun src/codegen/generate-primordials.ts --bun= --webkit= +// (src/codegen in oven-sh/bun). Derived from Node.js's primordials construction +// applied to this engine's intrinsics; see JSCPrimordials.h for the mechanism. + +#pragma once + +#if USE(BUN_JSC_ADDITIONS) + +namespace JSC { + +// V(name, key, kind): key is PROP("string"), SYM(wellKnownSymbolName), or SELF +// (the holder object itself); kind is Method | Getter | Setter | Value | Self. + +#define JSC_FOREACH_PRIMORDIAL_GlobalObject(V) \ + V(globalThis, PROP("globalThis"), Value) \ + V(decodeURI, PROP("decodeURI"), Method) \ + V(decodeURIComponent, PROP("decodeURIComponent"), Method) \ + V(encodeURI, PROP("encodeURI"), Method) \ + V(encodeURIComponent, PROP("encodeURIComponent"), Method) \ + V(escape, PROP("escape"), Method) \ + V(eval, PROP("eval"), Method) \ + V(unescape, PROP("unescape"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ObjectPrototype(V) \ + V(ObjectPrototype, SELF, Self) \ + V(ObjectPrototypeToString, PROP("toString"), Method) \ + V(ObjectPrototypeToLocaleString, PROP("toLocaleString"), Method) \ + V(ObjectPrototypeValueOf, PROP("valueOf"), Method) \ + V(ObjectPrototypeHasOwnProperty, PROP("hasOwnProperty"), Method) \ + V(ObjectPrototypePropertyIsEnumerable, PROP("propertyIsEnumerable"), Method) \ + V(ObjectPrototypeIsPrototypeOf, PROP("isPrototypeOf"), Method) \ + V(ObjectPrototype__defineGetter__, PROP("__defineGetter__"), Method) \ + V(ObjectPrototype__defineSetter__, PROP("__defineSetter__"), Method) \ + V(ObjectPrototype__lookupGetter__, PROP("__lookupGetter__"), Method) \ + V(ObjectPrototype__lookupSetter__, PROP("__lookupSetter__"), Method) \ + V(ObjectPrototypeGet__proto__, PROP("__proto__"), Getter) \ + V(ObjectPrototypeSet__proto__, PROP("__proto__"), Setter) \ + V(ObjectPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ObjectConstructor(V) \ + V(ObjectGetPrototypeOf, PROP("getPrototypeOf"), Method) \ + V(ObjectSetPrototypeOf, PROP("setPrototypeOf"), Method) \ + V(ObjectGetOwnPropertyDescriptor, PROP("getOwnPropertyDescriptor"), Method) \ + V(ObjectGetOwnPropertyDescriptors, PROP("getOwnPropertyDescriptors"), Method) \ + V(ObjectGetOwnPropertyNames, PROP("getOwnPropertyNames"), Method) \ + V(ObjectGetOwnPropertySymbols, PROP("getOwnPropertySymbols"), Method) \ + V(ObjectKeys, PROP("keys"), Method) \ + V(ObjectDefineProperty, PROP("defineProperty"), Method) \ + V(ObjectDefineProperties, PROP("defineProperties"), Method) \ + V(ObjectCreate, PROP("create"), Method) \ + V(ObjectSeal, PROP("seal"), Method) \ + V(ObjectFreeze, PROP("freeze"), Method) \ + V(ObjectPreventExtensions, PROP("preventExtensions"), Method) \ + V(ObjectIsSealed, PROP("isSealed"), Method) \ + V(ObjectIsFrozen, PROP("isFrozen"), Method) \ + V(ObjectIsExtensible, PROP("isExtensible"), Method) \ + V(ObjectIs, PROP("is"), Method) \ + V(ObjectAssign, PROP("assign"), Method) \ + V(ObjectValues, PROP("values"), Method) \ + V(ObjectEntries, PROP("entries"), Method) \ + V(ObjectFromEntries, PROP("fromEntries"), Method) \ + V(ObjectHasOwn, PROP("hasOwn"), Method) \ + V(ObjectGroupBy, PROP("groupBy"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_FunctionPrototype(V) \ + V(FunctionPrototypeToString, PROP("toString"), Method) \ + V(FunctionPrototypeApply, PROP("apply"), Method) \ + V(FunctionPrototypeCall, PROP("call"), Method) \ + V(FunctionPrototypeBind, PROP("bind"), Method) \ + V(FunctionPrototypeGetArguments, PROP("arguments"), Getter) \ + V(FunctionPrototypeSetArguments, PROP("arguments"), Setter) \ + V(FunctionPrototypeGetCaller, PROP("caller"), Getter) \ + V(FunctionPrototypeSetCaller, PROP("caller"), Setter) \ + V(FunctionPrototypeConstructor, PROP("constructor"), Method) \ + V(FunctionPrototypeSymbolHasInstance, SYM(hasInstance), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_FunctionConstructor(V) \ + V(Function, SELF, Self) \ + V(FunctionPrototype, PROP("prototype"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ArrayPrototype(V) \ + V(ArrayPrototype, SELF, Self) \ + V(ArrayPrototypeToString, PROP("toString"), Method) \ + V(ArrayPrototypeValues, PROP("values"), Method) \ + V(ArrayPrototypeToLocaleString, PROP("toLocaleString"), Method) \ + V(ArrayPrototypeConcat, PROP("concat"), Method) \ + V(ArrayPrototypeFill, PROP("fill"), Method) \ + V(ArrayPrototypeJoin, PROP("join"), Method) \ + V(ArrayPrototypePop, PROP("pop"), Method) \ + V(ArrayPrototypePush, PROP("push"), Method) \ + V(ArrayPrototypeReverse, PROP("reverse"), Method) \ + V(ArrayPrototypeShift, PROP("shift"), Method) \ + V(ArrayPrototypeSlice, PROP("slice"), Method) \ + V(ArrayPrototypeSort, PROP("sort"), Method) \ + V(ArrayPrototypeSplice, PROP("splice"), Method) \ + V(ArrayPrototypeUnshift, PROP("unshift"), Method) \ + V(ArrayPrototypeEvery, PROP("every"), Method) \ + V(ArrayPrototypeForEach, PROP("forEach"), Method) \ + V(ArrayPrototypeSome, PROP("some"), Method) \ + V(ArrayPrototypeIndexOf, PROP("indexOf"), Method) \ + V(ArrayPrototypeLastIndexOf, PROP("lastIndexOf"), Method) \ + V(ArrayPrototypeFilter, PROP("filter"), Method) \ + V(ArrayPrototypeFlat, PROP("flat"), Method) \ + V(ArrayPrototypeFlatMap, PROP("flatMap"), Method) \ + V(ArrayPrototypeReduce, PROP("reduce"), Method) \ + V(ArrayPrototypeReduceRight, PROP("reduceRight"), Method) \ + V(ArrayPrototypeMap, PROP("map"), Method) \ + V(ArrayPrototypeKeys, PROP("keys"), Method) \ + V(ArrayPrototypeEntries, PROP("entries"), Method) \ + V(ArrayPrototypeFind, PROP("find"), Method) \ + V(ArrayPrototypeFindLast, PROP("findLast"), Method) \ + V(ArrayPrototypeFindIndex, PROP("findIndex"), Method) \ + V(ArrayPrototypeFindLastIndex, PROP("findLastIndex"), Method) \ + V(ArrayPrototypeIncludes, PROP("includes"), Method) \ + V(ArrayPrototypeCopyWithin, PROP("copyWithin"), Method) \ + V(ArrayPrototypeAt, PROP("at"), Method) \ + V(ArrayPrototypeToReversed, PROP("toReversed"), Method) \ + V(ArrayPrototypeToSorted, PROP("toSorted"), Method) \ + V(ArrayPrototypeToSpliced, PROP("toSpliced"), Method) \ + V(ArrayPrototypeWith, PROP("with"), Method) \ + V(ArrayPrototypeConstructor, PROP("constructor"), Method) \ + V(ArrayPrototypeSymbolIterator, SYM(iterator), Method) \ + V(ArrayPrototypeSymbolUnscopables, SYM(unscopables), Value) \ + +#define JSC_FOREACH_PRIMORDIAL_ArrayConstructor(V) \ + V(ArrayFrom, PROP("from"), Method) \ + V(ArrayOf, PROP("of"), Method) \ + V(ArrayIsArray, PROP("isArray"), Method) \ + V(ArrayFromAsync, PROP("fromAsync"), Method) \ + V(ArrayGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_StringPrototype(V) \ + V(StringPrototype, SELF, Self) \ + V(StringPrototypeAnchor, PROP("anchor"), Method) \ + V(StringPrototypeBig, PROP("big"), Method) \ + V(StringPrototypeBold, PROP("bold"), Method) \ + V(StringPrototypeBlink, PROP("blink"), Method) \ + V(StringPrototypeFixed, PROP("fixed"), Method) \ + V(StringPrototypeFontcolor, PROP("fontcolor"), Method) \ + V(StringPrototypeFontsize, PROP("fontsize"), Method) \ + V(StringPrototypeItalics, PROP("italics"), Method) \ + V(StringPrototypeLink, PROP("link"), Method) \ + V(StringPrototypeSmall, PROP("small"), Method) \ + V(StringPrototypeStrike, PROP("strike"), Method) \ + V(StringPrototypeSub, PROP("sub"), Method) \ + V(StringPrototypeSup, PROP("sup"), Method) \ + V(StringPrototypeToString, PROP("toString"), Method) \ + V(StringPrototypeValueOf, PROP("valueOf"), Method) \ + V(StringPrototypeCharAt, PROP("charAt"), Method) \ + V(StringPrototypeCharCodeAt, PROP("charCodeAt"), Method) \ + V(StringPrototypeCodePointAt, PROP("codePointAt"), Method) \ + V(StringPrototypeConcat, PROP("concat"), Method) \ + V(StringPrototypeIndexOf, PROP("indexOf"), Method) \ + V(StringPrototypeLastIndexOf, PROP("lastIndexOf"), Method) \ + V(StringPrototypeReplace, PROP("replace"), Method) \ + V(StringPrototypeReplaceAll, PROP("replaceAll"), Method) \ + V(StringPrototypeRepeat, PROP("repeat"), Method) \ + V(StringPrototypePadStart, PROP("padStart"), Method) \ + V(StringPrototypePadEnd, PROP("padEnd"), Method) \ + V(StringPrototypeSlice, PROP("slice"), Method) \ + V(StringPrototypeSubstr, PROP("substr"), Method) \ + V(StringPrototypeAt, PROP("at"), Method) \ + V(StringPrototypeSubstring, PROP("substring"), Method) \ + V(StringPrototypeToLowerCase, PROP("toLowerCase"), Method) \ + V(StringPrototypeToUpperCase, PROP("toUpperCase"), Method) \ + V(StringPrototypeLocaleCompare, PROP("localeCompare"), Method) \ + V(StringPrototypeToLocaleLowerCase, PROP("toLocaleLowerCase"), Method) \ + V(StringPrototypeToLocaleUpperCase, PROP("toLocaleUpperCase"), Method) \ + V(StringPrototypeTrim, PROP("trim"), Method) \ + V(StringPrototypeStartsWith, PROP("startsWith"), Method) \ + V(StringPrototypeEndsWith, PROP("endsWith"), Method) \ + V(StringPrototypeIncludes, PROP("includes"), Method) \ + V(StringPrototypeMatch, PROP("match"), Method) \ + V(StringPrototypeSearch, PROP("search"), Method) \ + V(StringPrototypeMatchAll, PROP("matchAll"), Method) \ + V(StringPrototypeSplit, PROP("split"), Method) \ + V(StringPrototypeNormalize, PROP("normalize"), Method) \ + V(StringPrototypeTrimStart, PROP("trimStart"), Method) \ + V(StringPrototypeTrimLeft, PROP("trimLeft"), Method) \ + V(StringPrototypeTrimEnd, PROP("trimEnd"), Method) \ + V(StringPrototypeTrimRight, PROP("trimRight"), Method) \ + V(StringPrototypeIsWellFormed, PROP("isWellFormed"), Method) \ + V(StringPrototypeToWellFormed, PROP("toWellFormed"), Method) \ + V(StringPrototypeConstructor, PROP("constructor"), Method) \ + V(StringPrototypeSymbolIterator, SYM(iterator), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_StringConstructor(V) \ + V(StringFromCharCode, PROP("fromCharCode"), Method) \ + V(StringFromCodePoint, PROP("fromCodePoint"), Method) \ + V(StringRaw, PROP("raw"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_RegExpPrototype(V) \ + V(RegExpPrototype, SELF, Self) \ + V(RegExpPrototypeCompile, PROP("compile"), Method) \ + V(RegExpPrototypeExec, PROP("exec"), Method) \ + V(RegExpPrototypeToString, PROP("toString"), Method) \ + V(RegExpPrototypeGetGlobal, PROP("global"), Getter) \ + V(RegExpPrototypeGetDotAll, PROP("dotAll"), Getter) \ + V(RegExpPrototypeGetHasIndices, PROP("hasIndices"), Getter) \ + V(RegExpPrototypeGetIgnoreCase, PROP("ignoreCase"), Getter) \ + V(RegExpPrototypeGetMultiline, PROP("multiline"), Getter) \ + V(RegExpPrototypeGetSticky, PROP("sticky"), Getter) \ + V(RegExpPrototypeGetUnicode, PROP("unicode"), Getter) \ + V(RegExpPrototypeGetUnicodeSets, PROP("unicodeSets"), Getter) \ + V(RegExpPrototypeGetSource, PROP("source"), Getter) \ + V(RegExpPrototypeGetFlags, PROP("flags"), Getter) \ + V(RegExpPrototypeTest, PROP("test"), Method) \ + V(RegExpPrototypeConstructor, PROP("constructor"), Method) \ + V(RegExpPrototypeSymbolMatch, SYM(match), Method) \ + V(RegExpPrototypeSymbolMatchAll, SYM(matchAll), Method) \ + V(RegExpPrototypeSymbolReplace, SYM(replace), Method) \ + V(RegExpPrototypeSymbolSearch, SYM(search), Method) \ + V(RegExpPrototypeSymbolSplit, SYM(split), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_RegExpConstructor(V) \ + V(RegExpGetInput, PROP("input"), Getter) \ + V(RegExpSetInput, PROP("input"), Setter) \ + V(RegExpGetDollarUnderscore, PROP("$_"), Getter) \ + V(RegExpSetDollarUnderscore, PROP("$_"), Setter) \ + V(RegExpGetMultiline, PROP("multiline"), Getter) \ + V(RegExpSetMultiline, PROP("multiline"), Setter) \ + V(RegExpGetDollarAsterisk, PROP("$*"), Getter) \ + V(RegExpSetDollarAsterisk, PROP("$*"), Setter) \ + V(RegExpGetLastMatch, PROP("lastMatch"), Getter) \ + V(RegExpGetDollarAmpersand, PROP("$&"), Getter) \ + V(RegExpGetLastParen, PROP("lastParen"), Getter) \ + V(RegExpGetDollarPlus, PROP("$+"), Getter) \ + V(RegExpGetLeftContext, PROP("leftContext"), Getter) \ + V(RegExpGetDollarBacktick, PROP("$`"), Getter) \ + V(RegExpGetRightContext, PROP("rightContext"), Getter) \ + V(RegExpGetDollarApostrophe, PROP("$'"), Getter) \ + V(RegExpGetDollar1, PROP("$1"), Getter) \ + V(RegExpGetDollar2, PROP("$2"), Getter) \ + V(RegExpGetDollar3, PROP("$3"), Getter) \ + V(RegExpGetDollar4, PROP("$4"), Getter) \ + V(RegExpGetDollar5, PROP("$5"), Getter) \ + V(RegExpGetDollar6, PROP("$6"), Getter) \ + V(RegExpGetDollar7, PROP("$7"), Getter) \ + V(RegExpGetDollar8, PROP("$8"), Getter) \ + V(RegExpGetDollar9, PROP("$9"), Getter) \ + V(RegExpEscape, PROP("escape"), Method) \ + V(RegExpGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_SymbolPrototype(V) \ + V(SymbolPrototype, SELF, Self) \ + V(SymbolPrototypeGetDescription, PROP("description"), Getter) \ + V(SymbolPrototypeToString, PROP("toString"), Method) \ + V(SymbolPrototypeValueOf, PROP("valueOf"), Method) \ + V(SymbolPrototypeConstructor, PROP("constructor"), Method) \ + V(SymbolPrototypeSymbolToPrimitive, SYM(toPrimitive), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_SymbolConstructor(V) \ + V(Symbol, SELF, Self) \ + V(SymbolFor, PROP("for"), Method) \ + V(SymbolKeyFor, PROP("keyFor"), Method) \ + V(SymbolHasInstance, PROP("hasInstance"), Value) \ + V(SymbolIsConcatSpreadable, PROP("isConcatSpreadable"), Value) \ + V(SymbolAsyncIterator, PROP("asyncIterator"), Value) \ + V(SymbolIterator, PROP("iterator"), Value) \ + V(SymbolMatch, PROP("match"), Value) \ + V(SymbolMatchAll, PROP("matchAll"), Value) \ + V(SymbolReplace, PROP("replace"), Value) \ + V(SymbolSearch, PROP("search"), Value) \ + V(SymbolSpecies, PROP("species"), Value) \ + V(SymbolSplit, PROP("split"), Value) \ + V(SymbolToPrimitive, PROP("toPrimitive"), Value) \ + V(SymbolToStringTag, PROP("toStringTag"), Value) \ + V(SymbolUnscopables, PROP("unscopables"), Value) \ + V(SymbolDispose, PROP("dispose"), Value) \ + V(SymbolAsyncDispose, PROP("asyncDispose"), Value) \ + +#define JSC_FOREACH_PRIMORDIAL_BigIntPrototype(V) \ + V(BigIntPrototype, SELF, Self) \ + V(BigIntPrototypeToString, PROP("toString"), Method) \ + V(BigIntPrototypeToLocaleString, PROP("toLocaleString"), Method) \ + V(BigIntPrototypeValueOf, PROP("valueOf"), Method) \ + V(BigIntPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_BigIntConstructor(V) \ + V(BigInt, SELF, Self) \ + V(BigIntAsUintN, PROP("asUintN"), Method) \ + V(BigIntAsIntN, PROP("asIntN"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_PromisePrototype(V) \ + V(PromisePrototype, SELF, Self) \ + V(PromisePrototypeFinally, PROP("finally"), Method) \ + V(PromisePrototypeThen, PROP("then"), Method) \ + V(PromisePrototypeCatch, PROP("catch"), Method) \ + V(PromisePrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_PromiseConstructor(V) \ + V(PromiseResolve, PROP("resolve"), Method) \ + V(PromiseReject, PROP("reject"), Method) \ + V(PromiseRace, PROP("race"), Method) \ + V(PromiseAll, PROP("all"), Method) \ + V(PromiseAllSettled, PROP("allSettled"), Method) \ + V(PromiseAny, PROP("any"), Method) \ + V(PromiseWithResolvers, PROP("withResolvers"), Method) \ + V(PromiseTry, PROP("try"), Method) \ + V(PromiseGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_IteratorPrototype(V) \ + V(IteratorPrototype, SELF, Self) \ + V(IteratorPrototypeGetConstructor, PROP("constructor"), Getter) \ + V(IteratorPrototypeSetConstructor, PROP("constructor"), Setter) \ + V(IteratorPrototypeToArray, PROP("toArray"), Method) \ + V(IteratorPrototypeForEach, PROP("forEach"), Method) \ + V(IteratorPrototypeSome, PROP("some"), Method) \ + V(IteratorPrototypeEvery, PROP("every"), Method) \ + V(IteratorPrototypeFind, PROP("find"), Method) \ + V(IteratorPrototypeReduce, PROP("reduce"), Method) \ + V(IteratorPrototypeMap, PROP("map"), Method) \ + V(IteratorPrototypeFilter, PROP("filter"), Method) \ + V(IteratorPrototypeTake, PROP("take"), Method) \ + V(IteratorPrototypeDrop, PROP("drop"), Method) \ + V(IteratorPrototypeFlatMap, PROP("flatMap"), Method) \ + V(IteratorPrototypeIncludes, PROP("includes"), Method) \ + V(IteratorPrototypeSymbolIterator, SYM(iterator), Method) \ + V(IteratorPrototypeGetSymbolToStringTag, SYM(toStringTag), Getter) \ + V(IteratorPrototypeSetSymbolToStringTag, SYM(toStringTag), Setter) \ + V(IteratorPrototypeSymbolDispose, SYM(dispose), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_IteratorConstructor(V) \ + V(IteratorFrom, PROP("from"), Method) \ + V(IteratorConcat, PROP("concat"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ArrayIteratorPrototype(V) \ + V(ArrayIteratorPrototype, SELF, Self) \ + V(ArrayIteratorPrototypeNext, PROP("next"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_StringIteratorPrototype(V) \ + V(StringIteratorPrototype, SELF, Self) \ + V(StringIteratorPrototypeNext, PROP("next"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_MapIteratorPrototype(V) \ + V(MapIteratorPrototype, SELF, Self) \ + V(MapIteratorPrototypeNext, PROP("next"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_SetIteratorPrototype(V) \ + V(SetIteratorPrototype, SELF, Self) \ + V(SetIteratorPrototypeNext, PROP("next"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_RegExpStringIteratorPrototype(V) \ + V(RegExpStringIteratorPrototype, SELF, Self) \ + V(RegExpStringIteratorPrototypeNext, PROP("next"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_IteratorHelperPrototype(V) \ + V(IteratorHelperPrototype, SELF, Self) \ + V(IteratorHelperPrototypeNext, PROP("next"), Method) \ + V(IteratorHelperPrototypeReturn, PROP("return"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_WrapForValidIteratorPrototype(V) \ + V(WrapForValidIteratorPrototype, SELF, Self) \ + V(WrapForValidIteratorPrototypeNext, PROP("next"), Method) \ + V(WrapForValidIteratorPrototypeReturn, PROP("return"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_AsyncIteratorPrototype(V) \ + V(AsyncIteratorPrototype, SELF, Self) \ + V(AsyncIteratorPrototypeSymbolAsyncIterator, SYM(asyncIterator), Method) \ + V(AsyncIteratorPrototypeSymbolAsyncDispose, SYM(asyncDispose), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_GeneratorFunctionPrototype(V) \ + V(GeneratorFunctionPrototype, SELF, Self) \ + V(GeneratorFunctionPrototypeConstructor, PROP("constructor"), Method) \ + V(GeneratorFunctionPrototypePrototype, PROP("prototype"), Value) \ + +#define JSC_FOREACH_PRIMORDIAL_AsyncFunctionPrototype(V) \ + V(AsyncFunctionPrototype, SELF, Self) \ + V(AsyncFunctionPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_AsyncGeneratorFunctionPrototype(V) \ + V(AsyncGeneratorFunctionPrototype, SELF, Self) \ + V(AsyncGeneratorFunctionPrototypeConstructor, PROP("constructor"), Method) \ + V(AsyncGeneratorFunctionPrototypePrototype, PROP("prototype"), Value) \ + +#define JSC_FOREACH_PRIMORDIAL_WeakRefPrototype(V) \ + V(WeakRefPrototype, SELF, Self) \ + V(WeakRefPrototypeDeref, PROP("deref"), Method) \ + V(WeakRefPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_WeakRefConstructor(V) \ + V(WeakRef, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_FinalizationRegistryPrototype(V) \ + V(FinalizationRegistryPrototype, SELF, Self) \ + V(FinalizationRegistryPrototypeRegister, PROP("register"), Method) \ + V(FinalizationRegistryPrototypeUnregister, PROP("unregister"), Method) \ + V(FinalizationRegistryPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_FinalizationRegistryConstructor(V) \ + V(FinalizationRegistry, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_BooleanPrototype(V) \ + V(BooleanPrototype, SELF, Self) \ + V(BooleanPrototypeToString, PROP("toString"), Method) \ + V(BooleanPrototypeValueOf, PROP("valueOf"), Method) \ + V(BooleanPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_BooleanConstructor(V) \ + V(Boolean, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_NumberPrototype(V) \ + V(NumberPrototype, SELF, Self) \ + V(NumberPrototypeToLocaleString, PROP("toLocaleString"), Method) \ + V(NumberPrototypeValueOf, PROP("valueOf"), Method) \ + V(NumberPrototypeToFixed, PROP("toFixed"), Method) \ + V(NumberPrototypeToExponential, PROP("toExponential"), Method) \ + V(NumberPrototypeToPrecision, PROP("toPrecision"), Method) \ + V(NumberPrototypeToString, PROP("toString"), Method) \ + V(NumberPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_NumberConstructor(V) \ + V(NumberPrimordial, SELF, Self) \ + V(NumberIsFinite, PROP("isFinite"), Method) \ + V(NumberIsNaN, PROP("isNaN"), Method) \ + V(NumberIsSafeInteger, PROP("isSafeInteger"), Method) \ + V(NumberParseInt, PROP("parseInt"), Method) \ + V(NumberParseFloat, PROP("parseFloat"), Method) \ + V(NumberIsInteger, PROP("isInteger"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_DatePrototype(V) \ + V(DatePrototype, SELF, Self) \ + V(DatePrototypeToString, PROP("toString"), Method) \ + V(DatePrototypeToISOString, PROP("toISOString"), Method) \ + V(DatePrototypeToDateString, PROP("toDateString"), Method) \ + V(DatePrototypeToTimeString, PROP("toTimeString"), Method) \ + V(DatePrototypeToLocaleString, PROP("toLocaleString"), Method) \ + V(DatePrototypeToLocaleDateString, PROP("toLocaleDateString"), Method) \ + V(DatePrototypeToLocaleTimeString, PROP("toLocaleTimeString"), Method) \ + V(DatePrototypeValueOf, PROP("valueOf"), Method) \ + V(DatePrototypeGetTime, PROP("getTime"), Method) \ + V(DatePrototypeGetFullYear, PROP("getFullYear"), Method) \ + V(DatePrototypeGetUTCFullYear, PROP("getUTCFullYear"), Method) \ + V(DatePrototypeGetMonth, PROP("getMonth"), Method) \ + V(DatePrototypeGetUTCMonth, PROP("getUTCMonth"), Method) \ + V(DatePrototypeGetDate, PROP("getDate"), Method) \ + V(DatePrototypeGetUTCDate, PROP("getUTCDate"), Method) \ + V(DatePrototypeGetDay, PROP("getDay"), Method) \ + V(DatePrototypeGetUTCDay, PROP("getUTCDay"), Method) \ + V(DatePrototypeGetHours, PROP("getHours"), Method) \ + V(DatePrototypeGetUTCHours, PROP("getUTCHours"), Method) \ + V(DatePrototypeGetMinutes, PROP("getMinutes"), Method) \ + V(DatePrototypeGetUTCMinutes, PROP("getUTCMinutes"), Method) \ + V(DatePrototypeGetSeconds, PROP("getSeconds"), Method) \ + V(DatePrototypeGetUTCSeconds, PROP("getUTCSeconds"), Method) \ + V(DatePrototypeGetMilliseconds, PROP("getMilliseconds"), Method) \ + V(DatePrototypeGetUTCMilliseconds, PROP("getUTCMilliseconds"), Method) \ + V(DatePrototypeGetTimezoneOffset, PROP("getTimezoneOffset"), Method) \ + V(DatePrototypeGetYear, PROP("getYear"), Method) \ + V(DatePrototypeSetTime, PROP("setTime"), Method) \ + V(DatePrototypeSetMilliseconds, PROP("setMilliseconds"), Method) \ + V(DatePrototypeSetUTCMilliseconds, PROP("setUTCMilliseconds"), Method) \ + V(DatePrototypeSetSeconds, PROP("setSeconds"), Method) \ + V(DatePrototypeSetUTCSeconds, PROP("setUTCSeconds"), Method) \ + V(DatePrototypeSetMinutes, PROP("setMinutes"), Method) \ + V(DatePrototypeSetUTCMinutes, PROP("setUTCMinutes"), Method) \ + V(DatePrototypeSetHours, PROP("setHours"), Method) \ + V(DatePrototypeSetUTCHours, PROP("setUTCHours"), Method) \ + V(DatePrototypeSetDate, PROP("setDate"), Method) \ + V(DatePrototypeSetUTCDate, PROP("setUTCDate"), Method) \ + V(DatePrototypeSetMonth, PROP("setMonth"), Method) \ + V(DatePrototypeSetUTCMonth, PROP("setUTCMonth"), Method) \ + V(DatePrototypeSetFullYear, PROP("setFullYear"), Method) \ + V(DatePrototypeSetUTCFullYear, PROP("setUTCFullYear"), Method) \ + V(DatePrototypeSetYear, PROP("setYear"), Method) \ + V(DatePrototypeToJSON, PROP("toJSON"), Method) \ + V(DatePrototypeToUTCString, PROP("toUTCString"), Method) \ + V(DatePrototypeToGMTString, PROP("toGMTString"), Method) \ + V(DatePrototypeConstructor, PROP("constructor"), Method) \ + V(DatePrototypeSymbolToPrimitive, SYM(toPrimitive), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_DateConstructor(V) \ + V(Date, SELF, Self) \ + V(DateParse, PROP("parse"), Method) \ + V(DateUTC, PROP("UTC"), Method) \ + V(DateNow, PROP("now"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ErrorPrototype(V) \ + V(ErrorPrototype, SELF, Self) \ + V(ErrorPrototypeToString, PROP("toString"), Method) \ + V(ErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ErrorConstructor(V) \ + V(Error, SELF, Self) \ + V(ErrorCaptureStackTrace, PROP("captureStackTrace"), Method) \ + V(ErrorIsError, PROP("isError"), Method) \ + V(ErrorAppendStackTrace, PROP("appendStackTrace"), Method) \ + V(ErrorPrepareStackTrace, PROP("prepareStackTrace"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_MapPrototype(V) \ + V(MapPrototype, SELF, Self) \ + V(MapPrototypeClear, PROP("clear"), Method) \ + V(MapPrototypeDelete, PROP("delete"), Method) \ + V(MapPrototypeEntries, PROP("entries"), Method) \ + V(MapPrototypeForEach, PROP("forEach"), Method) \ + V(MapPrototypeGet, PROP("get"), Method) \ + V(MapPrototypeHas, PROP("has"), Method) \ + V(MapPrototypeKeys, PROP("keys"), Method) \ + V(MapPrototypeSet, PROP("set"), Method) \ + V(MapPrototypeGetOrInsert, PROP("getOrInsert"), Method) \ + V(MapPrototypeGetOrInsertComputed, PROP("getOrInsertComputed"), Method) \ + V(MapPrototypeGetSize, PROP("size"), Getter) \ + V(MapPrototypeValues, PROP("values"), Method) \ + V(MapPrototypeConstructor, PROP("constructor"), Method) \ + V(MapPrototypeSymbolIterator, SYM(iterator), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_MapConstructor(V) \ + V(MapGroupBy, PROP("groupBy"), Method) \ + V(MapGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_SetPrototype(V) \ + V(SetPrototype, SELF, Self) \ + V(SetPrototypeAdd, PROP("add"), Method) \ + V(SetPrototypeClear, PROP("clear"), Method) \ + V(SetPrototypeDelete, PROP("delete"), Method) \ + V(SetPrototypeEntries, PROP("entries"), Method) \ + V(SetPrototypeForEach, PROP("forEach"), Method) \ + V(SetPrototypeHas, PROP("has"), Method) \ + V(SetPrototypeKeys, PROP("keys"), Method) \ + V(SetPrototypeGetSize, PROP("size"), Getter) \ + V(SetPrototypeValues, PROP("values"), Method) \ + V(SetPrototypeUnion, PROP("union"), Method) \ + V(SetPrototypeIntersection, PROP("intersection"), Method) \ + V(SetPrototypeDifference, PROP("difference"), Method) \ + V(SetPrototypeSymmetricDifference, PROP("symmetricDifference"), Method) \ + V(SetPrototypeIsSubsetOf, PROP("isSubsetOf"), Method) \ + V(SetPrototypeIsSupersetOf, PROP("isSupersetOf"), Method) \ + V(SetPrototypeIsDisjointFrom, PROP("isDisjointFrom"), Method) \ + V(SetPrototypeConstructor, PROP("constructor"), Method) \ + V(SetPrototypeSymbolIterator, SYM(iterator), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_SetConstructor(V) \ + V(SetGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_WeakMapPrototype(V) \ + V(WeakMapPrototype, SELF, Self) \ + V(WeakMapPrototypeDelete, PROP("delete"), Method) \ + V(WeakMapPrototypeGet, PROP("get"), Method) \ + V(WeakMapPrototypeHas, PROP("has"), Method) \ + V(WeakMapPrototypeSet, PROP("set"), Method) \ + V(WeakMapPrototypeGetOrInsert, PROP("getOrInsert"), Method) \ + V(WeakMapPrototypeGetOrInsertComputed, PROP("getOrInsertComputed"), Method) \ + V(WeakMapPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_WeakMapConstructor(V) \ + V(WeakMap, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_WeakSetPrototype(V) \ + V(WeakSetPrototype, SELF, Self) \ + V(WeakSetPrototypeDelete, PROP("delete"), Method) \ + V(WeakSetPrototypeHas, PROP("has"), Method) \ + V(WeakSetPrototypeAdd, PROP("add"), Method) \ + V(WeakSetPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_WeakSetConstructor(V) \ + V(WeakSet, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_ArrayBufferPrototype(V) \ + V(ArrayBufferPrototype, SELF, Self) \ + V(ArrayBufferPrototypeSlice, PROP("slice"), Method) \ + V(ArrayBufferPrototypeGetByteLength, PROP("byteLength"), Getter) \ + V(ArrayBufferPrototypeResize, PROP("resize"), Method) \ + V(ArrayBufferPrototypeTransfer, PROP("transfer"), Method) \ + V(ArrayBufferPrototypeTransferToFixedLength, PROP("transferToFixedLength"), Method) \ + V(ArrayBufferPrototypeGetResizable, PROP("resizable"), Getter) \ + V(ArrayBufferPrototypeGetMaxByteLength, PROP("maxByteLength"), Getter) \ + V(ArrayBufferPrototypeGetDetached, PROP("detached"), Getter) \ + V(ArrayBufferPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ArrayBufferConstructor(V) \ + V(ArrayBufferPrimordial, SELF, Self) \ + V(ArrayBufferIsView, PROP("isView"), Method) \ + V(ArrayBufferGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_AggregateErrorPrototype(V) \ + V(AggregateErrorPrototype, SELF, Self) \ + V(AggregateErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_AggregateErrorConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_EvalErrorPrototype(V) \ + V(EvalErrorPrototype, SELF, Self) \ + V(EvalErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_EvalErrorConstructor(V) \ + V(EvalError, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_RangeErrorPrototype(V) \ + V(RangeErrorPrototype, SELF, Self) \ + V(RangeErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_RangeErrorConstructor(V) \ + V(RangeError, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_ReferenceErrorPrototype(V) \ + V(ReferenceErrorPrototype, SELF, Self) \ + V(ReferenceErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ReferenceErrorConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_SyntaxErrorPrototype(V) \ + V(SyntaxErrorPrototype, SELF, Self) \ + V(SyntaxErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_SyntaxErrorConstructor(V) \ + V(SyntaxError, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_TypeErrorPrototype(V) \ + V(TypeErrorPrototype, SELF, Self) \ + V(TypeErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_TypeErrorConstructor(V) \ + V(TypeError, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_URIErrorPrototype(V) \ + V(URIErrorPrototype, SELF, Self) \ + V(URIErrorPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_URIErrorConstructor(V) \ + V(URIError, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_TypedArrayPrototype(V) \ + V(TypedArrayPrototype, SELF, Self) \ + V(TypedArrayPrototypeToString, PROP("toString"), Method) \ + V(TypedArrayPrototypeGetBuffer, PROP("buffer"), Getter) \ + V(TypedArrayPrototypeGetByteLength, PROP("byteLength"), Getter) \ + V(TypedArrayPrototypeGetByteOffset, PROP("byteOffset"), Getter) \ + V(TypedArrayPrototypeCopyWithin, PROP("copyWithin"), Method) \ + V(TypedArrayPrototypeSort, PROP("sort"), Method) \ + V(TypedArrayPrototypeEvery, PROP("every"), Method) \ + V(TypedArrayPrototypeFilter, PROP("filter"), Method) \ + V(TypedArrayPrototypeEntries, PROP("entries"), Method) \ + V(TypedArrayPrototypeIncludes, PROP("includes"), Method) \ + V(TypedArrayPrototypeFill, PROP("fill"), Method) \ + V(TypedArrayPrototypeFind, PROP("find"), Method) \ + V(TypedArrayPrototypeFindLast, PROP("findLast"), Method) \ + V(TypedArrayPrototypeFindIndex, PROP("findIndex"), Method) \ + V(TypedArrayPrototypeFindLastIndex, PROP("findLastIndex"), Method) \ + V(TypedArrayPrototypeForEach, PROP("forEach"), Method) \ + V(TypedArrayPrototypeIndexOf, PROP("indexOf"), Method) \ + V(TypedArrayPrototypeJoin, PROP("join"), Method) \ + V(TypedArrayPrototypeKeys, PROP("keys"), Method) \ + V(TypedArrayPrototypeLastIndexOf, PROP("lastIndexOf"), Method) \ + V(TypedArrayPrototypeGetLength, PROP("length"), Getter) \ + V(TypedArrayPrototypeMap, PROP("map"), Method) \ + V(TypedArrayPrototypeReduce, PROP("reduce"), Method) \ + V(TypedArrayPrototypeReduceRight, PROP("reduceRight"), Method) \ + V(TypedArrayPrototypeReverse, PROP("reverse"), Method) \ + V(TypedArrayPrototypeSet, PROP("set"), Method) \ + V(TypedArrayPrototypeSlice, PROP("slice"), Method) \ + V(TypedArrayPrototypeSome, PROP("some"), Method) \ + V(TypedArrayPrototypeSubarray, PROP("subarray"), Method) \ + V(TypedArrayPrototypeToLocaleString, PROP("toLocaleString"), Method) \ + V(TypedArrayPrototypeToReversed, PROP("toReversed"), Method) \ + V(TypedArrayPrototypeToSorted, PROP("toSorted"), Method) \ + V(TypedArrayPrototypeWith, PROP("with"), Method) \ + V(TypedArrayPrototypeAt, PROP("at"), Method) \ + V(TypedArrayPrototypeValues, PROP("values"), Method) \ + V(TypedArrayPrototypeConstructor, PROP("constructor"), Method) \ + V(TypedArrayPrototypeGetSymbolToStringTag, SYM(toStringTag), Getter) \ + V(TypedArrayPrototypeSymbolIterator, SYM(iterator), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_TypedArrayConstructor(V) \ + V(TypedArray, SELF, Self) \ + V(TypedArrayOf, PROP("of"), Method) \ + V(TypedArrayFrom, PROP("from"), Method) \ + V(TypedArrayGetSymbolSpecies, SYM(species), Getter) \ + +#define JSC_FOREACH_PRIMORDIAL_DataViewPrototype(V) \ + V(DataViewPrototype, SELF, Self) \ + V(DataViewPrototypeGetInt8, PROP("getInt8"), Method) \ + V(DataViewPrototypeGetUint8, PROP("getUint8"), Method) \ + V(DataViewPrototypeGetInt16, PROP("getInt16"), Method) \ + V(DataViewPrototypeGetUint16, PROP("getUint16"), Method) \ + V(DataViewPrototypeGetInt32, PROP("getInt32"), Method) \ + V(DataViewPrototypeGetUint32, PROP("getUint32"), Method) \ + V(DataViewPrototypeGetFloat16, PROP("getFloat16"), Method) \ + V(DataViewPrototypeGetFloat32, PROP("getFloat32"), Method) \ + V(DataViewPrototypeGetFloat64, PROP("getFloat64"), Method) \ + V(DataViewPrototypeGetBigInt64, PROP("getBigInt64"), Method) \ + V(DataViewPrototypeGetBigUint64, PROP("getBigUint64"), Method) \ + V(DataViewPrototypeSetInt8, PROP("setInt8"), Method) \ + V(DataViewPrototypeSetUint8, PROP("setUint8"), Method) \ + V(DataViewPrototypeSetInt16, PROP("setInt16"), Method) \ + V(DataViewPrototypeSetUint16, PROP("setUint16"), Method) \ + V(DataViewPrototypeSetInt32, PROP("setInt32"), Method) \ + V(DataViewPrototypeSetUint32, PROP("setUint32"), Method) \ + V(DataViewPrototypeSetFloat16, PROP("setFloat16"), Method) \ + V(DataViewPrototypeSetFloat32, PROP("setFloat32"), Method) \ + V(DataViewPrototypeSetFloat64, PROP("setFloat64"), Method) \ + V(DataViewPrototypeSetBigInt64, PROP("setBigInt64"), Method) \ + V(DataViewPrototypeSetBigUint64, PROP("setBigUint64"), Method) \ + V(DataViewPrototypeGetBuffer, PROP("buffer"), Getter) \ + V(DataViewPrototypeGetByteOffset, PROP("byteOffset"), Getter) \ + V(DataViewPrototypeGetByteLength, PROP("byteLength"), Getter) \ + V(DataViewPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_DataViewConstructor(V) \ + V(DataView, SELF, Self) \ + +#define JSC_FOREACH_PRIMORDIAL_Int8ArrayPrototype(V) \ + V(Int8ArrayPrototype, SELF, Self) \ + V(Int8ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Int8ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Uint8ArrayPrototype(V) \ + V(Uint8ArrayPrototype, SELF, Self) \ + V(Uint8ArrayPrototypeSetFromBase64, PROP("setFromBase64"), Method) \ + V(Uint8ArrayPrototypeSetFromHex, PROP("setFromHex"), Method) \ + V(Uint8ArrayPrototypeToBase64, PROP("toBase64"), Method) \ + V(Uint8ArrayPrototypeToHex, PROP("toHex"), Method) \ + V(Uint8ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Uint8ArrayConstructor(V) \ + V(Uint8ArrayFromBase64, PROP("fromBase64"), Method) \ + V(Uint8ArrayFromHex, PROP("fromHex"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Uint8ClampedArrayPrototype(V) \ + V(Uint8ClampedArrayPrototype, SELF, Self) \ + V(Uint8ClampedArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Uint8ClampedArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Int16ArrayPrototype(V) \ + V(Int16ArrayPrototype, SELF, Self) \ + V(Int16ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Int16ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Uint16ArrayPrototype(V) \ + V(Uint16ArrayPrototype, SELF, Self) \ + V(Uint16ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Uint16ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Int32ArrayPrototype(V) \ + V(Int32ArrayPrototype, SELF, Self) \ + V(Int32ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Int32ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Uint32ArrayPrototype(V) \ + V(Uint32ArrayPrototype, SELF, Self) \ + V(Uint32ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Uint32ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Float16ArrayPrototype(V) \ + V(Float16ArrayPrototype, SELF, Self) \ + V(Float16ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Float16ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Float32ArrayPrototype(V) \ + V(Float32ArrayPrototype, SELF, Self) \ + V(Float32ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Float32ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_Float64ArrayPrototype(V) \ + V(Float64ArrayPrototype, SELF, Self) \ + V(Float64ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_Float64ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_BigInt64ArrayPrototype(V) \ + V(BigInt64ArrayPrototype, SELF, Self) \ + V(BigInt64ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_BigInt64ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_BigUint64ArrayPrototype(V) \ + V(BigUint64ArrayPrototype, SELF, Self) \ + V(BigUint64ArrayPrototypeConstructor, PROP("constructor"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_BigUint64ArrayConstructor(V) \ + + + +#define JSC_FOREACH_PRIMORDIAL_MathObject(V) \ + V(MathAbs, PROP("abs"), Method) \ + V(MathAcos, PROP("acos"), Method) \ + V(MathAsin, PROP("asin"), Method) \ + V(MathAtan, PROP("atan"), Method) \ + V(MathAcosh, PROP("acosh"), Method) \ + V(MathAsinh, PROP("asinh"), Method) \ + V(MathAtanh, PROP("atanh"), Method) \ + V(MathAtan2, PROP("atan2"), Method) \ + V(MathCbrt, PROP("cbrt"), Method) \ + V(MathCeil, PROP("ceil"), Method) \ + V(MathClz32, PROP("clz32"), Method) \ + V(MathCos, PROP("cos"), Method) \ + V(MathCosh, PROP("cosh"), Method) \ + V(MathExp, PROP("exp"), Method) \ + V(MathExpm1, PROP("expm1"), Method) \ + V(MathFloor, PROP("floor"), Method) \ + V(MathFround, PROP("fround"), Method) \ + V(MathHypot, PROP("hypot"), Method) \ + V(MathLog, PROP("log"), Method) \ + V(MathLog10, PROP("log10"), Method) \ + V(MathLog1p, PROP("log1p"), Method) \ + V(MathLog2, PROP("log2"), Method) \ + V(MathMax, PROP("max"), Method) \ + V(MathMin, PROP("min"), Method) \ + V(MathPow, PROP("pow"), Method) \ + V(MathRandom, PROP("random"), Method) \ + V(MathRound, PROP("round"), Method) \ + V(MathSign, PROP("sign"), Method) \ + V(MathSin, PROP("sin"), Method) \ + V(MathSinh, PROP("sinh"), Method) \ + V(MathSqrt, PROP("sqrt"), Method) \ + V(MathTan, PROP("tan"), Method) \ + V(MathTanh, PROP("tanh"), Method) \ + V(MathTrunc, PROP("trunc"), Method) \ + V(MathImul, PROP("imul"), Method) \ + V(MathF16round, PROP("f16round"), Method) \ + V(MathSumPrecise, PROP("sumPrecise"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_JSONObject(V) \ + V(JSONParse, PROP("parse"), Method) \ + V(JSONStringify, PROP("stringify"), Method) \ + V(JSONIsRawJSON, PROP("isRawJSON"), Method) \ + V(JSONRawJSON, PROP("rawJSON"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ReflectObject(V) \ + V(ReflectApply, PROP("apply"), Method) \ + V(ReflectConstruct, PROP("construct"), Method) \ + V(ReflectDefineProperty, PROP("defineProperty"), Method) \ + V(ReflectDeleteProperty, PROP("deleteProperty"), Method) \ + V(ReflectGet, PROP("get"), Method) \ + V(ReflectGetOwnPropertyDescriptor, PROP("getOwnPropertyDescriptor"), Method) \ + V(ReflectGetPrototypeOf, PROP("getPrototypeOf"), Method) \ + V(ReflectHas, PROP("has"), Method) \ + V(ReflectIsExtensible, PROP("isExtensible"), Method) \ + V(ReflectOwnKeys, PROP("ownKeys"), Method) \ + V(ReflectPreventExtensions, PROP("preventExtensions"), Method) \ + V(ReflectSet, PROP("set"), Method) \ + V(ReflectSetPrototypeOf, PROP("setPrototypeOf"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_AtomicsObject(V) \ + V(AtomicsAdd, PROP("add"), Method) \ + V(AtomicsAnd, PROP("and"), Method) \ + V(AtomicsCompareExchange, PROP("compareExchange"), Method) \ + V(AtomicsExchange, PROP("exchange"), Method) \ + V(AtomicsIsLockFree, PROP("isLockFree"), Method) \ + V(AtomicsLoad, PROP("load"), Method) \ + V(AtomicsNotify, PROP("notify"), Method) \ + V(AtomicsOr, PROP("or"), Method) \ + V(AtomicsStore, PROP("store"), Method) \ + V(AtomicsSub, PROP("sub"), Method) \ + V(AtomicsWait, PROP("wait"), Method) \ + V(AtomicsXor, PROP("xor"), Method) \ + V(AtomicsPause, PROP("pause"), Method) \ + V(AtomicsWaitAsync, PROP("waitAsync"), Method) \ + +#define JSC_FOREACH_PRIMORDIAL_ProxyObject(V) \ + V(Proxy, SELF, Self) \ + V(ProxyRevocable, PROP("revocable"), Method) \ + +// --------------------------------------------------------------------------- +// Holders, eager (exist after JSGlobalObject::init(), snapshotted there) then +// lazy (snapshotted where they are created). +// --------------------------------------------------------------------------- + +#define JSC_FOREACH_PRIMORDIAL_EAGER_HOLDER(H) \ + H(GlobalObject) \ + H(ObjectPrototype) \ + H(ObjectConstructor) \ + H(FunctionPrototype) \ + H(FunctionConstructor) \ + H(ArrayPrototype) \ + H(ArrayConstructor) \ + H(StringPrototype) \ + H(StringConstructor) \ + H(RegExpPrototype) \ + H(RegExpConstructor) \ + H(SymbolPrototype) \ + H(SymbolConstructor) \ + H(BigIntPrototype) \ + H(BigIntConstructor) \ + H(PromisePrototype) \ + H(PromiseConstructor) \ + H(IteratorPrototype) \ + H(IteratorConstructor) \ + H(ArrayIteratorPrototype) \ + H(StringIteratorPrototype) \ + H(MapIteratorPrototype) \ + H(SetIteratorPrototype) \ + H(RegExpStringIteratorPrototype) \ + H(IteratorHelperPrototype) \ + H(WrapForValidIteratorPrototype) \ + H(AsyncIteratorPrototype) \ + H(GeneratorFunctionPrototype) \ + H(AsyncFunctionPrototype) \ + H(AsyncGeneratorFunctionPrototype) \ + H(WeakRefPrototype) \ + H(WeakRefConstructor) \ + H(FinalizationRegistryPrototype) \ + H(FinalizationRegistryConstructor) \ + +#define JSC_FOREACH_PRIMORDIAL_LAZY_HOLDER(H) \ + H(BooleanPrototype) \ + H(BooleanConstructor) \ + H(NumberPrototype) \ + H(NumberConstructor) \ + H(DatePrototype) \ + H(DateConstructor) \ + H(ErrorPrototype) \ + H(ErrorConstructor) \ + H(MapPrototype) \ + H(MapConstructor) \ + H(SetPrototype) \ + H(SetConstructor) \ + H(WeakMapPrototype) \ + H(WeakMapConstructor) \ + H(WeakSetPrototype) \ + H(WeakSetConstructor) \ + H(ArrayBufferPrototype) \ + H(ArrayBufferConstructor) \ + H(AggregateErrorPrototype) \ + H(AggregateErrorConstructor) \ + H(EvalErrorPrototype) \ + H(EvalErrorConstructor) \ + H(RangeErrorPrototype) \ + H(RangeErrorConstructor) \ + H(ReferenceErrorPrototype) \ + H(ReferenceErrorConstructor) \ + H(SyntaxErrorPrototype) \ + H(SyntaxErrorConstructor) \ + H(TypeErrorPrototype) \ + H(TypeErrorConstructor) \ + H(URIErrorPrototype) \ + H(URIErrorConstructor) \ + H(TypedArrayPrototype) \ + H(TypedArrayConstructor) \ + H(DataViewPrototype) \ + H(DataViewConstructor) \ + H(Int8ArrayPrototype) \ + H(Int8ArrayConstructor) \ + H(Uint8ArrayPrototype) \ + H(Uint8ArrayConstructor) \ + H(Uint8ClampedArrayPrototype) \ + H(Uint8ClampedArrayConstructor) \ + H(Int16ArrayPrototype) \ + H(Int16ArrayConstructor) \ + H(Uint16ArrayPrototype) \ + H(Uint16ArrayConstructor) \ + H(Int32ArrayPrototype) \ + H(Int32ArrayConstructor) \ + H(Uint32ArrayPrototype) \ + H(Uint32ArrayConstructor) \ + H(Float16ArrayPrototype) \ + H(Float16ArrayConstructor) \ + H(Float32ArrayPrototype) \ + H(Float32ArrayConstructor) \ + H(Float64ArrayPrototype) \ + H(Float64ArrayConstructor) \ + H(BigInt64ArrayPrototype) \ + H(BigInt64ArrayConstructor) \ + H(BigUint64ArrayPrototype) \ + H(BigUint64ArrayConstructor) \ + H(MathObject) \ + H(JSONObject) \ + H(ReflectObject) \ + H(AtomicsObject) \ + H(ProxyObject) \ + +#define JSC_FOREACH_PRIMORDIAL_HOLDER(H) \ + JSC_FOREACH_PRIMORDIAL_EAGER_HOLDER(H) \ + JSC_FOREACH_PRIMORDIAL_LAZY_HOLDER(H) \ + +#define JSC_FOREACH_PRIMORDIAL_NAME(V) \ + JSC_FOREACH_PRIMORDIAL_GlobalObject(V) \ + JSC_FOREACH_PRIMORDIAL_ObjectPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_ObjectConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_FunctionPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_FunctionConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_StringPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_StringConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_RegExpPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_RegExpConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_SymbolPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_SymbolConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_BigIntPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_BigIntConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_PromisePrototype(V) \ + JSC_FOREACH_PRIMORDIAL_PromiseConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_IteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_IteratorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_ArrayIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_StringIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_MapIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_SetIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_RegExpStringIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_IteratorHelperPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_WrapForValidIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_AsyncIteratorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_GeneratorFunctionPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_AsyncFunctionPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_AsyncGeneratorFunctionPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_WeakRefPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_WeakRefConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_FinalizationRegistryPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_FinalizationRegistryConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_BooleanPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_BooleanConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_NumberPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_NumberConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_DatePrototype(V) \ + JSC_FOREACH_PRIMORDIAL_DateConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_ErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_ErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_MapPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_MapConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_SetPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_SetConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_WeakMapPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_WeakMapConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_WeakSetPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_WeakSetConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_ArrayBufferPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_ArrayBufferConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_AggregateErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_AggregateErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_EvalErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_EvalErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_RangeErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_RangeErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_ReferenceErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_ReferenceErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_SyntaxErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_SyntaxErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_TypeErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_TypeErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_URIErrorPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_URIErrorConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_TypedArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_TypedArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_DataViewPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_DataViewConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Int8ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Int8ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Uint8ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Uint8ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Uint8ClampedArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Uint8ClampedArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Int16ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Int16ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Uint16ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Uint16ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Int32ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Int32ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Uint32ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Uint32ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Float16ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Float16ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Float32ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Float32ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_Float64ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_Float64ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_BigInt64ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_BigInt64ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_BigUint64ArrayPrototype(V) \ + JSC_FOREACH_PRIMORDIAL_BigUint64ArrayConstructor(V) \ + JSC_FOREACH_PRIMORDIAL_MathObject(V) \ + JSC_FOREACH_PRIMORDIAL_JSONObject(V) \ + JSC_FOREACH_PRIMORDIAL_ReflectObject(V) \ + JSC_FOREACH_PRIMORDIAL_AtomicsObject(V) \ + JSC_FOREACH_PRIMORDIAL_ProxyObject(V) \ + +// V(Holder, expression yielding the holder JSObject* inside a JSGlobalObject member). +#define JSC_FOREACH_PRIMORDIAL_HOLDER_ACCESSOR(V) \ + V(GlobalObject, this) \ + V(ObjectPrototype, objectPrototype()) \ + V(ObjectConstructor, m_objectConstructor.get()) \ + V(FunctionPrototype, functionPrototype()) \ + V(FunctionConstructor, functionConstructor()) \ + V(ArrayPrototype, arrayPrototype()) \ + V(ArrayConstructor, m_arrayConstructor.get()) \ + V(StringPrototype, stringPrototype()) \ + V(StringConstructor, stringConstructor()) \ + V(RegExpPrototype, regExpPrototype()) \ + V(RegExpConstructor, regExpConstructor()) \ + V(SymbolPrototype, symbolPrototype()) \ + V(SymbolConstructor, symbolConstructor()) \ + V(BigIntPrototype, bigIntPrototype()) \ + V(BigIntConstructor, bigIntConstructor()) \ + V(PromisePrototype, promisePrototype()) \ + V(PromiseConstructor, promiseConstructor()) \ + V(IteratorPrototype, iteratorPrototype()) \ + V(IteratorConstructor, iteratorConstructor()) \ + V(ArrayIteratorPrototype, arrayIteratorPrototype()) \ + V(StringIteratorPrototype, m_stringIteratorPrototype.get()) \ + V(MapIteratorPrototype, mapIteratorPrototype()) \ + V(SetIteratorPrototype, setIteratorPrototype()) \ + V(RegExpStringIteratorPrototype, m_regExpStringIteratorStructure.get()->storedPrototypeObject()) \ + V(IteratorHelperPrototype, iteratorHelperPrototype()) \ + V(WrapForValidIteratorPrototype, m_wrapForValidIteratorStructure.get()->storedPrototypeObject()) \ + V(AsyncIteratorPrototype, asyncIteratorPrototype()) \ + V(GeneratorFunctionPrototype, generatorFunctionPrototype()) \ + V(AsyncFunctionPrototype, asyncFunctionPrototype()) \ + V(AsyncGeneratorFunctionPrototype, asyncGeneratorFunctionPrototype()) \ + V(WeakRefPrototype, m_weakObjectRefPrototype.get()) \ + V(WeakRefConstructor, weakObjectRefConstructor()) \ + V(FinalizationRegistryPrototype, m_finalizationRegistryPrototype.get()) \ + V(FinalizationRegistryConstructor, finalizationRegistryConstructor()) \ + V(BooleanPrototype, booleanPrototype()) \ + V(BooleanConstructor, booleanObjectConstructor()) \ + V(NumberPrototype, numberPrototype()) \ + V(NumberConstructor, numberObjectConstructor()) \ + V(DatePrototype, datePrototype()) \ + V(DateConstructor, dateConstructor()) \ + V(ErrorPrototype, errorPrototype()) \ + V(ErrorConstructor, errorConstructor()) \ + V(MapPrototype, mapPrototype()) \ + V(MapConstructor, mapConstructor()) \ + V(SetPrototype, jsSetPrototype()) \ + V(SetConstructor, setConstructor()) \ + V(WeakMapPrototype, m_weakMapStructure.prototype(this)) \ + V(WeakMapConstructor, weakMapConstructor()) \ + V(WeakSetPrototype, m_weakSetStructure.prototype(this)) \ + V(WeakSetConstructor, weakSetConstructor()) \ + V(ArrayBufferPrototype, arrayBufferPrototype(ArrayBufferSharingMode::Default)) \ + V(ArrayBufferConstructor, arrayBufferConstructor(ArrayBufferSharingMode::Default)) \ + V(AggregateErrorPrototype, m_aggregateErrorStructure.prototype(this)) \ + V(AggregateErrorConstructor, m_aggregateErrorStructure.constructor(this)) \ + V(EvalErrorPrototype, m_evalErrorStructure.prototype(this)) \ + V(EvalErrorConstructor, m_evalErrorStructure.constructor(this)) \ + V(RangeErrorPrototype, m_rangeErrorStructure.prototype(this)) \ + V(RangeErrorConstructor, m_rangeErrorStructure.constructor(this)) \ + V(ReferenceErrorPrototype, m_referenceErrorStructure.prototype(this)) \ + V(ReferenceErrorConstructor, m_referenceErrorStructure.constructor(this)) \ + V(SyntaxErrorPrototype, m_syntaxErrorStructure.prototype(this)) \ + V(SyntaxErrorConstructor, m_syntaxErrorStructure.constructor(this)) \ + V(TypeErrorPrototype, m_typeErrorStructure.prototype(this)) \ + V(TypeErrorConstructor, m_typeErrorStructure.constructor(this)) \ + V(URIErrorPrototype, m_URIErrorStructure.prototype(this)) \ + V(URIErrorConstructor, m_URIErrorStructure.constructor(this)) \ + V(TypedArrayPrototype, m_typedArrayProto.get(this)) \ + V(TypedArrayConstructor, m_typedArraySuperConstructor.get(this)) \ + V(DataViewPrototype, typedArrayPrototype(TypeDataView)) \ + V(DataViewConstructor, typedArrayConstructor(TypeDataView)) \ + V(Int8ArrayPrototype, typedArrayPrototype(TypeInt8)) \ + V(Int8ArrayConstructor, typedArrayConstructor(TypeInt8)) \ + V(Uint8ArrayPrototype, typedArrayPrototype(TypeUint8)) \ + V(Uint8ArrayConstructor, typedArrayConstructor(TypeUint8)) \ + V(Uint8ClampedArrayPrototype, typedArrayPrototype(TypeUint8Clamped)) \ + V(Uint8ClampedArrayConstructor, typedArrayConstructor(TypeUint8Clamped)) \ + V(Int16ArrayPrototype, typedArrayPrototype(TypeInt16)) \ + V(Int16ArrayConstructor, typedArrayConstructor(TypeInt16)) \ + V(Uint16ArrayPrototype, typedArrayPrototype(TypeUint16)) \ + V(Uint16ArrayConstructor, typedArrayConstructor(TypeUint16)) \ + V(Int32ArrayPrototype, typedArrayPrototype(TypeInt32)) \ + V(Int32ArrayConstructor, typedArrayConstructor(TypeInt32)) \ + V(Uint32ArrayPrototype, typedArrayPrototype(TypeUint32)) \ + V(Uint32ArrayConstructor, typedArrayConstructor(TypeUint32)) \ + V(Float16ArrayPrototype, typedArrayPrototype(TypeFloat16)) \ + V(Float16ArrayConstructor, typedArrayConstructor(TypeFloat16)) \ + V(Float32ArrayPrototype, typedArrayPrototype(TypeFloat32)) \ + V(Float32ArrayConstructor, typedArrayConstructor(TypeFloat32)) \ + V(Float64ArrayPrototype, typedArrayPrototype(TypeFloat64)) \ + V(Float64ArrayConstructor, typedArrayConstructor(TypeFloat64)) \ + V(BigInt64ArrayPrototype, typedArrayPrototype(TypeBigInt64)) \ + V(BigInt64ArrayConstructor, typedArrayConstructor(TypeBigInt64)) \ + V(BigUint64ArrayPrototype, typedArrayPrototype(TypeBigUint64)) \ + V(BigUint64ArrayConstructor, typedArrayConstructor(TypeBigUint64)) \ + V(MathObject, pristineNamespaceObject(vm, this, Identifier::fromString(vm, "Math"_s), createMathProperty)) \ + V(JSONObject, pristineNamespaceObject(vm, this, Identifier::fromString(vm, "JSON"_s), createJSONProperty)) \ + V(ReflectObject, pristineNamespaceObject(vm, this, Identifier::fromString(vm, "Reflect"_s), createReflectProperty)) \ + V(AtomicsObject, pristineNamespaceObject(vm, this, Identifier::fromString(vm, "Atomics"_s), createAtomicsProperty)) \ + V(ProxyObject, pristineNamespaceObject(vm, this, Identifier::fromString(vm, "Proxy"_s), createProxyProperty)) \ + +// Names CREATE_PROTOTYPE_FOR_LAZY_TYPE's hook uses for its capitalName parameter. +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_Boolean PrimordialHolder::BooleanPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_Boolean PrimordialHolder::BooleanConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_Date PrimordialHolder::DatePrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_Date PrimordialHolder::DateConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_Error PrimordialHolder::ErrorPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_Error PrimordialHolder::ErrorConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_Map PrimordialHolder::MapPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_Map PrimordialHolder::MapConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_Number PrimordialHolder::NumberPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_Number PrimordialHolder::NumberConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_Set PrimordialHolder::SetPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_Set PrimordialHolder::SetConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_WeakMap PrimordialHolder::WeakMapPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_WeakMap PrimordialHolder::WeakMapConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_WeakSet PrimordialHolder::WeakSetPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_WeakSet PrimordialHolder::WeakSetConstructor +#define JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_JSArrayBuffer PrimordialHolder::ArrayBufferPrototype +#define JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_JSArrayBuffer PrimordialHolder::ArrayBufferConstructor + +} // namespace JSC + +#endif // USE(BUN_JSC_ADDITIONS) diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp index e0cbd0907891e..05386b8ac49a3 100644 --- a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp +++ b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp @@ -414,33 +414,95 @@ static JSValue initializeEvalFunction(VM&, JSObject* object) static JSValue createProxyProperty(VM& vm, JSObject* object) { JSGlobalObject* global = uncheckedDowncast(object); - return ProxyConstructor::create(vm, ProxyConstructor::createStructure(vm, global, global->functionPrototype())); + JSObject* holder = ProxyConstructor::create(vm, ProxyConstructor::createStructure(vm, global, global->functionPrototype())); +#if USE(BUN_JSC_ADDITIONS) + global->snapshotPrimordialsFromHolder(vm, holder, PrimordialHolder::ProxyObject); +#endif + return holder; } static JSValue createJSONProperty(VM& vm, JSObject* object) { JSGlobalObject* global = uncheckedDowncast(object); - return JSONObject::create(vm, global, JSONObject::createStructure(vm, global, global->objectPrototype())); + JSObject* holder = JSONObject::create(vm, global, JSONObject::createStructure(vm, global, global->objectPrototype())); +#if USE(BUN_JSC_ADDITIONS) + global->snapshotPrimordialsFromHolder(vm, holder, PrimordialHolder::JSONObject); +#endif + return holder; } static JSValue createMathProperty(VM& vm, JSObject* object) { JSGlobalObject* global = uncheckedDowncast(object); - return MathObject::create(vm, global, MathObject::createStructure(vm, global, global->objectPrototype())); + JSObject* holder = MathObject::create(vm, global, MathObject::createStructure(vm, global, global->objectPrototype())); +#if USE(BUN_JSC_ADDITIONS) + global->snapshotPrimordialsFromHolder(vm, holder, PrimordialHolder::MathObject); +#endif + return holder; } static JSValue createReflectProperty(VM& vm, JSObject* object) { JSGlobalObject* global = uncheckedDowncast(object); - return ReflectObject::create(vm, global, ReflectObject::createStructure(vm, global, global->objectPrototype())); + JSObject* holder = ReflectObject::create(vm, global, ReflectObject::createStructure(vm, global, global->objectPrototype())); +#if USE(BUN_JSC_ADDITIONS) + global->snapshotPrimordialsFromHolder(vm, holder, PrimordialHolder::ReflectObject); +#endif + return holder; } static JSValue createAtomicsProperty(VM& vm, JSObject *object) { JSGlobalObject* global = uncheckedDowncast(object); - return AtomicsObject::create(vm, global, AtomicsObject::createStructure(vm, global, global->objectPrototype())); + JSObject* holder = AtomicsObject::create(vm, global, AtomicsObject::createStructure(vm, global, global->objectPrototype())); +#if USE(BUN_JSC_ADDITIONS) + global->snapshotPrimordialsFromHolder(vm, holder, PrimordialHolder::AtomicsObject); +#endif + return holder; } +#if USE(BUN_JSC_ADDITIONS) +// The global's own binding for a namespace object if it is still the pristine +// object JSC created for this global, else a fresh un-installed one so its static +// table can be read. The untouched static entry is reified from the table itself +// so no getOwnPropertySlot override (a node:vm sandbox) can run user code here. +template +static JSObject* pristineNamespaceObject(VM& vm, JSGlobalObject* globalObject, const Identifier& name, JSValue (*create)(VM&, JSObject*)) +{ + unsigned attributes; + PropertyOffset offset = globalObject->getDirectOffset(vm, name, attributes); + if (!isValidOffset(offset) && !globalObject->staticPropertiesReified()) { + if (auto entry = globalObject->findPropertyHashEntry(name)) { + auto catchScope = DECLARE_TOP_EXCEPTION_SCOPE(vm); + DeferTerminationForAWhile deferScope(vm); + reifyStaticProperty(vm, entry->table->classForThis, name, *entry->value, *globalObject); + catchScope.assertNoExceptionExceptTermination(); + offset = globalObject->getDirectOffset(vm, name, attributes); + } + } + if (isValidOffset(offset)) { + JSValue value = globalObject->getDirect(offset); + auto* existing = value.isCell() ? dynamicDowncast(value.asCell()) : nullptr; + if (existing && existing->globalObject() == globalObject) + return existing; + } + return uncheckedDowncast(create(vm, globalObject)); +} + +JSObject* JSGlobalObject::primordialHolderObject(VM& vm, PrimordialHolder holder) +{ + switch (holder) { +#define JSC_PRIMORDIAL_HOLDER_CASE(Holder, expression) \ + case PrimordialHolder::Holder: \ + return static_cast(expression); + JSC_FOREACH_PRIMORDIAL_HOLDER_ACCESSOR(JSC_PRIMORDIAL_HOLDER_CASE) +#undef JSC_PRIMORDIAL_HOLDER_CASE + } + RELEASE_ASSERT_NOT_REACHED(); + return nullptr; +} +#endif + static JSValue createConsoleProperty(VM& vm, JSObject* object) { JSGlobalObject* global = uncheckedDowncast(object); @@ -1049,12 +1111,31 @@ static ObjectPropertyCondition setupAbsenceAdaptiveWatchpoint(JSGlobalObject* gl return condition; } +#if USE(BUN_JSC_ADDITIONS) +static PrimordialHolder nativeErrorPrimordialHolder(ErrorType errorType, bool prototype) +{ + switch (errorType) { + case ErrorType::EvalError: return prototype ? PrimordialHolder::EvalErrorPrototype : PrimordialHolder::EvalErrorConstructor; + case ErrorType::RangeError: return prototype ? PrimordialHolder::RangeErrorPrototype : PrimordialHolder::RangeErrorConstructor; + case ErrorType::ReferenceError: return prototype ? PrimordialHolder::ReferenceErrorPrototype : PrimordialHolder::ReferenceErrorConstructor; + case ErrorType::SyntaxError: return prototype ? PrimordialHolder::SyntaxErrorPrototype : PrimordialHolder::SyntaxErrorConstructor; + case ErrorType::TypeError: return prototype ? PrimordialHolder::TypeErrorPrototype : PrimordialHolder::TypeErrorConstructor; + case ErrorType::URIError: return prototype ? PrimordialHolder::URIErrorPrototype : PrimordialHolder::URIErrorConstructor; + default: RELEASE_ASSERT_NOT_REACHED(); + } +} +#endif + template void JSGlobalObject::initializeErrorConstructor(LazyClassStructure::Initializer& init) { init.setPrototype(NativeErrorPrototype::create(init.vm, NativeErrorPrototype::createStructure(init.vm, this, m_errorStructure.prototype(this)), errorTypeName(errorType))); init.setStructure(ErrorInstance::createStructure(init.vm, this, init.prototype)); init.setConstructor(NativeErrorConstructor::create(init.vm, NativeErrorConstructor::createStructure(init.vm, this, m_errorStructure.constructor(this)), uncheckedDowncast(init.prototype))); +#if USE(BUN_JSC_ADDITIONS) + snapshotPrimordialsFromHolder(init.vm, init.prototype, nativeErrorPrimordialHolder(errorType, true)); + snapshotPrimordialsFromHolder(init.vm, init.constructor, nativeErrorPrimordialHolder(errorType, false)); +#endif } void JSGlobalObject::initializeAggregateErrorConstructor(LazyClassStructure::Initializer& init) @@ -1062,6 +1143,10 @@ void JSGlobalObject::initializeAggregateErrorConstructor(LazyClassStructure::Ini init.setPrototype(AggregateErrorPrototype::create(init.vm, AggregateErrorPrototype::createStructure(init.vm, this, m_errorStructure.prototype(this)))); init.setStructure(ErrorInstance::createStructure(init.vm, this, init.prototype)); init.setConstructor(AggregateErrorConstructor::create(init.vm, AggregateErrorConstructor::createStructure(init.vm, this, m_errorStructure.constructor(this)), uncheckedDowncast(init.prototype))); +#if USE(BUN_JSC_ADDITIONS) + snapshotPrimordialsFromHolder(init.vm, init.prototype, PrimordialHolder::AggregateErrorPrototype); + snapshotPrimordialsFromHolder(init.vm, init.constructor, PrimordialHolder::AggregateErrorConstructor); +#endif } void JSGlobalObject::initializeSuppressedErrorConstructor(LazyClassStructure::Initializer& init) @@ -1092,6 +1177,9 @@ void JSGlobalObject::init(VM& vm) ASSERT(vm.currentThreadIsHoldingAPILock()); auto catchScope = DECLARE_TOP_EXCEPTION_SCOPE(vm); +#if USE(BUN_JSC_ADDITIONS) + initializePrimordialLinkTimeConstants(); +#endif convertToDictionary(vm); m_debugger = nullptr; @@ -1226,9 +1314,11 @@ void JSGlobalObject::init(VM& vm) }); m_typedArrayProto.initLater( [] (const Initializer& init) { - init.set(JSTypedArrayViewPrototype::create(init.vm, init.owner, JSTypedArrayViewPrototype::createStructure(init.vm, init.owner, init.owner->m_objectPrototype.get()))); + JSTypedArrayViewPrototype* prototype = JSTypedArrayViewPrototype::create(init.vm, init.owner, JSTypedArrayViewPrototype::createStructure(init.vm, init.owner, init.owner->m_objectPrototype.get())); + init.set(prototype); - // Make sure that the constructor gets initialized, too. + // Make sure that the constructor gets initialized, too (its initializer + // installs prototype.constructor and snapshots both holders). init.owner->m_typedArraySuperConstructor.get(init.owner); }); m_typedArraySuperConstructor.initLater( @@ -1237,8 +1327,21 @@ void JSGlobalObject::init(VM& vm) JSTypedArrayViewConstructor* constructor = JSTypedArrayViewConstructor::create(init.vm, init.owner, JSTypedArrayViewConstructor::createStructure(init.vm, init.owner, init.owner->m_functionPrototype.get()), prototype); prototype->putDirectWithoutTransition(init.vm, init.vm.propertyNames->constructor, constructor, static_cast(PropertyAttribute::DontEnum)); init.set(constructor); +#if USE(BUN_JSC_ADDITIONS) + // Both init orders converge here, after prototype.constructor is installed. + init.owner->snapshotPrimordialsFromHolder(init.vm, prototype, PrimordialHolder::TypedArrayPrototype); + init.owner->snapshotPrimordialsFromHolder(init.vm, constructor, PrimordialHolder::TypedArrayConstructor); +#endif }); +#if USE(BUN_JSC_ADDITIONS) +#define INIT_TYPED_ARRAY_LATER_SNAPSHOT_PRIMORDIALS(type) \ + init.global->snapshotPrimordialsFromHolder(init.vm, init.prototype, PrimordialHolder::type##ArrayPrototype); \ + init.global->snapshotPrimordialsFromHolder(init.vm, init.constructor, PrimordialHolder::type##ArrayConstructor); +#else +#define INIT_TYPED_ARRAY_LATER_SNAPSHOT_PRIMORDIALS(type) +#endif + #define INIT_TYPED_ARRAY_LATER(type) \ m_typedArray ## type.initLater( \ [] (LazyClassStructure::Initializer& init) { \ @@ -1246,6 +1349,7 @@ void JSGlobalObject::init(VM& vm) init.setStructure(JS ## type ## Array::createStructure(init.vm, init.global, init.prototype)); \ init.setConstructor(JS ## type ## ArrayConstructor::create(init.vm, init.global, JS ## type ## ArrayConstructor::createStructure(init.vm, init.global, init.global->m_typedArraySuperConstructor.get(init.global)), init.prototype, #type "Array"_s)); \ init.global->typedArrayStructure(Type##type, /* isResizableOrGrowableShared */ true); /* Initialize resizable Structure too */ \ + INIT_TYPED_ARRAY_LATER_SNAPSHOT_PRIMORDIALS(type) \ }); \ m_resizableOrGrowableSharedTypedArray ## type ## Structure.initLater( \ [] (const Initializer& init) { \ @@ -1264,6 +1368,10 @@ void JSGlobalObject::init(VM& vm) init.setStructure(JSDataView::createStructure(init.vm, init.global, init.prototype)); init.setConstructor(JSDataViewConstructor::create(init.vm, init.global, JSDataViewConstructor::createStructure(init.vm, init.global, init.global->m_functionPrototype.get()), init.prototype, "DataView"_s)); init.global->typedArrayStructure(TypeDataView, /* isResizableOrGrowableShared */ true); /* Initialize resizable Structure too */ +#if USE(BUN_JSC_ADDITIONS) + init.global->snapshotPrimordialsFromHolder(init.vm, init.prototype, PrimordialHolder::DataViewPrototype); + init.global->snapshotPrimordialsFromHolder(init.vm, init.constructor, PrimordialHolder::DataViewConstructor); +#endif }); m_resizableOrGrowableSharedTypedArrayDataViewStructure.initLater( [] (const Initializer& init) { @@ -1475,18 +1583,28 @@ void JSGlobalObject::init(VM& vm) #undef CREATE_PROTOTYPE_FOR_SIMPLE_TYPE +#if USE(BUN_JSC_ADDITIONS) +#define CREATE_PROTOTYPE_FOR_LAZY_TYPE_CAPTURE_PRIMORDIALS(capitalName) \ + init.global->snapshotPrimordialsFromHolder(init.vm, init.prototype, JSC_PRIMORDIAL_LAZY_TYPE_PROTOTYPE_HOLDER_##capitalName); \ + init.global->snapshotPrimordialsFromHolder(init.vm, init.constructor, JSC_PRIMORDIAL_LAZY_TYPE_CONSTRUCTOR_HOLDER_##capitalName); +#else +#define CREATE_PROTOTYPE_FOR_LAZY_TYPE_CAPTURE_PRIMORDIALS(capitalName) +#endif + #define CREATE_PROTOTYPE_FOR_LAZY_TYPE(capitalName, lowerName, properName, instanceType, jsName, prototypeBase, featureFlag) if (featureFlag) { \ m_ ## properName ## Structure.initLater(\ [] (LazyClassStructure::Initializer& init) { \ init.setPrototype(capitalName##Prototype::create(init.vm, init.global, capitalName##Prototype::createStructure(init.vm, init.global, init.global->m_ ## prototypeBase ## Prototype.get()))); \ init.setStructure(instanceType::createStructure(init.vm, init.global, init.prototype)); \ init.setConstructor(capitalName ## Constructor::create(init.vm, capitalName ## Constructor::createStructure(init.vm, init.global, init.global->m_functionPrototype.get()), uncheckedDowncast(init.prototype))); \ + CREATE_PROTOTYPE_FOR_LAZY_TYPE_CAPTURE_PRIMORDIALS(capitalName) \ }); \ } FOR_EACH_LAZY_BUILTIN_TYPE(CREATE_PROTOTYPE_FOR_LAZY_TYPE) #undef CREATE_PROTOTYPE_FOR_LAZY_TYPE +#undef CREATE_PROTOTYPE_FOR_LAZY_TYPE_CAPTURE_PRIMORDIALS // Constructors @@ -1523,6 +1641,12 @@ capitalName ## Constructor* lowerName ## Constructor = featureFlag ? capitalName m_promiseConstructor.set(vm, this, promiseConstructor); m_stringConstructor.set(vm, this, stringConstructor); +#if USE(BUN_JSC_ADDITIONS) + m_symbolConstructor.set(vm, this, symbolConstructor); + m_bigIntConstructor.set(vm, this, bigIntConstructor); + m_weakObjectRefConstructor.set(vm, this, weakObjectRefConstructor); + m_finalizationRegistryConstructor.set(vm, this, finalizationRegistryConstructor); +#endif m_linkTimeConstants[static_cast(LinkTimeConstant::Promise)].set(vm, this, promiseConstructor); m_linkTimeConstants[static_cast(LinkTimeConstant::String)].set(vm, this, stringConstructor); @@ -1929,6 +2053,11 @@ capitalName ## Constructor* lowerName ## Constructor = featureFlag ? capitalName m_linkTimeConstants[static_cast(LinkTimeConstant::hasOwnPropertyFunction)].set(vm, this, uncheckedDowncast(hasOwnPropertyFunction)); } +#if USE(BUN_JSC_ADDITIONS) + snapshotEagerPrimordials(vm); + catchScope.assertNoException(); +#endif + #define INIT_PRIVATE_GLOBAL(funcName, code) \ m_linkTimeConstants[static_cast(LinkTimeConstant::funcName)].initLater([] (const Initializer& init) { \ JSGlobalObject* globalObject = init.owner; \ @@ -3037,6 +3166,12 @@ void JSGlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor) visitor.append(thisObject->m_iteratorConstructor); visitor.append(thisObject->m_promiseConstructor); visitor.append(thisObject->m_stringConstructor); +#if USE(BUN_JSC_ADDITIONS) + visitor.append(thisObject->m_symbolConstructor); + visitor.append(thisObject->m_bigIntConstructor); + visitor.append(thisObject->m_weakObjectRefConstructor); + visitor.append(thisObject->m_finalizationRegistryConstructor); +#endif thisObject->m_defaultCollator.visit(visitor); thisObject->m_defaultDateTimeFormat.visit(visitor); diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.h b/Source/JavaScriptCore/runtime/JSGlobalObject.h index 74358f4bdf4c2..caa0ef219b1b2 100644 --- a/Source/JavaScriptCore/runtime/JSGlobalObject.h +++ b/Source/JavaScriptCore/runtime/JSGlobalObject.h @@ -127,6 +127,10 @@ class ShadowRealmPrototype; class SourceCodeKey; class SourceOrigin; class StringConstructor; +#if USE(BUN_JSC_ADDITIONS) +class SymbolConstructor; +class BigIntConstructor; +#endif class SymbolTable; class WrapperMap; class WrapForValidIteratorPrototype; @@ -141,6 +145,9 @@ enum class ArrayBufferSharingMode : bool; enum class CodeGenerationMode : uint8_t; enum class ErrorType : uint8_t; enum class LinkTimeConstant : int32_t; +#if USE(BUN_JSC_ADDITIONS) +enum class PrimordialHolder : uint8_t; +#endif enum class FunctionConstructionMode : uint8_t; enum class JSPromiseRejectionOperation : unsigned; @@ -283,6 +290,12 @@ class JSGlobalObject : public JSSegmentedVariableObject { WriteBarrier m_promiseConstructor; WriteBarrier m_iteratorConstructor; WriteBarrier m_stringConstructor; +#if USE(BUN_JSC_ADDITIONS) + WriteBarrier m_symbolConstructor; + WriteBarrier m_bigIntConstructor; + WriteBarrier m_weakObjectRefConstructor; + WriteBarrier m_finalizationRegistryConstructor; +#endif LazyProperty m_defaultCollator; LazyProperty m_defaultDateTimeFormat; @@ -506,6 +519,19 @@ class JSGlobalObject : public JSSegmentedVariableObject { FixedVector> m_linkTimeConstants; +#if USE(BUN_JSC_ADDITIONS) + void initializePrimordialLinkTimeConstants(); + void snapshotEagerPrimordials(VM&); + JS_EXPORT_PRIVATE void snapshotPrimordialsFromHolder(VM&, JSObject* holder, PrimordialHolder, bool overrideExisting = false); + // Host embedders that replace a builtin during their own global setup call this + // so the primordial is what user code sees. + JS_EXPORT_PRIVATE void overridePrimordialsFromHolder(VM&, JSObject* holder, PrimordialHolder); + JSObject* primordialHolderObject(VM&, PrimordialHolder); + JSCell* materializePrimordial(VM&, LinkTimeConstant); + JSCell* materializePrimordialFromTables(VM&, JSObject* holder, unsigned index); + JS_EXPORT_PRIVATE static JSValue auditPrimordials(JSGlobalObject*); +#endif + StructureCache m_structureCache; WeakGCMap m_symbolTableCache; @@ -830,6 +856,13 @@ class JSGlobalObject : public JSSegmentedVariableObject { ObjectConstructor* objectConstructor() const LIFETIME_BOUND { return m_objectConstructor.get(); } FunctionConstructor* functionConstructor() const LIFETIME_BOUND { return m_functionConstructor.get(); } JSPromiseConstructor* promiseConstructor() const LIFETIME_BOUND { return m_promiseConstructor.get(); } +#if USE(BUN_JSC_ADDITIONS) + StringConstructor* stringConstructor() const LIFETIME_BOUND { return m_stringConstructor.get(); } + SymbolConstructor* symbolConstructor() const LIFETIME_BOUND { return m_symbolConstructor.get(); } + BigIntConstructor* bigIntConstructor() const LIFETIME_BOUND { return m_bigIntConstructor.get(); } + JSObject* weakObjectRefConstructor() const LIFETIME_BOUND { return m_weakObjectRefConstructor.get(); } + JSObject* finalizationRegistryConstructor() const LIFETIME_BOUND { return m_finalizationRegistryConstructor.get(); } +#endif JSIteratorConstructor* iteratorConstructor() const LIFETIME_BOUND { return m_iteratorConstructor.get(); } IntlCollator* defaultCollator() const LIFETIME_BOUND { return m_defaultCollator.get(this); } diff --git a/Source/JavaScriptCore/runtime/PropertyDescriptor.cpp b/Source/JavaScriptCore/runtime/PropertyDescriptor.cpp index c4bc3afd48f2b..65297ee613193 100644 --- a/Source/JavaScriptCore/runtime/PropertyDescriptor.cpp +++ b/Source/JavaScriptCore/runtime/PropertyDescriptor.cpp @@ -57,7 +57,7 @@ struct WeakCustomGetterOrSetterHashTranslator { } }; -static JSCustomSetterFunction* createCustomSetterFunction(JSGlobalObject* globalObject, VM& vm, PropertyName propertyName, PutValueFunc putValueFunc) +JSCustomSetterFunction* createCustomSetterFunction(JSGlobalObject* globalObject, VM& vm, PropertyName propertyName, PutValueFunc putValueFunc) { using Translator = WeakCustomGetterOrSetterHashTranslator; @@ -69,7 +69,7 @@ static JSCustomSetterFunction* createCustomSetterFunction(JSGlobalObject* global }); } -static JSCustomGetterFunction* createCustomGetterFunction(JSGlobalObject* globalObject, VM& vm, PropertyName propertyName, GetValueFunc getValueFunc, std::optional domAttribute) +JSCustomGetterFunction* createCustomGetterFunction(JSGlobalObject* globalObject, VM& vm, PropertyName propertyName, GetValueFunc getValueFunc, std::optional domAttribute) { using Translator = WeakCustomGetterOrSetterHashTranslator; @@ -84,6 +84,7 @@ static JSCustomGetterFunction* createCustomGetterFunction(JSGlobalObject* global }); } + bool PropertyDescriptor::writable() const { ASSERT(!isAccessorDescriptor()); diff --git a/Source/JavaScriptCore/runtime/PropertyDescriptor.h b/Source/JavaScriptCore/runtime/PropertyDescriptor.h index feedb19ebd616..2ad57b9bfcc18 100644 --- a/Source/JavaScriptCore/runtime/PropertyDescriptor.h +++ b/Source/JavaScriptCore/runtime/PropertyDescriptor.h @@ -33,6 +33,16 @@ namespace JSC { class GetterSetter; +#if USE(BUN_JSC_ADDITIONS) +class JSCustomGetterFunction; +class JSCustomSetterFunction; +struct DOMAttributeAnnotation; + +// The JS function that reflects a C++ getter/setter; cached per (name, function). +JS_EXPORT_PRIVATE JSCustomGetterFunction* createCustomGetterFunction(JSGlobalObject*, VM&, PropertyName, GetValueFunc, std::optional); +JS_EXPORT_PRIVATE JSCustomSetterFunction* createCustomSetterFunction(JSGlobalObject*, VM&, PropertyName, PutValueFunc); +#endif + class PropertyDescriptor { public: PropertyDescriptor()