Changeset 253019 in webkit


Ignore:
Timestamp:
Dec 2, 2019 5:47:31 PM (4 years ago)
Author:
ysuzuki@apple.com
Message:

[JSC] Put some destructible objects to IsoSubspace
​https://bugs.webkit.org/show_bug.cgi?id=204771

Reviewed by Mark Lam.

This patch puts DateInstance, ErrorInstance, and Intl objects in IsoSubspace.
By using specific IsoHeapCellType, we can use JSNonFinalObject as base-classes of
them instead of using JSDestructibleObject. We also introduce STATIC_ASSERT_ISO_SUBSPACE_SHARABLE
to ensure that derived class of some IsoSubspace'ed one is intentional and safe.

  • runtime/ArrayConstructor.h:
  • runtime/AsyncFunctionConstructor.h:
  • runtime/AsyncGeneratorFunctionConstructor.h:
  • runtime/BigIntConstructor.h:
  • runtime/BooleanConstructor.h:
  • runtime/DateConstructor.h:
  • runtime/DateInstance.cpp:

(JSC::DateInstance::destroy): Deleted.

  • runtime/DateInstance.h:
  • runtime/ErrorConstructor.h:
  • runtime/ErrorInstance.cpp:

(JSC::ErrorInstance::destroy): Deleted.

  • runtime/ErrorInstance.h:

(JSC::ErrorInstance::destroy):
(JSC::ErrorInstance::subspaceFor):

  • runtime/FunctionConstructor.h:
  • runtime/FunctionPrototype.h:
  • runtime/GeneratorFunctionConstructor.h:
  • runtime/IntlCollator.cpp:

(JSC::IntlCollator::IntlCollator):
(JSC::IntlCollator::destroy): Deleted.

  • runtime/IntlCollator.h:
  • runtime/IntlCollatorConstructor.h:
  • runtime/IntlDateTimeFormat.cpp:

(JSC::IntlDateTimeFormat::IntlDateTimeFormat):
(JSC::IntlDateTimeFormat::destroy): Deleted.

  • runtime/IntlDateTimeFormat.h:
  • runtime/IntlDateTimeFormatConstructor.h:
  • runtime/IntlNumberFormat.cpp:

(JSC::IntlNumberFormat::IntlNumberFormat):
(JSC::IntlNumberFormat::destroy): Deleted.

  • runtime/IntlNumberFormat.h:
  • runtime/IntlNumberFormatConstructor.h:
  • runtime/IntlPluralRules.cpp:

(JSC::IntlPluralRules::IntlPluralRules):
(JSC::IntlPluralRules::destroy): Deleted.

  • runtime/IntlPluralRules.h:
  • runtime/IntlPluralRulesConstructor.h:
  • runtime/JSArrayBufferConstructor.h:
  • runtime/JSCell.h:
  • runtime/JSObject.h:
  • runtime/JSTypedArrayConstructors.h:
  • runtime/JSTypedArrayViewConstructor.h:
  • runtime/MapConstructor.h:
  • runtime/NativeErrorConstructor.h:
  • runtime/NullGetterFunction.h:
  • runtime/NullSetterFunction.h:
  • runtime/NumberConstructor.h:
  • runtime/ObjectConstructor.h:
  • runtime/ProxyConstructor.h:
  • runtime/RegExpConstructor.h:
  • runtime/SetConstructor.h:
  • runtime/StringConstructor.h:
  • runtime/SymbolConstructor.h:
  • runtime/VM.cpp:

(JSC::VM::VM):

  • runtime/VM.h:
  • runtime/WeakMapConstructor.h:
  • runtime/WeakObjectRefConstructor.h:
  • runtime/WeakSetConstructor.h:
  • tools/JSDollarVM.cpp:
  • wasm/js/JSWebAssemblyCompileError.h:
  • wasm/js/JSWebAssemblyLinkError.h:
  • wasm/js/JSWebAssemblyRuntimeError.h:
  • wasm/js/WebAssemblyCompileErrorConstructor.h:
  • wasm/js/WebAssemblyInstanceConstructor.h:
  • wasm/js/WebAssemblyLinkErrorConstructor.h:
  • wasm/js/WebAssemblyMemoryConstructor.h:
  • wasm/js/WebAssemblyModuleConstructor.h:
  • wasm/js/WebAssemblyRuntimeErrorConstructor.h:
  • wasm/js/WebAssemblyTableConstructor.h:
Location:
trunk/Source/JavaScriptCore
Files:
59 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r253015 r253019  
     12019-12-02  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Put some destructible objects to IsoSubspace
     4        https://bugs.webkit.org/show_bug.cgi?id=204771
     5
     6        Reviewed by Mark Lam.
     7
     8        This patch puts DateInstance, ErrorInstance, and Intl objects in IsoSubspace.
     9        By using specific IsoHeapCellType, we can use JSNonFinalObject as base-classes of
     10        them instead of using JSDestructibleObject. We also introduce STATIC_ASSERT_ISO_SUBSPACE_SHARABLE
     11        to ensure that derived class of some IsoSubspace'ed one is intentional and safe.
     12
     13        * runtime/ArrayConstructor.h:
     14        * runtime/AsyncFunctionConstructor.h:
     15        * runtime/AsyncGeneratorFunctionConstructor.h:
     16        * runtime/BigIntConstructor.h:
     17        * runtime/BooleanConstructor.h:
     18        * runtime/DateConstructor.h:
     19        * runtime/DateInstance.cpp:
     20        (JSC::DateInstance::destroy): Deleted.
     21        * runtime/DateInstance.h:
     22        * runtime/ErrorConstructor.h:
     23        * runtime/ErrorInstance.cpp:
     24        (JSC::ErrorInstance::destroy): Deleted.
     25        * runtime/ErrorInstance.h:
     26        (JSC::ErrorInstance::destroy):
     27        (JSC::ErrorInstance::subspaceFor):
     28        * runtime/FunctionConstructor.h:
     29        * runtime/FunctionPrototype.h:
     30        * runtime/GeneratorFunctionConstructor.h:
     31        * runtime/IntlCollator.cpp:
     32        (JSC::IntlCollator::IntlCollator):
     33        (JSC::IntlCollator::destroy): Deleted.
     34        * runtime/IntlCollator.h:
     35        * runtime/IntlCollatorConstructor.h:
     36        * runtime/IntlDateTimeFormat.cpp:
     37        (JSC::IntlDateTimeFormat::IntlDateTimeFormat):
     38        (JSC::IntlDateTimeFormat::destroy): Deleted.
     39        * runtime/IntlDateTimeFormat.h:
     40        * runtime/IntlDateTimeFormatConstructor.h:
     41        * runtime/IntlNumberFormat.cpp:
     42        (JSC::IntlNumberFormat::IntlNumberFormat):
     43        (JSC::IntlNumberFormat::destroy): Deleted.
     44        * runtime/IntlNumberFormat.h:
     45        * runtime/IntlNumberFormatConstructor.h:
     46        * runtime/IntlPluralRules.cpp:
     47        (JSC::IntlPluralRules::IntlPluralRules):
     48        (JSC::IntlPluralRules::destroy): Deleted.
     49        * runtime/IntlPluralRules.h:
     50        * runtime/IntlPluralRulesConstructor.h:
     51        * runtime/JSArrayBufferConstructor.h:
     52        * runtime/JSCell.h:
     53        * runtime/JSObject.h:
     54        * runtime/JSTypedArrayConstructors.h:
     55        * runtime/JSTypedArrayViewConstructor.h:
     56        * runtime/MapConstructor.h:
     57        * runtime/NativeErrorConstructor.h:
     58        * runtime/NullGetterFunction.h:
     59        * runtime/NullSetterFunction.h:
     60        * runtime/NumberConstructor.h:
     61        * runtime/ObjectConstructor.h:
     62        * runtime/ProxyConstructor.h:
     63        * runtime/RegExpConstructor.h:
     64        * runtime/SetConstructor.h:
     65        * runtime/StringConstructor.h:
     66        * runtime/SymbolConstructor.h:
     67        * runtime/VM.cpp:
     68        (JSC::VM::VM):
     69        * runtime/VM.h:
     70        * runtime/WeakMapConstructor.h:
     71        * runtime/WeakObjectRefConstructor.h:
     72        * runtime/WeakSetConstructor.h:
     73        * tools/JSDollarVM.cpp:
     74        * wasm/js/JSWebAssemblyCompileError.h:
     75        * wasm/js/JSWebAssemblyLinkError.h:
     76        * wasm/js/JSWebAssemblyRuntimeError.h:
     77        * wasm/js/WebAssemblyCompileErrorConstructor.h:
     78        * wasm/js/WebAssemblyInstanceConstructor.h:
     79        * wasm/js/WebAssemblyLinkErrorConstructor.h:
     80        * wasm/js/WebAssemblyMemoryConstructor.h:
     81        * wasm/js/WebAssemblyModuleConstructor.h:
     82        * wasm/js/WebAssemblyRuntimeErrorConstructor.h:
     83        * wasm/js/WebAssemblyTableConstructor.h:
     84
    1852019-12-02  Mark Lam  <mark.lam@apple.com>
    286

  • trunk/Source/JavaScriptCore/runtime/ArrayConstructor.h

    r251425 r253019  
    5656    ArrayConstructor(VM&, Structure*);
    5757};
     58STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(ArrayConstructor, InternalFunction);
    5859
    5960JSArray* constructArrayWithSizeQuirk(JSGlobalObject*, ArrayAllocationProfile*, JSValue length, JSValue prototype = JSValue());

  • trunk/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.h

    r229413 r253019  
    5454    void finishCreation(VM&, AsyncFunctionPrototype*);
    5555};
     56STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(AsyncFunctionConstructor, InternalFunction);
    5657
    5758} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/AsyncGeneratorFunctionConstructor.h

    r229413 r253019  
    5454    void finishCreation(VM&, AsyncGeneratorFunctionPrototype*);
    5555};
     56STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(AsyncGeneratorFunctionConstructor, InternalFunction);
    5657
    5758} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/BigIntConstructor.h

    r250005 r253019  
    5959    BigIntConstructor(VM&, Structure*);
    6060};
     61STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(BigIntConstructor, InternalFunction);
    6162
    6263} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/BooleanConstructor.h

    r251425 r253019  
    5252    BooleanConstructor(VM&, Structure*);
    5353};
     54STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(BooleanConstructor, InternalFunction);
    5455
    5556JSObject* constructBooleanFromImmediateBoolean(JSGlobalObject*, JSValue);

  • trunk/Source/JavaScriptCore/runtime/DateConstructor.h

    r251425 r253019  
    5353    DateConstructor(VM&, Structure*);
    5454};
     55STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(DateConstructor, InternalFunction);
    5556
    5657JSObject* constructDate(JSGlobalObject*, JSValue newTarget, const ArgList&);

  • trunk/Source/JavaScriptCore/runtime/DateInstance.cpp

    r251852 r253019  
    5151}
    5252
    53 void DateInstance::destroy(JSCell* cell)
    54 {
    55     static_cast<DateInstance*>(cell)->DateInstance::~DateInstance();
    56 }
    57 
    5853const GregorianDateTime* DateInstance::calculateGregorianDateTime(VM& vm) const
    5954{

  • trunk/Source/JavaScriptCore/runtime/DateInstance.h

    r251826 r253019  
    2121#pragma once
    2222
    23 #include "JSDestructibleObject.h"
     23#include "JSObject.h"
    2424
    2525namespace JSC {
    2626
    27 class DateInstance final : public JSDestructibleObject {
    28 protected:
    29     JS_EXPORT_PRIVATE DateInstance(VM&, Structure*);
    30     void finishCreation(VM&);
    31     JS_EXPORT_PRIVATE void finishCreation(VM&, double);
     27class DateInstance final : public JSNonFinalObject {
     28public:
     29    using Base = JSNonFinalObject;
    3230
    33     JS_EXPORT_PRIVATE static void destroy(JSCell*);
     31    static constexpr bool needsDestruction = true;
     32    static void destroy(JSCell* cell)
     33    {
     34        static_cast<DateInstance*>(cell)->DateInstance::~DateInstance();
     35    }
    3436
    35 public:
    36     using Base = JSDestructibleObject;
     37    template<typename CellType, SubspaceAccess mode>
     38    static IsoSubspace* subspaceFor(VM& vm)
     39    {
     40        return &vm.dateInstanceSpace;
     41    }
    3742
    3843    static DateInstance* create(VM& vm, Structure* structure, double date)
    … …  
    7883
    7984private:
     85    JS_EXPORT_PRIVATE DateInstance(VM&, Structure*);
     86    void finishCreation(VM&);
     87    JS_EXPORT_PRIVATE void finishCreation(VM&, double);
    8088    JS_EXPORT_PRIVATE const GregorianDateTime* calculateGregorianDateTime(VM&) const;
    8189    JS_EXPORT_PRIVATE const GregorianDateTime* calculateGregorianDateTimeUTC(VM&) const;

  • trunk/Source/JavaScriptCore/runtime/ErrorConstructor.h

    r251425 r253019  
    5656
    5757};
     58STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(ErrorConstructor, InternalFunction);
    5859
    5960static_assert(sizeof(ErrorConstructor) == sizeof(InternalFunction), "");

  • trunk/Source/JavaScriptCore/runtime/ErrorInstance.cpp

    r251886 r253019  
    133133}
    134134
    135 void ErrorInstance::destroy(JSCell* cell)
    136 {
    137     static_cast<ErrorInstance*>(cell)->ErrorInstance::~ErrorInstance();
    138 }
    139 
    140135// Based on ErrorPrototype's errorProtoFuncToString(), but is modified to
    141136// have no observable side effects to the user (i.e. does not call proxies,

  • trunk/Source/JavaScriptCore/runtime/ErrorInstance.h

    r251425 r253019  
    2121#pragma once
    2222
    23 #include "JSDestructibleObject.h"
     23#include "JSObject.h"
    2424#include "RuntimeType.h"
    2525#include "StackFrame.h"
    … …  
    2727namespace JSC {
    2828
    29 class ErrorInstance : public JSDestructibleObject {
     29class ErrorInstance : public JSNonFinalObject {
    3030public:
    31     typedef JSDestructibleObject Base;
     31    using Base = JSNonFinalObject;
    3232    static constexpr unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames;
     33    static constexpr bool needsDestruction = true;
     34
     35    static void destroy(JSCell* cell)
     36    {
     37        static_cast<ErrorInstance*>(cell)->ErrorInstance::~ErrorInstance();
     38    }
     39
     40    template<typename CellType, SubspaceAccess mode>
     41    static IsoSubspace* subspaceFor(VM& vm)
     42    {
     43        return vm.errorInstanceSpace<mode>();
     44    }
    3345
    3446    enum SourceTextWhereErrorOccurred { FoundExactSource, FoundApproximateSource };
    … …  
    7688    bool materializeErrorInfoIfNeeded(VM&, PropertyName);
    7789
    78     template<typename CellType, SubspaceAccess mode>
    79     static IsoSubspace* subspaceFor(VM& vm)
    80     {
    81         return vm.errorInstanceSpace<mode>();
    82     }
    83 
    8490    void finalizeUnconditionally(VM&);
    8591
    … …  
    8894
    8995    void finishCreation(JSGlobalObject*, VM&, const String&, bool useCurrentFrame = true);
    90     static void destroy(JSCell*);
    9196
    9297    static bool getOwnPropertySlot(JSObject*, JSGlobalObject*, PropertyName, PropertySlot&);

  • trunk/Source/JavaScriptCore/runtime/FunctionConstructor.h

    r251425 r253019  
    5353    void finishCreation(VM&, FunctionPrototype*);
    5454};
     55STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(FunctionConstructor, InternalFunction);
    5556
    5657enum class FunctionConstructionMode {

  • trunk/Source/JavaScriptCore/runtime/FunctionPrototype.h

    r242650 r253019  
    5353    FunctionPrototype(VM&, Structure*);
    5454};
     55STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(FunctionPrototype, InternalFunction);
    5556
    5657} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/GeneratorFunctionConstructor.h

    r229413 r253019  
    6060    void finishCreation(VM&, GeneratorFunctionPrototype*);
    6161};
     62STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(GeneratorFunctionConstructor, InternalFunction);
    6263
    6364} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/IntlCollator.cpp

    r251882 r253019  
    7171
    7272IntlCollator::IntlCollator(VM& vm, Structure* structure)
    73     : JSDestructibleObject(vm, structure)
     73    : Base(vm, structure)
    7474{
    7575}
    … …  
    7979    Base::finishCreation(vm);
    8080    ASSERT(inherits(vm, info()));
    81 }
    82 
    83 void IntlCollator::destroy(JSCell* cell)
    84 {
    85     static_cast<IntlCollator*>(cell)->IntlCollator::~IntlCollator();
    8681}
    8782

  • trunk/Source/JavaScriptCore/runtime/IntlCollator.h

    r251425 r253019  
    2828#if ENABLE(INTL)
    2929
    30 #include "JSDestructibleObject.h"
     30#include "JSObject.h"
    3131
    3232struct UCollator;
    … …  
    3737class JSBoundFunction;
    3838
    39 class IntlCollator final : public JSDestructibleObject {
     39class IntlCollator final : public JSNonFinalObject {
    4040public:
    41     typedef JSDestructibleObject Base;
     41    using Base = JSNonFinalObject;
     42
     43    static constexpr bool needsDestruction = true;
     44
     45    static void destroy(JSCell* cell)
     46    {
     47        static_cast<IntlCollator*>(cell)->IntlCollator::~IntlCollator();
     48    }
     49
     50    template<typename CellType, SubspaceAccess mode>
     51    static IsoSubspace* subspaceFor(VM& vm)
     52    {
     53        return vm.intlCollatorSpace<mode>();
     54    }
    4255
    4356    static IntlCollator* create(VM&, Structure*);
    … …  
    5669    IntlCollator(VM&, Structure*);
    5770    void finishCreation(VM&);
    58     static void destroy(JSCell*);
    5971    static void visitChildren(JSCell*, SlotVisitor&);
    6072

  • trunk/Source/JavaScriptCore/runtime/IntlCollatorConstructor.h

    r250803 r253019  
    5555    IntlCollatorConstructor(VM&, Structure*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(IntlCollatorConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/IntlDateTimeFormat.cpp

    r251815 r253019  
    8787
    8888IntlDateTimeFormat::IntlDateTimeFormat(VM& vm, Structure* structure)
    89     : JSDestructibleObject(vm, structure)
     89    : Base(vm, structure)
    9090{
    9191}
    … …  
    9595    Base::finishCreation(vm);
    9696    ASSERT(inherits(vm, info()));
    97 }
    98 
    99 void IntlDateTimeFormat::destroy(JSCell* cell)
    100 {
    101     static_cast<IntlDateTimeFormat*>(cell)->IntlDateTimeFormat::~IntlDateTimeFormat();
    10297}
    10398

  • trunk/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h

    r251425 r253019  
    2828#if ENABLE(INTL)
    2929
    30 #include "JSDestructibleObject.h"
     30#include "JSObject.h"
    3131#include <unicode/udat.h>
    3232#include <unicode/uvernum.h>
    … …  
    3939class JSBoundFunction;
    4040
    41 class IntlDateTimeFormat final : public JSDestructibleObject {
     41class IntlDateTimeFormat final : public JSNonFinalObject {
    4242public:
    43     typedef JSDestructibleObject Base;
     43    using Base = JSNonFinalObject;
     44
     45    static constexpr bool needsDestruction = true;
     46
     47    static void destroy(JSCell* cell)
     48    {
     49        static_cast<IntlDateTimeFormat*>(cell)->IntlDateTimeFormat::~IntlDateTimeFormat();
     50    }
     51
     52    template<typename CellType, SubspaceAccess mode>
     53    static IsoSubspace* subspaceFor(VM& vm)
     54    {
     55        return vm.intlDateTimeFormatSpace<mode>();
     56    }
    4457
    4558    static IntlDateTimeFormat* create(VM&, Structure*);
    … …  
    6174    IntlDateTimeFormat(VM&, Structure*);
    6275    void finishCreation(VM&);
    63     static void destroy(JSCell*);
    6476    static void visitChildren(JSCell*, SlotVisitor&);
    6577

  • trunk/Source/JavaScriptCore/runtime/IntlDateTimeFormatConstructor.h

    r250803 r253019  
    5555    IntlDateTimeFormatConstructor(VM&, Structure*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(IntlDateTimeFormatConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/IntlNumberFormat.cpp

    r251425 r253019  
    6868
    6969IntlNumberFormat::IntlNumberFormat(VM& vm, Structure* structure)
    70     : JSDestructibleObject(vm, structure)
     70    : Base(vm, structure)
    7171{
    7272}
    … …  
    7676    Base::finishCreation(vm);
    7777    ASSERT(inherits(vm, info()));
    78 }
    79 
    80 void IntlNumberFormat::destroy(JSCell* cell)
    81 {
    82     static_cast<IntlNumberFormat*>(cell)->IntlNumberFormat::~IntlNumberFormat();
    8378}
    8479

  • trunk/Source/JavaScriptCore/runtime/IntlNumberFormat.h

    r251425 r253019  
    2828#if ENABLE(INTL)
    2929
    30 #include "JSDestructibleObject.h"
     30#include "JSObject.h"
    3131#include <unicode/unum.h>
    3232#include <unicode/uvernum.h>
    … …  
    3939class JSBoundFunction;
    4040
    41 class IntlNumberFormat final : public JSDestructibleObject {
     41class IntlNumberFormat final : public JSNonFinalObject {
    4242public:
    43     typedef JSDestructibleObject Base;
     43    using Base = JSNonFinalObject;
     44
     45    static constexpr bool needsDestruction = true;
     46
     47    static void destroy(JSCell* cell)
     48    {
     49        static_cast<IntlNumberFormat*>(cell)->IntlNumberFormat::~IntlNumberFormat();
     50    }
     51
     52    template<typename CellType, SubspaceAccess mode>
     53    static IsoSubspace* subspaceFor(VM& vm)
     54    {
     55        return vm.intlNumberFormatSpace<mode>();
     56    }
    4457
    4558    static IntlNumberFormat* create(VM&, Structure*);
    … …  
    6174    IntlNumberFormat(VM&, Structure*);
    6275    void finishCreation(VM&);
    63     static void destroy(JSCell*);
    6476    static void visitChildren(JSCell*, SlotVisitor&);
    6577

  • trunk/Source/JavaScriptCore/runtime/IntlNumberFormatConstructor.h

    r250803 r253019  
    5555    IntlNumberFormatConstructor(VM&, Structure*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(IntlNumberFormatConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/IntlPluralRules.cpp

    r251425 r253019  
    7373
    7474IntlPluralRules::IntlPluralRules(VM& vm, Structure* structure)
    75     : JSDestructibleObject(vm, structure)
     75    : Base(vm, structure)
    7676{
    7777}
    … …  
    8181    Base::finishCreation(vm);
    8282    ASSERT(inherits(vm, info()));
    83 }
    84 
    85 void IntlPluralRules::destroy(JSCell* cell)
    86 {
    87     static_cast<IntlPluralRules*>(cell)->IntlPluralRules::~IntlPluralRules();
    8883}
    8984

  • trunk/Source/JavaScriptCore/runtime/IntlPluralRules.h

    r251425 r253019  
    2828#if ENABLE(INTL)
    2929
    30 #include "JSDestructibleObject.h"
     30#include "JSObject.h"
    3131#include <unicode/unum.h>
    3232#include <unicode/upluralrules.h>
    … …  
    4141class JSBoundFunction;
    4242
    43 class IntlPluralRules final : public JSDestructibleObject {
     43class IntlPluralRules final : public JSNonFinalObject {
    4444public:
    45     typedef JSDestructibleObject Base;
     45    using Base = JSNonFinalObject;
     46
     47    static constexpr bool needsDestruction = true;
     48
     49    static void destroy(JSCell* cell)
     50    {
     51        static_cast<IntlPluralRules*>(cell)->IntlPluralRules::~IntlPluralRules();
     52    }
     53
     54    template<typename CellType, SubspaceAccess mode>
     55    static IsoSubspace* subspaceFor(VM& vm)
     56    {
     57        return vm.intlPluralRulesSpace<mode>();
     58    }
    4659
    4760    static IntlPluralRules* create(VM&, Structure*);
    … …  
    5770    IntlPluralRules(VM&, Structure*);
    5871    void finishCreation(VM&);
    59     static void destroy(JSCell*);
    6072    static void visitChildren(JSCell*, SlotVisitor&);
    6173

  • trunk/Source/JavaScriptCore/runtime/IntlPluralRulesConstructor.h

    r250803 r253019  
    5555    IntlPluralRulesConstructor(VM&, Structure*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(IntlPluralRulesConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/JSArrayBufferConstructor.h

    r250803 r253019  
    6262using JSArrayBufferConstructor = JSGenericArrayBufferConstructor<ArrayBufferSharingMode::Default>;
    6363using JSSharedArrayBufferConstructor = JSGenericArrayBufferConstructor<ArrayBufferSharingMode::Shared>;
    64 static_assert(sizeof(JSArrayBufferConstructor::Base) == sizeof(JSArrayBufferConstructor), "");
    65 static_assert(sizeof(JSSharedArrayBufferConstructor::Base) == sizeof(JSSharedArrayBufferConstructor), "");
     64STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSArrayBufferConstructor, InternalFunction);
     65STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSharedArrayBufferConstructor, InternalFunction);
    6666
    6767} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/JSCell.h

    r252385 r253019  
    9999    JSCell(CreatingEarlyCellTag);
    100100   
     101    JS_EXPORT_PRIVATE static void destroy(JSCell*);
     102
    101103protected:
    102104    JSCell(VM&, Structure*);
    103     JS_EXPORT_PRIVATE static void destroy(JSCell*);
    104105
    105106public:

  • trunk/Source/JavaScriptCore/runtime/JSObject.h

    r252024 r253019  
    16291629    JSC_NATIVE_INTRINSIC_GETTER_WITHOUT_TRANSITION((jsName), (cppName), (attributes), NoIntrinsic)
    16301630
     1631
     1632#define STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(DerivedClass, BaseClass) \
     1633    static_assert(sizeof(DerivedClass) == sizeof(BaseClass)); \
     1634    static_assert(DerivedClass::destroy == BaseClass::destroy);
     1635
    16311636} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/JSTypedArrayConstructors.h

    r206525 r253019  
    3232namespace JSC {
    3333
    34 typedef JSGenericTypedArrayViewConstructor<JSInt8Array> JSInt8ArrayConstructor;
    35 typedef JSGenericTypedArrayViewConstructor<JSInt16Array> JSInt16ArrayConstructor;
    36 typedef JSGenericTypedArrayViewConstructor<JSInt32Array> JSInt32ArrayConstructor;
    37 typedef JSGenericTypedArrayViewConstructor<JSUint8Array> JSUint8ArrayConstructor;
    38 typedef JSGenericTypedArrayViewConstructor<JSUint8ClampedArray> JSUint8ClampedArrayConstructor;
    39 typedef JSGenericTypedArrayViewConstructor<JSUint16Array> JSUint16ArrayConstructor;
    40 typedef JSGenericTypedArrayViewConstructor<JSUint32Array> JSUint32ArrayConstructor;
    41 typedef JSGenericTypedArrayViewConstructor<JSFloat32Array> JSFloat32ArrayConstructor;
    42 typedef JSGenericTypedArrayViewConstructor<JSFloat64Array> JSFloat64ArrayConstructor;
    43 typedef JSGenericTypedArrayViewConstructor<JSDataView> JSDataViewConstructor;
     34using JSInt8ArrayConstructor = JSGenericTypedArrayViewConstructor<JSInt8Array>;
     35using JSInt16ArrayConstructor = JSGenericTypedArrayViewConstructor<JSInt16Array>;
     36using JSInt32ArrayConstructor = JSGenericTypedArrayViewConstructor<JSInt32Array>;
     37using JSUint8ArrayConstructor = JSGenericTypedArrayViewConstructor<JSUint8Array>;
     38using JSUint8ClampedArrayConstructor = JSGenericTypedArrayViewConstructor<JSUint8ClampedArray>;
     39using JSUint16ArrayConstructor = JSGenericTypedArrayViewConstructor<JSUint16Array>;
     40using JSUint32ArrayConstructor = JSGenericTypedArrayViewConstructor<JSUint32Array>;
     41using JSFloat32ArrayConstructor = JSGenericTypedArrayViewConstructor<JSFloat32Array>;
     42using JSFloat64ArrayConstructor = JSGenericTypedArrayViewConstructor<JSFloat64Array>;
     43using JSDataViewConstructor = JSGenericTypedArrayViewConstructor<JSDataView>;
     44STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSInt8ArrayConstructor, InternalFunction);
     45STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSInt16ArrayConstructor, InternalFunction);
     46STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSInt32ArrayConstructor, InternalFunction);
     47STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSUint8ArrayConstructor, InternalFunction);
     48STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSUint8ClampedArrayConstructor, InternalFunction);
     49STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSUint16ArrayConstructor, InternalFunction);
     50STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSUint32ArrayConstructor, InternalFunction);
     51STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFloat32ArrayConstructor, InternalFunction);
     52STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFloat64ArrayConstructor, InternalFunction);
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDataViewConstructor, InternalFunction);
    4454
    4555} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/JSTypedArrayViewConstructor.h

    r229413 r253019  
    5353    static Structure* createStructure(VM&, JSGlobalObject*, JSValue prototype);
    5454};
     55STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTypedArrayViewConstructor, InternalFunction);
    5556   
    5657} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/MapConstructor.h

    r250803 r253019  
    5656    void finishCreation(VM&, MapPrototype*, GetterSetter* speciesSymbol);
    5757};
     58STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(MapConstructor, InternalFunction);
    5859
    5960EncodedJSValue JSC_HOST_CALL mapPrivateFuncMapBucketHead(JSGlobalObject*, CallFrame*);

  • trunk/Source/JavaScriptCore/runtime/NativeErrorConstructor.h

    r250803 r253019  
    7676using URIErrorConstructor = NativeErrorConstructor<ErrorType::URIError>;
    7777
    78 static_assert(sizeof(EvalErrorConstructor) == sizeof(InternalFunction), "");
    79 static_assert(sizeof(RangeErrorConstructor) == sizeof(InternalFunction), "");
    80 static_assert(sizeof(ReferenceErrorConstructor) == sizeof(InternalFunction), "");
    81 static_assert(sizeof(SyntaxErrorConstructor) == sizeof(InternalFunction), "");
    82 static_assert(sizeof(TypeErrorConstructor) == sizeof(InternalFunction), "");
    83 static_assert(sizeof(URIErrorConstructor) == sizeof(InternalFunction), "");
     78STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(EvalErrorConstructor, InternalFunction);
     79STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(RangeErrorConstructor, InternalFunction);
     80STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(ReferenceErrorConstructor, InternalFunction);
     81STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(SyntaxErrorConstructor, InternalFunction);
     82STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(TypeErrorConstructor, InternalFunction);
     83STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(URIErrorConstructor, InternalFunction);
    8484
    8585} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/NullGetterFunction.h

    r252520 r253019  
    5252    NullGetterFunction(VM&, Structure*);
    5353};
     54STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(NullGetterFunction, InternalFunction);
    5455
    5556} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/NullSetterFunction.h

    r252520 r253019  
    5252    NullSetterFunction(VM&, Structure*);
    5353};
     54STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(NullSetterFunction, InternalFunction);
    5455
    5556} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/NumberConstructor.h

    r250005 r253019  
    6464    NumberConstructor(VM&, Structure*);
    6565};
     66STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(NumberConstructor, InternalFunction);
    6667
    6768} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/ObjectConstructor.h

    r251425 r253019  
    6060    ObjectConstructor(VM&, Structure*);
    6161};
     62STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(ObjectConstructor, InternalFunction);
    6263
    6364inline JSFinalObject* constructEmptyObject(VM& vm, Structure* structure)

  • trunk/Source/JavaScriptCore/runtime/ProxyConstructor.h

    r251425 r253019  
    5151    static EncodedJSValue getGetter(JSGlobalObject*, EncodedJSValue thisValue, PropertyName);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(ProxyConstructor, InternalFunction);
    5354
    5455} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/RegExpConstructor.h

    r251483 r253019  
    5656    RegExpConstructor(VM&, Structure*);
    5757};
    58 
    59 static_assert(sizeof(RegExpConstructor) == sizeof(InternalFunction), "");
     58STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(RegExpConstructor, InternalFunction);
    6059
    6160JSObject* constructRegExp(JSGlobalObject*, const ArgList&, JSObject* callee = nullptr, JSValue newTarget = jsUndefined());

  • trunk/Source/JavaScriptCore/runtime/SetConstructor.h

    r250803 r253019  
    5555    void finishCreation(VM&, SetPrototype*, GetterSetter* speciesSymbol);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(SetConstructor, InternalFunction);
    5758
    5859EncodedJSValue JSC_HOST_CALL setPrivateFuncSetBucketHead(JSGlobalObject*, CallFrame*);

  • trunk/Source/JavaScriptCore/runtime/StringConstructor.h

    r251425 r253019  
    5151    void finishCreation(VM&, StringPrototype*);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(StringConstructor, InternalFunction);
    5354
    5455JSString* JSC_HOST_CALL stringFromCharCode(JSGlobalObject*, int32_t);

  • trunk/Source/JavaScriptCore/runtime/SymbolConstructor.h

    r250005 r253019  
    5959    SymbolConstructor(VM&, Structure*);
    6060};
     61STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(SymbolConstructor, InternalFunction);
    6162
    6263} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r253015 r253019  
    4040#include "CustomGetterSetter.h"
    4141#include "DFGWorklist.h"
     42#include "DateInstance.h"
    4243#include "DirectEvalExecutable.h"
    4344#include "Disassembler.h"
    … …  
    179180#endif
    180181
     182#if ENABLE(INTL)
     183#include "IntlCollator.h"
     184#include "IntlDateTimeFormat.h"
     185#include "IntlNumberFormat.h"
     186#include "IntlPluralRules.h"
     187#endif
     188
    181189namespace JSC {
    182190
    … …  
    268276    , cellHeapCellType(makeUnique<HeapCellType>(CellAttributes(DoesNotNeedDestruction, HeapCell::JSCell)))
    269277    , destructibleCellHeapCellType(makeUnique<HeapCellType>(CellAttributes(NeedsDestruction, HeapCell::JSCell)))
     278    , dateInstanceHeapCellType(makeUnique<IsoHeapCellType<DateInstance>>())
     279    , errorInstanceHeapCellType(makeUnique<IsoHeapCellType<ErrorInstance>>())
    270280    , stringHeapCellType(makeUnique<IsoHeapCellType<JSString>>())
    271281    , weakMapHeapCellType(makeUnique<IsoHeapCellType<JSWeakMap>>())
    … …  
    277287#ifdef JSC_GLIB_API_ENABLED
    278288    , jscCallbackFunctionHeapCellType(makeUnique<IsoHeapCellType<JSCCallbackFunction>>())
     289#endif
     290#if ENABLE(INTL)
     291    , intlCollatorHeapCellType(makeUnique<IsoHeapCellType<IntlCollator>>())
     292    , intlDateTimeFormatHeapCellType(makeUnique<IsoHeapCellType<IntlDateTimeFormat>>())
     293    , intlNumberFormatHeapCellType(makeUnique<IsoHeapCellType<IntlNumberFormat>>())
     294    , intlPluralRulesHeapCellType(makeUnique<IsoHeapCellType<IntlPluralRules>>())
    279295#endif
    280296#if ENABLE(WEBASSEMBLY)
    … …  
    290306    , destructibleObjectSpace("JSDestructibleObject", heap, destructibleObjectHeapCellType.get(), fastMallocAllocator.get()) // Hash:0x4f5ed7a9
    291307    , bigIntSpace ISO_SUBSPACE_INIT(heap, destructibleCellHeapCellType.get(), JSBigInt)
     308    , dateInstanceSpace ISO_SUBSPACE_INIT(heap, dateInstanceHeapCellType.get(), DateInstance)
    292309    , executableToCodeBlockEdgeSpace ISO_SUBSPACE_INIT(heap, cellHeapCellType.get(), ExecutableToCodeBlockEdge) // Hash:0x7b730b20
    293310    , functionSpace ISO_SUBSPACE_INIT(heap, cellHeapCellType.get(), JSFunction) // Hash:0x800fca72
    … …  
    13181335DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(callbackFunctionSpace, cellHeapCellType.get(), JSCallbackFunction) // Hash:0xe7648ebc
    13191336DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(customGetterSetterFunctionSpace, cellHeapCellType.get(), JSCustomGetterSetterFunction) // Hash:0x18091000
    1320 DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(errorInstanceSpace, destructibleObjectHeapCellType.get(), ErrorInstance) // Hash:0x3f40d4a
     1337DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(errorInstanceSpace, errorInstanceHeapCellType.get(), ErrorInstance) // Hash:0x3f40d4a
    13211338DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(functionRareDataSpace, destructibleCellHeapCellType.get(), FunctionRareData)
    13221339DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(generatorSpace, cellHeapCellType.get(), JSGenerator)
    … …  
    13381355DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(jscCallbackFunctionSpace, jscCallbackFunctionHeapCellType.get(), JSCCallbackFunction)
    13391356#endif
     1357#if ENABLE(INTL)
     1358DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(intlCollatorSpace, intlCollatorHeapCellType.get(), IntlCollator)
     1359DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(intlDateTimeFormatSpace, intlDateTimeFormatHeapCellType.get(), IntlDateTimeFormat)
     1360DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(intlNumberFormatSpace, intlNumberFormatHeapCellType.get(), IntlNumberFormat)
     1361DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(intlPluralRulesSpace, intlPluralRulesHeapCellType.get(), IntlPluralRules)
     1362#endif
    13401363#if ENABLE(WEBASSEMBLY)
    13411364DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER_SLOW(webAssemblyCodeBlockSpace, webAssemblyCodeBlockHeapCellType.get(), JSWebAssemblyCodeBlock) // Hash:0x9ad995cd

  • trunk/Source/JavaScriptCore/runtime/VM.h

    r253007 r253019  
    110110class CustomGetterSetter;
    111111class DOMAttributeGetterSetter;
     112class DateInstance;
     113class ErrorInstance;
    112114class Exception;
    113115class ExceptionScope;
    … …  
    121123class Identifier;
    122124class Interpreter;
     125class IntlCollator;
     126class IntlDateTimeFormat;
     127class IntlNumberFormat;
     128class IntlPluralRules;
    123129class JSCCallbackFunction;
    124130class JSCustomGetterSetterFunction;
    … …  
    346352    std::unique_ptr<HeapCellType> cellHeapCellType;
    347353    std::unique_ptr<HeapCellType> destructibleCellHeapCellType;
     354    std::unique_ptr<IsoHeapCellType<DateInstance>> dateInstanceHeapCellType;
     355    std::unique_ptr<IsoHeapCellType<ErrorInstance>> errorInstanceHeapCellType;
    348356    std::unique_ptr<IsoHeapCellType<JSString>> stringHeapCellType;
    349357    std::unique_ptr<IsoHeapCellType<JSWeakMap>> weakMapHeapCellType;
    … …  
    355363#ifdef JSC_GLIB_API_ENABLED
    356364    std::unique_ptr<IsoHeapCellType<JSCCallbackFunction>> jscCallbackFunctionHeapCellType;
     365#endif
     366#if ENABLE(INTL)
     367    std::unique_ptr<IsoHeapCellType<IntlCollator>> intlCollatorHeapCellType;
     368    std::unique_ptr<IsoHeapCellType<IntlDateTimeFormat>> intlDateTimeFormatHeapCellType;
     369    std::unique_ptr<IsoHeapCellType<IntlNumberFormat>> intlNumberFormatHeapCellType;
     370    std::unique_ptr<IsoHeapCellType<IntlPluralRules>> intlPluralRulesHeapCellType;
    357371#endif
    358372#if ENABLE(WEBASSEMBLY)
    … …  
    392406   
    393407    IsoSubspace bigIntSpace;
     408    IsoSubspace dateInstanceSpace;
    394409    IsoSubspace executableToCodeBlockEdgeSpace;
    395410    IsoSubspace functionSpace;
    … …  
    443458    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(weakSetSpace)
    444459    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(weakMapSpace)
     460#if ENABLE(INTL)
     461    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(intlCollatorSpace)
     462    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(intlDateTimeFormatSpace)
     463    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(intlNumberFormatSpace)
     464    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(intlPluralRulesSpace)
     465#endif
    445466#if ENABLE(WEBASSEMBLY)
    446467    DYNAMIC_ISO_SUBSPACE_DEFINE_MEMBER(webAssemblyCodeBlockSpace)

  • trunk/Source/JavaScriptCore/runtime/WeakMapConstructor.h

    r229413 r253019  
    5555    void finishCreation(VM&, WeakMapPrototype*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WeakMapConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/WeakObjectRefConstructor.h

    r246596 r253019  
    5454    void finishCreation(VM&, WeakObjectRefPrototype*);
    5555};
    56 
    57 static_assert(sizeof(WeakObjectRefConstructor) == sizeof(InternalFunction));
     56STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WeakObjectRefConstructor, InternalFunction);
    5857
    5958}

  • trunk/Source/JavaScriptCore/runtime/WeakSetConstructor.h

    r229413 r253019  
    5555    void finishCreation(VM&, WeakSetPrototype*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WeakSetConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/tools/JSDollarVM.cpp

    r253008 r253019  
    106106// Instead, these constructors should always be ALWAYS_INLINE.
    107107
    108 class JSDollarVMCallFrame : public JSDestructibleObject {
    109     using Base = JSDestructibleObject;
     108class JSDollarVMCallFrame : public JSNonFinalObject {
     109    using Base = JSNonFinalObject;
    110110public:
    111111    JSDollarVMCallFrame(VM& vm, Structure* structure)

  • trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyCompileError.h

    r251425 r253019  
    3434class JSWebAssemblyCompileError final : public ErrorInstance {
    3535public:
    36     typedef ErrorInstance Base;
     36    using Base = ErrorInstance;
    3737
    3838    static JSWebAssemblyCompileError* create(JSGlobalObject*, VM&, Structure*, const String&);
    … …  
    4747    JSWebAssemblyCompileError(VM&, Structure*);
    4848};
     49STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSWebAssemblyCompileError, ErrorInstance);
    4950
    5051JSObject* createJSWebAssemblyCompileError(JSGlobalObject*, VM&, const String&);

  • trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyLinkError.h

    r251425 r253019  
    4747    JSWebAssemblyLinkError(VM&, Structure*);
    4848};
     49STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSWebAssemblyLinkError, ErrorInstance);
    4950
    5051JSObject* createJSWebAssemblyLinkError(JSGlobalObject*, VM&, const String&);

  • trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyRuntimeError.h

    r251425 r253019  
    4343    JSWebAssemblyRuntimeError(VM&, Structure*);
    4444};
     45STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSWebAssemblyRuntimeError, ErrorInstance);
    4546
    4647JSObject* createJSWebAssemblyRuntimeError(JSGlobalObject*, VM&, const String&);

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyCompileErrorConstructor.h

    r250005 r253019  
    5151    WebAssemblyCompileErrorConstructor(VM&, Structure*);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyCompileErrorConstructor, InternalFunction);
    5354
    5455} // namespace JSC

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.h

    r251425 r253019  
    5555    WebAssemblyInstanceConstructor(VM&, Structure*);
    5656};
     57STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyInstanceConstructor, InternalFunction);
    5758
    5859} // namespace JSC

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyLinkErrorConstructor.h

    r250005 r253019  
    5151    WebAssemblyLinkErrorConstructor(VM&, Structure*);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyLinkErrorConstructor, InternalFunction);
    5354
    5455} // namespace JSC

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyMemoryConstructor.h

    r250005 r253019  
    5151    WebAssemblyMemoryConstructor(VM&, Structure*);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyMemoryConstructor, InternalFunction);
    5354
    5455} // namespace JSC

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleConstructor.h

    r251425 r253019  
    5656    WebAssemblyModuleConstructor(VM&, Structure*);
    5757};
     58STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyModuleConstructor, InternalFunction);
    5859
    5960} // namespace JSC

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyRuntimeErrorConstructor.h

    r250005 r253019  
    5151    WebAssemblyRuntimeErrorConstructor(VM&, Structure*);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyRuntimeErrorConstructor, InternalFunction);
    5354
    5455} // namespace JSC

  • trunk/Source/JavaScriptCore/wasm/js/WebAssemblyTableConstructor.h

    r250005 r253019  
    5151    WebAssemblyTableConstructor(VM&, Structure*);
    5252};
     53STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(WebAssemblyTableConstructor, InternalFunction);
    5354
    5455} // namespace JSC
Note: See TracChangeset for help on using the changeset viewer.