Changeset 290193 in webkit


Ignore:
Timestamp:
Feb 18, 2022, 7:21:11 PM (3 years ago)
Author:
mark.lam@apple.com
Message:

Unreviewed, reverting r290188.
​https://bugs.webkit.org/show_bug.cgi?id=236875

Broke WebKitGTK & WPE build bots

Reverted changeset:

"Provide a WebCore subspaceImplFor template to make code more
readable."
​https://bugs.webkit.org/show_bug.cgi?id=236868
​https://commits.webkit.org/r290188

Patch by Commit Queue <​commit-queue@webkit.org> on 2022-02-18

Location:
trunk/Source/WebCore
Files:
2 deleted
91 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r290189 r290193  
     12022-02-18  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, reverting r290188.
     4        https://bugs.webkit.org/show_bug.cgi?id=236875
     5
     6        Broke WebKitGTK &amp; WPE build bots
     7
     8        Reverted changeset:
     9
     10        "Provide a WebCore subspaceImplFor template to make code more
     11        readable."
     12        https://bugs.webkit.org/show_bug.cgi?id=236868
     13        https://commits.webkit.org/r290188
     14
    1152022-02-18  Per Arne Vollan  <pvollan@apple.com>
    216

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r290189 r290193  
    24212421                7BDDA31F274FA0210038659E /* GraphicsContextGLCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BDDA31D274F9DA50038659E /* GraphicsContextGLCocoa.h */; settings = {ATTRIBUTES = (Private, ); }; };
    24222422                7BDDA34C275A01310038659E /* ProcessIdentity.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BDDA349275A01300038659E /* ProcessIdentity.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2423                7BE37F8727BBB708007A6CD3 /* VideoFrameCV.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BE37F8627BBB6FF007A6CD3 /* VideoFrameCV.h */; settings = {ATTRIBUTES = (Private, ); }; };
    24232424                7BE37F7A27BB86AB007A6CD3 /* GraphicsContextGLCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 7BDDA31C274F9DA40038659E /* GraphicsContextGLCocoa.mm */; };
    24242425                7BE37F7C27BB86B8007A6CD3 /* ANGLEUtilitiesCocoa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7BCD42DA2705C94900EB2127 /* ANGLEUtilitiesCocoa.cpp */; };
    24252426                7BE37F7D27BB86CD007A6CD3 /* ANGLEUtilities.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7BCD42D8270599EF00EB2127 /* ANGLEUtilities.cpp */; };
    24262427                7BE37F7E27BB86DB007A6CD3 /* GraphicsContextGLCVCocoa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B10339A2549720000C8C1AC /* GraphicsContextGLCVCocoa.cpp */; };
    2427                 7BE37F8727BBB708007A6CD3 /* VideoFrameCV.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BE37F8627BBB6FF007A6CD3 /* VideoFrameCV.h */; settings = {ATTRIBUTES = (Private, ); }; };
    24282428                7BE7427381FA906FBB4F0F2C /* JSSVGGraphicsElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 950C4C02BED8936F818E2F99 /* JSSVGGraphicsElement.h */; };
    24292429                7BFF59F42757726700773D39 /* DisplayConfigurationMonitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BFF59EF275771E800773D39 /* DisplayConfigurationMonitor.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    57455745                FDF6BAF9134A4C9800822920 /* JSOfflineAudioCompletionEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = FDF6BAF7134A4C9800822920 /* JSOfflineAudioCompletionEvent.h */; };
    57465746                FDF7E9C413AC21DB00A51EAC /* JSAudioBufferCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = FDF7E9C213AC21DB00A51EAC /* JSAudioBufferCallback.h */; };
    5747                 FE0BCF3427C0661000BFB2DB /* ExtendedDOMIsoSubspaces.h in Headers */ = {isa = PBXBuildFile; fileRef = FE0BCF3127C0660F00BFB2DB /* ExtendedDOMIsoSubspaces.h */; };
    5748                 FE0BCF3527C0661000BFB2DB /* ExtendedDOMClientIsoSubspaces.h in Headers */ = {isa = PBXBuildFile; fileRef = FE0BCF3327C0661000BFB2DB /* ExtendedDOMClientIsoSubspaces.h */; };
    57495747                FE0D84E910484348001A179E /* WebEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = FE0D84E810484348001A179E /* WebEvent.h */; settings = {ATTRIBUTES = (Private, ); }; };
    57505748                FE36FD1516C7826500F887C1 /* ChangeVersionData.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1116C7826400F887C1 /* ChangeVersionData.h */; };
    … …  
    1829418292                FDF7E9C113AC21DB00A51EAC /* JSAudioBufferCallback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSAudioBufferCallback.cpp; sourceTree = "<group>"; };
    1829518293                FDF7E9C213AC21DB00A51EAC /* JSAudioBufferCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAudioBufferCallback.h; sourceTree = "<group>"; };
    18296                 FE0BCF3127C0660F00BFB2DB /* ExtendedDOMIsoSubspaces.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExtendedDOMIsoSubspaces.h; sourceTree = "<group>"; };
    18297                 FE0BCF3327C0661000BFB2DB /* ExtendedDOMClientIsoSubspaces.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExtendedDOMClientIsoSubspaces.h; sourceTree = "<group>"; };
    1829818294                FE0D84E810484348001A179E /* WebEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebEvent.h; sourceTree = "<group>"; };
    1829918295                FE0D84EA1048436E001A179E /* WebEvent.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebEvent.mm; sourceTree = "<group>"; };
    … …  
    2934129337                                BC53DA2D1143121E000D817E /* DOMWrapperWorld.h */,
    2934229338                                2D293869235F6B6800C7F3B2 /* ExceptionDetails.h */,
    29343                                 FE0BCF3327C0661000BFB2DB /* ExtendedDOMClientIsoSubspaces.h */,
    29344                                 FE0BCF3127C0660F00BFB2DB /* ExtendedDOMIsoSubspaces.h */,
    2934529339                                1432E8480C51493F00B1500F /* GCController.cpp */,
    2934629340                                1432E8460C51493800B1500F /* GCController.h */,
    … …  
    3518935183                                71025EDE1F99F1EC004A250C /* JSAnimationTimeline.h in Headers */,
    3519035184                                A1956F1C2331A6770057E9D2 /* JSApplePayCancelEvent.h in Headers */,
    35191                                 FE0BCF3527C0661000BFB2DB /* ExtendedDOMClientIsoSubspaces.h in Headers */,
    3519235185                                A1DF5A991F7EC8C00058A477 /* JSApplePayContactField.h in Headers */,
    3519335186                                9596B93825DEEF0300ED2CFA /* JSApplePayCouponCodeChangedEvent.h in Headers */,
    … …  
    3711237105                                3135910B1E7DDC7300F30630 /* RTCSignalingState.h in Headers */,
    3711337106                                078E092A17D14D1C00420AA1 /* RTCStatsReport.h in Headers */,
    37114                                 FE0BCF3427C0661000BFB2DB /* ExtendedDOMIsoSubspaces.h in Headers */,
    3711537107                                5E2C43681BCEE3770001E2BC /* RTCTrackEvent.h in Headers */,
    3711637108                                078E094717D16E1C00420AA1 /* RTCVoidRequest.h in Headers */,

  • trunk/Source/WebCore/bindings/js/JSFileSystemDirectoryHandleIterator.cpp

    r290188 r290193  
    2727#include "JSFileSystemDirectoryHandleIterator.h"
    2828
    29 #include "ExtendedDOMClientIsoSubspaces.h"
    30 #include "ExtendedDOMIsoSubspaces.h"
    3129#include "JSDOMOperation.h"
    3230#include "WebCoreJSClientData.h"
    … …  
    5351{
    5452    JSLockHolder apiLocker(vm);
    55     return subspaceForImpl<JSFileSystemDirectoryHandleIterator, UseCustomHeapCellType::No>(vm,
    56         [] (auto& spaces) { return spaces.m_clientSubspaceForFileSystemDirectoryHandleIterator.get(); },
    57         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemDirectoryHandleIterator = WTFMove(space); },
    58         [] (auto& spaces) { return spaces.m_subspaceForFileSystemDirectoryHandleIterator.get(); },
    59         [] (auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemDirectoryHandleIterator = WTFMove(space); }
    60     );
     53    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     54    if (auto* clientSpace = clientData.fileSystemDirectoryHandleIteratorSpace())
     55        return clientSpace;
     56
     57    auto& heapData = clientData.heapData();
     58    Locker locker { heapData.lock() };
     59
     60    IsoSubspace* space = heapData.fileSystemDirectoryHandleIteratorSpace();
     61    if (!space) {
     62        Heap& heap = vm.heap;
     63        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSFileSystemDirectoryHandleIterator> || !JSFileSystemDirectoryHandleIterator::needsDestruction);
     64        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSFileSystemDirectoryHandleIterator>)
     65            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSFileSystemDirectoryHandleIterator);
     66        else
     67            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSFileSystemDirectoryHandleIterator);
     68        heapData.setFileSystemDirectoryHandleIteratorSpace(std::unique_ptr<IsoSubspace>(space));
     69
     70IGNORE_WARNINGS_BEGIN("unreachable-code")
     71IGNORE_WARNINGS_BEGIN("tautological-compare")
     72        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSFileSystemDirectoryHandleIterator::visitOutputConstraints;
     73        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     74        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     75            heapData.outputConstraintSpaces().append(space);
     76IGNORE_WARNINGS_END
     77IGNORE_WARNINGS_END
     78    }
     79
     80    auto* clientSpace = new GCClient::IsoSubspace(*space);
     81    clientData.setFileSystemDirectoryHandleIteratorSpace(std::unique_ptr<GCClient::IsoSubspace>(clientSpace));
     82    return clientSpace;
    6183}
    6284

  • trunk/Source/WebCore/bindings/js/WebCoreJSClientData.cpp

    r290188 r290193  
    2727#include "WebCoreJSClientData.h"
    2828
     29#include "DOMClientIsoSubspaces.h"
    2930#include "DOMGCOutputConstraint.h"
    30 #include "ExtendedDOMClientIsoSubspaces.h"
    31 #include "ExtendedDOMIsoSubspaces.h"
     31#include "DOMIsoSubspaces.h"
    3232#include "JSAudioWorkletGlobalScope.h"
    3333#include "JSDOMBinding.h"
    … …  
    9191    , m_windowProxySpace ISO_SUBSPACE_INIT(heap, m_windowProxyHeapCellType, JSWindowProxy)
    9292    , m_idbSerializationSpace ISO_SUBSPACE_INIT(heap, m_heapCellTypeForJSIDBSerializationGlobalObject, JSIDBSerializationGlobalObject)
    93     , m_subspaces(makeUnique<ExtendedDOMIsoSubspaces>())
     93    , m_subspaces(makeUnique<DOMIsoSubspaces>())
    9494{
    9595}
    … …  
    123123    , CLIENT_ISO_SUBSPACE_INIT(m_windowProxySpace)
    124124    , CLIENT_ISO_SUBSPACE_INIT(m_idbSerializationSpace)
    125     , m_clientSubspaces(makeUnique<ExtendedDOMClientIsoSubspaces>())
     125    , m_clientSubspaces(makeUnique<DOMClientIsoSubspaces>())
    126126{
    127127}

  • trunk/Source/WebCore/bindings/js/WebCoreJSClientData.h

    r290188 r290193  
    3232namespace WebCore {
    3333
    34 class ExtendedDOMClientIsoSubspaces;
    35 class ExtendedDOMIsoSubspaces;
     34class DOMClientIsoSubspaces;
     35class DOMIsoSubspaces;
    3636
    3737class JSHeapData {
    … …  
    4545
    4646    Lock& lock() { return m_lock; }
    47     ExtendedDOMIsoSubspaces& subspaces() { return *m_subspaces.get(); }
     47    DOMIsoSubspaces& subspaces() { return *m_subspaces.get(); }
    4848
    4949    Vector<JSC::IsoSubspace*>& outputConstraintSpaces() { return m_outputConstraintSpaces; }
    … …  
    5555            func(*space);
    5656    }
     57
     58    JSC::IsoSubspace* fileSystemDirectoryHandleIteratorSpace() { return m_fileSystemDirectoryHandleIteratorSpace.get(); }
     59    void setFileSystemDirectoryHandleIteratorSpace(std::unique_ptr<JSC::IsoSubspace> space) { m_fileSystemDirectoryHandleIteratorSpace = std::exchange(space, nullptr); }
    5760
    5861private:
    … …  
    9194    JSC::IsoSubspace m_windowProxySpace;
    9295    JSC::IsoSubspace m_idbSerializationSpace;
     96    std::unique_ptr<JSC::IsoSubspace> m_fileSystemDirectoryHandleIteratorSpace;
    9397
    94     std::unique_ptr<ExtendedDOMIsoSubspaces> m_subspaces;
     98    std::unique_ptr<DOMIsoSubspaces> m_subspaces;
    9599    Vector<JSC::IsoSubspace*> m_outputConstraintSpaces;
    96100};
    … …  
    138142    JSC::GCClient::IsoSubspace& windowProxySpace() { return m_windowProxySpace; }
    139143    JSC::GCClient::IsoSubspace& idbSerializationSpace() { return m_idbSerializationSpace; }
     144    JSC::GCClient::IsoSubspace* fileSystemDirectoryHandleIteratorSpace() { return m_fileSystemDirectoryHandleIteratorSpace.get(); }
     145    void setFileSystemDirectoryHandleIteratorSpace(std::unique_ptr<JSC::GCClient::IsoSubspace> space) { m_fileSystemDirectoryHandleIteratorSpace = std::exchange(space, nullptr); }
    140146
    141     ExtendedDOMClientIsoSubspaces& clientSubspaces() { return *m_clientSubspaces.get(); }
     147    DOMClientIsoSubspaces& clientSubspaces() { return *m_clientSubspaces.get(); }
    142148
    143149private:
    … …  
    159165    JSC::GCClient::IsoSubspace m_idbSerializationSpace;
    160166
    161     std::unique_ptr<ExtendedDOMClientIsoSubspaces> m_clientSubspaces;
     167    std::unique_ptr<JSC::GCClient::IsoSubspace> m_fileSystemDirectoryHandleIteratorSpace;
     168    std::unique_ptr<DOMClientIsoSubspaces> m_clientSubspaces;
    162169};
    163170
    164 
    165 enum class UseCustomHeapCellType { Yes, No };
    166 
    167 template<typename T, UseCustomHeapCellType useCustomHeapCellType, typename GetClient, typename SetClient, typename GetServer, typename SetServer>
    168 ALWAYS_INLINE JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm, GetClient getClient, SetClient setClient, GetServer getServer, SetServer setServer, JSC::HeapCellType& (*getCustomHeapCellType)(JSHeapData&) = nullptr)
    169 {
    170     auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
    171     auto& clientSubspaces = clientData.clientSubspaces();
    172     if (auto* clientSpace = getClient(clientSubspaces))
    173         return clientSpace;
    174 
    175     auto& heapData = clientData.heapData();
    176     Locker locker { heapData.lock() };
    177 
    178     auto& subspaces = heapData.subspaces();
    179     JSC::IsoSubspace* space = getServer(subspaces);
    180     if (!space) {
    181         JSC::Heap& heap = vm.heap;
    182         std::unique_ptr<JSC::IsoSubspace> uniqueSubspace;
    183         static_assert(useCustomHeapCellType == UseCustomHeapCellType::Yes || std::is_base_of_v<JSC::JSDestructibleObject, T> || !T::needsDestruction);
    184         if constexpr (useCustomHeapCellType == UseCustomHeapCellType::Yes)
    185             uniqueSubspace = makeUnique<JSC::IsoSubspace> ISO_SUBSPACE_INIT(heap, getCustomHeapCellType(heapData), T);
    186         else {
    187             if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, T>)
    188                 uniqueSubspace = makeUnique<JSC::IsoSubspace> ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, T);
    189             else
    190                 uniqueSubspace = makeUnique<JSC::IsoSubspace> ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, T);
    191         }
    192         space = uniqueSubspace.get();
    193         setServer(subspaces, uniqueSubspace);
    194 
    195 IGNORE_WARNINGS_BEGIN("unreachable-code")
    196 IGNORE_WARNINGS_BEGIN("tautological-compare")
    197         void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = T::visitOutputConstraints;
    198         void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
    199         if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
    200             heapData.outputConstraintSpaces().append(space);
    201 IGNORE_WARNINGS_END
    202 IGNORE_WARNINGS_END
    203     }
    204 
    205     auto uniqueClientSubspace = makeUnique<JSC::GCClient::IsoSubspace>(*space);
    206     auto* clientSpace = uniqueClientSubspace.get();
    207     setClient(clientSubspaces, uniqueClientSubspace);
    208     return clientSpace;
    209 }
    210 
    211171} // namespace WebCore

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r290188 r290193  
    48724872    GenerateIterableDefinition($interface) if $interface->iterable;
    48734873
    4874     AddToImplIncludes("ExtendedDOMClientIsoSubspaces.h");
    4875     AddToImplIncludes("ExtendedDOMIsoSubspaces.h");
     4874    AddToImplIncludes("DOMClientIsoSubspaces.h");
     4875    AddToImplIncludes("DOMIsoSubspaces.h");
    48764876    AddToImplIncludes("WebCoreJSClientData.h");
    48774877    AddToImplIncludes("<JavaScriptCore/JSDestructibleObjectHeapCellType.h>");
    … …  
    48804880    push(@implContent, "JSC::GCClient::IsoSubspace* ${className}::subspaceForImpl(JSC::VM& vm)\n");
    48814881    push(@implContent, "{\n");
    4882 
    4883     my $useCustomHeapCell;
    4884     my $customHeapCellTypeGetter;
     4882    push(@implContent, "    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);\n");
     4883    push(@implContent, "    auto& clientSpaces = clientData.clientSubspaces();\n");
     4884    push(@implContent, "    if (auto* clientSpace = clientSpaces.m_clientSubspaceFor${interfaceName}.get())\n");
     4885    push(@implContent, "        return clientSpace;\n");
     4886    push(@implContent, "\n");
     4887    push(@implContent, "    auto& heapData = clientData.heapData();\n");
     4888    push(@implContent, "    Locker locker { heapData.lock() };\n");
     4889    push(@implContent, "\n");
     4890    push(@implContent, "    auto& spaces = heapData.subspaces();\n");
     4891    push(@implContent, "    IsoSubspace* space = spaces.m_subspaceFor${interfaceName}.get();\n");
     4892    push(@implContent, "    if (!space) {\n");
     4893    push(@implContent, "        Heap& heap = vm.heap;\n");
     4894
    48854895    if (IsDOMGlobalObject($interface)) {
    4886         $useCustomHeapCell = "Yes";
    4887         $customHeapCellTypeGetter = "[] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeFor${className}; }";
     4896        push(@implContent, "        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeFor${className}, ${className});\n");
    48884897    } else {
    4889         $useCustomHeapCell = "No";
    4890         $customHeapCellTypeGetter = "nullptr";
    4891     }
    4892 
    4893     push(@implContent, "    return subspaceForImpl<${className}, UseCustomHeapCellType::$useCustomHeapCell>(vm,\n");
    4894     push(@implContent, "        [] (auto& spaces) { return spaces.m_clientSubspaceFor${interfaceName}.get(); },\n");
    4895     push(@implContent, "        [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceFor${interfaceName} = WTFMove(space); },\n");
    4896     push(@implContent, "        [] (auto& spaces) { return spaces.m_subspaceFor${interfaceName}.get(); },\n");
    4897     push(@implContent, "        [] (auto& spaces, auto&& space) { spaces.m_subspaceFor${interfaceName} = WTFMove(space); },\n");
    4898     push(@implContent, "        $customHeapCellTypeGetter\n");
    4899     push(@implContent, "    );\n");
     4898        push(@implContent, "        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, ${className}> || !${className}::needsDestruction);\n");
     4899        push(@implContent, "        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, ${className}>)\n");
     4900        push(@implContent, "            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, ${className});\n");
     4901        push(@implContent, "        else\n");
     4902        push(@implContent, "            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, ${className});\n");
     4903    }
     4904    push(@implContent, "        spaces.m_subspaceFor${interfaceName} = std::unique_ptr<IsoSubspace>(space);\n");
     4905    push(@implContent, "IGNORE_WARNINGS_BEGIN(\"unreachable-code\")\n");
     4906    push(@implContent, "IGNORE_WARNINGS_BEGIN(\"tautological-compare\")\n");
     4907    push(@implContent, "        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = ${className}::visitOutputConstraints;\n");
     4908    push(@implContent, "        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;\n");
     4909    push(@implContent, "        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)\n");
     4910    push(@implContent, "            heapData.outputConstraintSpaces().append(space);\n");
     4911    push(@implContent, "IGNORE_WARNINGS_END\n");
     4912    push(@implContent, "IGNORE_WARNINGS_END\n");
     4913    push(@implContent, "    }\n");
     4914    push(@implContent, "\n");
     4915
     4916    push(@implContent, "    clientSpaces.m_clientSubspaceFor${interfaceName} = makeUnique<JSC::GCClient::IsoSubspace>(*space);\n");
     4917    push(@implContent, "    return clientSpaces.m_clientSubspaceFor${interfaceName}.get();\n");
    49004918    push(@implContent, "}\n\n");
    49014919
    … …  
    67856803        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
    67866804            return nullptr;
    6787         return subspaceForImpl<${iteratorName}, UseCustomHeapCellType::No>(vm,
    6788             [] (auto& spaces) { return spaces.m_clientSubspaceFor${iteratorName}.get(); },
    6789             [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceFor${iteratorName} = WTFMove(space); },
    6790             [] (auto& spaces) { return spaces.m_subspaceFor${iteratorName}.get(); },
    6791             [] (auto& spaces, auto&& space) { spaces.m_subspaceFor${iteratorName} = WTFMove(space); }
    6792         );
     6805        auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     6806        auto& clientSpaces = clientData.clientSubspaces();
     6807        if (auto* clientSpace = clientSpaces.m_clientSubspaceFor${iteratorName}.get())
     6808            return clientSpace;
     6809
     6810        auto& heapData = clientData.heapData();
     6811        Locker locker { heapData.lock() };
     6812
     6813        auto& spaces = heapData.subspaces();
     6814        IsoSubspace* space = spaces.m_subspaceFor${iteratorName}.get();
     6815        if (!space) {
     6816            Heap& heap = vm.heap;
     6817            static_assert(std::is_base_of_v<JSC::JSDestructibleObject, ${iteratorName}> || !${iteratorName}::needsDestruction);
     6818            if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, ${iteratorName}>)
     6819                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, ${iteratorName});
     6820            else
     6821                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, ${iteratorName});
     6822            spaces.m_subspaceFor${iteratorName} = std::unique_ptr<IsoSubspace>(space);
     6823IGNORE_WARNINGS_BEGIN(\"unreachable-code\")
     6824IGNORE_WARNINGS_BEGIN(\"tautological-compare\")
     6825            void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = ${iteratorName}::visitOutputConstraints;
     6826            void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     6827            if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     6828                heapData.outputConstraintSpaces().append(space);
     6829IGNORE_WARNINGS_END
     6830IGNORE_WARNINGS_END
     6831        }
     6832
     6833        clientSpaces.m_clientSubspaceFor${iteratorName} = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     6834        return clientSpaces.m_clientSubspaceFor${iteratorName}.get();
    67936835    }
    67946836

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSDOMWindow.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    367367JSC::GCClient::IsoSubspace* JSDOMWindow::subspaceForImpl(JSC::VM& vm)
    368368{
    369     return subspaceForImpl<JSDOMWindow, UseCustomHeapCellType::Yes>(vm,
    370         [] (auto& spaces) { return spaces.m_clientSubspaceForDOMWindow.get(); },
    371         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForDOMWindow = WTFMove(space); },
    372         [] (auto& spaces) { return spaces.m_subspaceForDOMWindow.get(); },
    373         [] (auto& spaces, auto&& space) { spaces.m_subspaceForDOMWindow = WTFMove(space); },
    374         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSDOMWindow; }
    375     );
     369    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     370    auto& clientSpaces = clientData.clientSubspaces();
     371    if (auto* clientSpace = clientSpaces.m_clientSubspaceForDOMWindow.get())
     372        return clientSpace;
     373
     374    auto& heapData = clientData.heapData();
     375    Locker locker { heapData.lock() };
     376
     377    auto& spaces = heapData.subspaces();
     378    IsoSubspace* space = spaces.m_subspaceForDOMWindow.get();
     379    if (!space) {
     380        Heap& heap = vm.heap;
     381        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSDOMWindow, JSDOMWindow);
     382        spaces.m_subspaceForDOMWindow = std::unique_ptr<IsoSubspace>(space);
     383IGNORE_WARNINGS_BEGIN("unreachable-code")
     384IGNORE_WARNINGS_BEGIN("tautological-compare")
     385        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSDOMWindow::visitOutputConstraints;
     386        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     387        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     388            heapData.outputConstraintSpaces().append(space);
     389IGNORE_WARNINGS_END
     390IGNORE_WARNINGS_END
     391    }
     392
     393    clientSpaces.m_clientSubspaceForDOMWindow = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     394    return clientSpaces.m_clientSubspaceForDOMWindow.get();
    376395}
    377396

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSDedicatedWorkerGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DedicatedWorkerGlobalScope.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
    2828#include "JSDOMAttribute.h"
    2929#include "JSDOMBinding.h"
    … …  
    168168JSC::GCClient::IsoSubspace* JSDedicatedWorkerGlobalScope::subspaceForImpl(JSC::VM& vm)
    169169{
    170     return subspaceForImpl<JSDedicatedWorkerGlobalScope, UseCustomHeapCellType::Yes>(vm,
    171         [] (auto& spaces) { return spaces.m_clientSubspaceForDedicatedWorkerGlobalScope.get(); },
    172         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForDedicatedWorkerGlobalScope = WTFMove(space); },
    173         [] (auto& spaces) { return spaces.m_subspaceForDedicatedWorkerGlobalScope.get(); },
    174         [] (auto& spaces, auto&& space) { spaces.m_subspaceForDedicatedWorkerGlobalScope = WTFMove(space); },
    175         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSDedicatedWorkerGlobalScope; }
    176     );
     170    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     171    auto& clientSpaces = clientData.clientSubspaces();
     172    if (auto* clientSpace = clientSpaces.m_clientSubspaceForDedicatedWorkerGlobalScope.get())
     173        return clientSpace;
     174
     175    auto& heapData = clientData.heapData();
     176    Locker locker { heapData.lock() };
     177
     178    auto& spaces = heapData.subspaces();
     179    IsoSubspace* space = spaces.m_subspaceForDedicatedWorkerGlobalScope.get();
     180    if (!space) {
     181        Heap& heap = vm.heap;
     182        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSDedicatedWorkerGlobalScope, JSDedicatedWorkerGlobalScope);
     183        spaces.m_subspaceForDedicatedWorkerGlobalScope = std::unique_ptr<IsoSubspace>(space);
     184IGNORE_WARNINGS_BEGIN("unreachable-code")
     185IGNORE_WARNINGS_BEGIN("tautological-compare")
     186        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSDedicatedWorkerGlobalScope::visitOutputConstraints;
     187        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     188        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     189            heapData.outputConstraintSpaces().append(space);
     190IGNORE_WARNINGS_END
     191IGNORE_WARNINGS_END
     192    }
     193
     194    clientSpaces.m_clientSubspaceForDedicatedWorkerGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     195    return clientSpaces.m_clientSubspaceForDedicatedWorkerGlobalScope.get();
    177196}
    178197

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSExposedStar.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMBinding.h"
    … …  
    232232JSC::GCClient::IsoSubspace* JSExposedStar::subspaceForImpl(JSC::VM& vm)
    233233{
    234     return subspaceForImpl<JSExposedStar, UseCustomHeapCellType::No>(vm,
    235         [] (auto& spaces) { return spaces.m_clientSubspaceForExposedStar.get(); },
    236         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForExposedStar = WTFMove(space); },
    237         [] (auto& spaces) { return spaces.m_subspaceForExposedStar.get(); },
    238         [] (auto& spaces, auto&& space) { spaces.m_subspaceForExposedStar = WTFMove(space); },
    239         nullptr
    240     );
     234    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     235    auto& clientSpaces = clientData.clientSubspaces();
     236    if (auto* clientSpace = clientSpaces.m_clientSubspaceForExposedStar.get())
     237        return clientSpace;
     238
     239    auto& heapData = clientData.heapData();
     240    Locker locker { heapData.lock() };
     241
     242    auto& spaces = heapData.subspaces();
     243    IsoSubspace* space = spaces.m_subspaceForExposedStar.get();
     244    if (!space) {
     245        Heap& heap = vm.heap;
     246        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSExposedStar> || !JSExposedStar::needsDestruction);
     247        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSExposedStar>)
     248            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSExposedStar);
     249        else
     250            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSExposedStar);
     251        spaces.m_subspaceForExposedStar = std::unique_ptr<IsoSubspace>(space);
     252IGNORE_WARNINGS_BEGIN("unreachable-code")
     253IGNORE_WARNINGS_BEGIN("tautological-compare")
     254        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSExposedStar::visitOutputConstraints;
     255        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     256        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     257            heapData.outputConstraintSpaces().append(space);
     258IGNORE_WARNINGS_END
     259IGNORE_WARNINGS_END
     260    }
     261
     262    clientSpaces.m_clientSubspaceForExposedStar = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     263    return clientSpaces.m_clientSubspaceForExposedStar.get();
    241264}
    242265

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSExposedToWorkerAndWindow.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructor.h"
    … …  
    250250JSC::GCClient::IsoSubspace* JSExposedToWorkerAndWindow::subspaceForImpl(JSC::VM& vm)
    251251{
    252     return subspaceForImpl<JSExposedToWorkerAndWindow, UseCustomHeapCellType::No>(vm,
    253         [] (auto& spaces) { return spaces.m_clientSubspaceForExposedToWorkerAndWindow.get(); },
    254         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForExposedToWorkerAndWindow = WTFMove(space); },
    255         [] (auto& spaces) { return spaces.m_subspaceForExposedToWorkerAndWindow.get(); },
    256         [] (auto& spaces, auto&& space) { spaces.m_subspaceForExposedToWorkerAndWindow = WTFMove(space); },
    257         nullptr
    258     );
     252    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     253    auto& clientSpaces = clientData.clientSubspaces();
     254    if (auto* clientSpace = clientSpaces.m_clientSubspaceForExposedToWorkerAndWindow.get())
     255        return clientSpace;
     256
     257    auto& heapData = clientData.heapData();
     258    Locker locker { heapData.lock() };
     259
     260    auto& spaces = heapData.subspaces();
     261    IsoSubspace* space = spaces.m_subspaceForExposedToWorkerAndWindow.get();
     262    if (!space) {
     263        Heap& heap = vm.heap;
     264        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSExposedToWorkerAndWindow> || !JSExposedToWorkerAndWindow::needsDestruction);
     265        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSExposedToWorkerAndWindow>)
     266            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSExposedToWorkerAndWindow);
     267        else
     268            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSExposedToWorkerAndWindow);
     269        spaces.m_subspaceForExposedToWorkerAndWindow = std::unique_ptr<IsoSubspace>(space);
     270IGNORE_WARNINGS_BEGIN("unreachable-code")
     271IGNORE_WARNINGS_BEGIN("tautological-compare")
     272        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSExposedToWorkerAndWindow::visitOutputConstraints;
     273        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     274        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     275            heapData.outputConstraintSpaces().append(space);
     276IGNORE_WARNINGS_END
     277IGNORE_WARNINGS_END
     278    }
     279
     280    clientSpaces.m_clientSubspaceForExposedToWorkerAndWindow = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     281    return clientSpaces.m_clientSubspaceForExposedToWorkerAndWindow.get();
    259282}
    260283

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSPaintWorkletGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    167167JSC::GCClient::IsoSubspace* JSPaintWorkletGlobalScope::subspaceForImpl(JSC::VM& vm)
    168168{
    169     return subspaceForImpl<JSPaintWorkletGlobalScope, UseCustomHeapCellType::Yes>(vm,
    170         [] (auto& spaces) { return spaces.m_clientSubspaceForPaintWorkletGlobalScope.get(); },
    171         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForPaintWorkletGlobalScope = WTFMove(space); },
    172         [] (auto& spaces) { return spaces.m_subspaceForPaintWorkletGlobalScope.get(); },
    173         [] (auto& spaces, auto&& space) { spaces.m_subspaceForPaintWorkletGlobalScope = WTFMove(space); },
    174         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSPaintWorkletGlobalScope; }
    175     );
     169    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     170    auto& clientSpaces = clientData.clientSubspaces();
     171    if (auto* clientSpace = clientSpaces.m_clientSubspaceForPaintWorkletGlobalScope.get())
     172        return clientSpace;
     173
     174    auto& heapData = clientData.heapData();
     175    Locker locker { heapData.lock() };
     176
     177    auto& spaces = heapData.subspaces();
     178    IsoSubspace* space = spaces.m_subspaceForPaintWorkletGlobalScope.get();
     179    if (!space) {
     180        Heap& heap = vm.heap;
     181        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSPaintWorkletGlobalScope, JSPaintWorkletGlobalScope);
     182        spaces.m_subspaceForPaintWorkletGlobalScope = std::unique_ptr<IsoSubspace>(space);
     183IGNORE_WARNINGS_BEGIN("unreachable-code")
     184IGNORE_WARNINGS_BEGIN("tautological-compare")
     185        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSPaintWorkletGlobalScope::visitOutputConstraints;
     186        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     187        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     188            heapData.outputConstraintSpaces().append(space);
     189IGNORE_WARNINGS_END
     190IGNORE_WARNINGS_END
     191    }
     192
     193    clientSpaces.m_clientSubspaceForPaintWorkletGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     194    return clientSpaces.m_clientSubspaceForPaintWorkletGlobalScope.get();
    176195}
    177196

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSServiceWorkerGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    167167JSC::GCClient::IsoSubspace* JSServiceWorkerGlobalScope::subspaceForImpl(JSC::VM& vm)
    168168{
    169     return subspaceForImpl<JSServiceWorkerGlobalScope, UseCustomHeapCellType::Yes>(vm,
    170         [] (auto& spaces) { return spaces.m_clientSubspaceForServiceWorkerGlobalScope.get(); },
    171         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForServiceWorkerGlobalScope = WTFMove(space); },
    172         [] (auto& spaces) { return spaces.m_subspaceForServiceWorkerGlobalScope.get(); },
    173         [] (auto& spaces, auto&& space) { spaces.m_subspaceForServiceWorkerGlobalScope = WTFMove(space); },
    174         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSServiceWorkerGlobalScope; }
    175     );
     169    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     170    auto& clientSpaces = clientData.clientSubspaces();
     171    if (auto* clientSpace = clientSpaces.m_clientSubspaceForServiceWorkerGlobalScope.get())
     172        return clientSpace;
     173
     174    auto& heapData = clientData.heapData();
     175    Locker locker { heapData.lock() };
     176
     177    auto& spaces = heapData.subspaces();
     178    IsoSubspace* space = spaces.m_subspaceForServiceWorkerGlobalScope.get();
     179    if (!space) {
     180        Heap& heap = vm.heap;
     181        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSServiceWorkerGlobalScope, JSServiceWorkerGlobalScope);
     182        spaces.m_subspaceForServiceWorkerGlobalScope = std::unique_ptr<IsoSubspace>(space);
     183IGNORE_WARNINGS_BEGIN("unreachable-code")
     184IGNORE_WARNINGS_BEGIN("tautological-compare")
     185        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSServiceWorkerGlobalScope::visitOutputConstraints;
     186        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     187        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     188            heapData.outputConstraintSpaces().append(space);
     189IGNORE_WARNINGS_END
     190IGNORE_WARNINGS_END
     191    }
     192
     193    clientSpaces.m_clientSubspaceForServiceWorkerGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     194    return clientSpaces.m_clientSubspaceForServiceWorkerGlobalScope.get();
    176195}
    177196

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSShadowRealmGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    153153JSC::GCClient::IsoSubspace* JSShadowRealmGlobalScope::subspaceForImpl(JSC::VM& vm)
    154154{
    155     return subspaceForImpl<JSShadowRealmGlobalScope, UseCustomHeapCellType::Yes>(vm,
    156         [] (auto& spaces) { return spaces.m_clientSubspaceForShadowRealmGlobalScope.get(); },
    157         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForShadowRealmGlobalScope = WTFMove(space); },
    158         [] (auto& spaces) { return spaces.m_subspaceForShadowRealmGlobalScope.get(); },
    159         [] (auto& spaces, auto&& space) { spaces.m_subspaceForShadowRealmGlobalScope = WTFMove(space); },
    160         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSShadowRealmGlobalScope; }
    161     );
     155    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     156    auto& clientSpaces = clientData.clientSubspaces();
     157    if (auto* clientSpace = clientSpaces.m_clientSubspaceForShadowRealmGlobalScope.get())
     158        return clientSpace;
     159
     160    auto& heapData = clientData.heapData();
     161    Locker locker { heapData.lock() };
     162
     163    auto& spaces = heapData.subspaces();
     164    IsoSubspace* space = spaces.m_subspaceForShadowRealmGlobalScope.get();
     165    if (!space) {
     166        Heap& heap = vm.heap;
     167        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSShadowRealmGlobalScope, JSShadowRealmGlobalScope);
     168        spaces.m_subspaceForShadowRealmGlobalScope = std::unique_ptr<IsoSubspace>(space);
     169IGNORE_WARNINGS_BEGIN("unreachable-code")
     170IGNORE_WARNINGS_BEGIN("tautological-compare")
     171        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSShadowRealmGlobalScope::visitOutputConstraints;
     172        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     173        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     174            heapData.outputConstraintSpaces().append(space);
     175IGNORE_WARNINGS_END
     176IGNORE_WARNINGS_END
     177    }
     178
     179    clientSpaces.m_clientSubspaceForShadowRealmGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     180    return clientSpaces.m_clientSubspaceForShadowRealmGlobalScope.get();
    162181}
    163182

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSSharedWorkerGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    151151JSC::GCClient::IsoSubspace* JSSharedWorkerGlobalScope::subspaceForImpl(JSC::VM& vm)
    152152{
    153     return subspaceForImpl<JSSharedWorkerGlobalScope, UseCustomHeapCellType::Yes>(vm,
    154         [] (auto& spaces) { return spaces.m_clientSubspaceForSharedWorkerGlobalScope.get(); },
    155         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForSharedWorkerGlobalScope = WTFMove(space); },
    156         [] (auto& spaces) { return spaces.m_subspaceForSharedWorkerGlobalScope.get(); },
    157         [] (auto& spaces, auto&& space) { spaces.m_subspaceForSharedWorkerGlobalScope = WTFMove(space); },
    158         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSSharedWorkerGlobalScope; }
    159     );
     153    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     154    auto& clientSpaces = clientData.clientSubspaces();
     155    if (auto* clientSpace = clientSpaces.m_clientSubspaceForSharedWorkerGlobalScope.get())
     156        return clientSpace;
     157
     158    auto& heapData = clientData.heapData();
     159    Locker locker { heapData.lock() };
     160
     161    auto& spaces = heapData.subspaces();
     162    IsoSubspace* space = spaces.m_subspaceForSharedWorkerGlobalScope.get();
     163    if (!space) {
     164        Heap& heap = vm.heap;
     165        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSSharedWorkerGlobalScope, JSSharedWorkerGlobalScope);
     166        spaces.m_subspaceForSharedWorkerGlobalScope = std::unique_ptr<IsoSubspace>(space);
     167IGNORE_WARNINGS_BEGIN("unreachable-code")
     168IGNORE_WARNINGS_BEGIN("tautological-compare")
     169        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSSharedWorkerGlobalScope::visitOutputConstraints;
     170        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     171        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     172            heapData.outputConstraintSpaces().append(space);
     173IGNORE_WARNINGS_END
     174IGNORE_WARNINGS_END
     175    }
     176
     177    clientSpaces.m_clientSubspaceForSharedWorkerGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     178    return clientSpaces.m_clientSubspaceForSharedWorkerGlobalScope.get();
    160179}
    161180

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCEReactions.cpp

    r290188 r290193  
    2424#include "ActiveDOMObject.h"
    2525#include "CustomElementReactionQueue.h"
     26#include "DOMClientIsoSubspaces.h"
     27#include "DOMIsoSubspaces.h"
    2628#include "ElementInlines.h"
    27 #include "ExtendedDOMClientIsoSubspaces.h"
    28 #include "ExtendedDOMIsoSubspaces.h"
    2929#include "HTMLNames.h"
    3030#include "IDLTypes.h"
    … …  
    434434JSC::GCClient::IsoSubspace* JSTestCEReactions::subspaceForImpl(JSC::VM& vm)
    435435{
    436     return subspaceForImpl<JSTestCEReactions, UseCustomHeapCellType::No>(vm,
    437         [] (auto& spaces) { return spaces.m_clientSubspaceForTestCEReactions.get(); },
    438         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestCEReactions = WTFMove(space); },
    439         [] (auto& spaces) { return spaces.m_subspaceForTestCEReactions.get(); },
    440         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestCEReactions = WTFMove(space); },
    441         nullptr
    442     );
     436    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     437    auto& clientSpaces = clientData.clientSubspaces();
     438    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestCEReactions.get())
     439        return clientSpace;
     440
     441    auto& heapData = clientData.heapData();
     442    Locker locker { heapData.lock() };
     443
     444    auto& spaces = heapData.subspaces();
     445    IsoSubspace* space = spaces.m_subspaceForTestCEReactions.get();
     446    if (!space) {
     447        Heap& heap = vm.heap;
     448        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestCEReactions> || !JSTestCEReactions::needsDestruction);
     449        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestCEReactions>)
     450            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestCEReactions);
     451        else
     452            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestCEReactions);
     453        spaces.m_subspaceForTestCEReactions = std::unique_ptr<IsoSubspace>(space);
     454IGNORE_WARNINGS_BEGIN("unreachable-code")
     455IGNORE_WARNINGS_BEGIN("tautological-compare")
     456        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestCEReactions::visitOutputConstraints;
     457        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     458        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     459            heapData.outputConstraintSpaces().append(space);
     460IGNORE_WARNINGS_END
     461IGNORE_WARNINGS_END
     462    }
     463
     464    clientSpaces.m_clientSubspaceForTestCEReactions = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     465    return clientSpaces.m_clientSubspaceForTestCEReactions.get();
    443466}
    444467

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCEReactionsStringifier.cpp

    r290188 r290193  
    2424#include "ActiveDOMObject.h"
    2525#include "CustomElementReactionQueue.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
     26#include "DOMClientIsoSubspaces.h"
     27#include "DOMIsoSubspaces.h"
    2828#include "JSDOMAttribute.h"
    2929#include "JSDOMBinding.h"
    … …  
    260260JSC::GCClient::IsoSubspace* JSTestCEReactionsStringifier::subspaceForImpl(JSC::VM& vm)
    261261{
    262     return subspaceForImpl<JSTestCEReactionsStringifier, UseCustomHeapCellType::No>(vm,
    263         [] (auto& spaces) { return spaces.m_clientSubspaceForTestCEReactionsStringifier.get(); },
    264         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestCEReactionsStringifier = WTFMove(space); },
    265         [] (auto& spaces) { return spaces.m_subspaceForTestCEReactionsStringifier.get(); },
    266         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestCEReactionsStringifier = WTFMove(space); },
    267         nullptr
    268     );
     262    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     263    auto& clientSpaces = clientData.clientSubspaces();
     264    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestCEReactionsStringifier.get())
     265        return clientSpace;
     266
     267    auto& heapData = clientData.heapData();
     268    Locker locker { heapData.lock() };
     269
     270    auto& spaces = heapData.subspaces();
     271    IsoSubspace* space = spaces.m_subspaceForTestCEReactionsStringifier.get();
     272    if (!space) {
     273        Heap& heap = vm.heap;
     274        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestCEReactionsStringifier> || !JSTestCEReactionsStringifier::needsDestruction);
     275        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestCEReactionsStringifier>)
     276            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestCEReactionsStringifier);
     277        else
     278            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestCEReactionsStringifier);
     279        spaces.m_subspaceForTestCEReactionsStringifier = std::unique_ptr<IsoSubspace>(space);
     280IGNORE_WARNINGS_BEGIN("unreachable-code")
     281IGNORE_WARNINGS_BEGIN("tautological-compare")
     282        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestCEReactionsStringifier::visitOutputConstraints;
     283        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     284        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     285            heapData.outputConstraintSpaces().append(space);
     286IGNORE_WARNINGS_END
     287IGNORE_WARNINGS_END
     288    }
     289
     290    clientSpaces.m_clientSubspaceForTestCEReactionsStringifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     291    return clientSpaces.m_clientSubspaceForTestCEReactionsStringifier.get();
    269292}
    270293

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCallTracer.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAttribute.h"
    … …  
    509509JSC::GCClient::IsoSubspace* JSTestCallTracer::subspaceForImpl(JSC::VM& vm)
    510510{
    511     return subspaceForImpl<JSTestCallTracer, UseCustomHeapCellType::No>(vm,
    512         [] (auto& spaces) { return spaces.m_clientSubspaceForTestCallTracer.get(); },
    513         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestCallTracer = WTFMove(space); },
    514         [] (auto& spaces) { return spaces.m_subspaceForTestCallTracer.get(); },
    515         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestCallTracer = WTFMove(space); },
    516         nullptr
    517     );
     511    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     512    auto& clientSpaces = clientData.clientSubspaces();
     513    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestCallTracer.get())
     514        return clientSpace;
     515
     516    auto& heapData = clientData.heapData();
     517    Locker locker { heapData.lock() };
     518
     519    auto& spaces = heapData.subspaces();
     520    IsoSubspace* space = spaces.m_subspaceForTestCallTracer.get();
     521    if (!space) {
     522        Heap& heap = vm.heap;
     523        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestCallTracer> || !JSTestCallTracer::needsDestruction);
     524        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestCallTracer>)
     525            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestCallTracer);
     526        else
     527            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestCallTracer);
     528        spaces.m_subspaceForTestCallTracer = std::unique_ptr<IsoSubspace>(space);
     529IGNORE_WARNINGS_BEGIN("unreachable-code")
     530IGNORE_WARNINGS_BEGIN("tautological-compare")
     531        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestCallTracer::visitOutputConstraints;
     532        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     533        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     534            heapData.outputConstraintSpaces().append(space);
     535IGNORE_WARNINGS_END
     536IGNORE_WARNINGS_END
     537    }
     538
     539    clientSpaces.m_clientSubspaceForTestCallTracer = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     540    return clientSpaces.m_clientSubspaceForTestCallTracer.get();
    518541}
    519542

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestClassWithJSBuiltinConstructor.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMBuiltinConstructor.h"
    … …  
    172172JSC::GCClient::IsoSubspace* JSTestClassWithJSBuiltinConstructor::subspaceForImpl(JSC::VM& vm)
    173173{
    174     return subspaceForImpl<JSTestClassWithJSBuiltinConstructor, UseCustomHeapCellType::No>(vm,
    175         [] (auto& spaces) { return spaces.m_clientSubspaceForTestClassWithJSBuiltinConstructor.get(); },
    176         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestClassWithJSBuiltinConstructor = WTFMove(space); },
    177         [] (auto& spaces) { return spaces.m_subspaceForTestClassWithJSBuiltinConstructor.get(); },
    178         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestClassWithJSBuiltinConstructor = WTFMove(space); },
    179         nullptr
    180     );
     174    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     175    auto& clientSpaces = clientData.clientSubspaces();
     176    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestClassWithJSBuiltinConstructor.get())
     177        return clientSpace;
     178
     179    auto& heapData = clientData.heapData();
     180    Locker locker { heapData.lock() };
     181
     182    auto& spaces = heapData.subspaces();
     183    IsoSubspace* space = spaces.m_subspaceForTestClassWithJSBuiltinConstructor.get();
     184    if (!space) {
     185        Heap& heap = vm.heap;
     186        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestClassWithJSBuiltinConstructor> || !JSTestClassWithJSBuiltinConstructor::needsDestruction);
     187        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestClassWithJSBuiltinConstructor>)
     188            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestClassWithJSBuiltinConstructor);
     189        else
     190            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestClassWithJSBuiltinConstructor);
     191        spaces.m_subspaceForTestClassWithJSBuiltinConstructor = std::unique_ptr<IsoSubspace>(space);
     192IGNORE_WARNINGS_BEGIN("unreachable-code")
     193IGNORE_WARNINGS_BEGIN("tautological-compare")
     194        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestClassWithJSBuiltinConstructor::visitOutputConstraints;
     195        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     196        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     197            heapData.outputConstraintSpaces().append(space);
     198IGNORE_WARNINGS_END
     199IGNORE_WARNINGS_END
     200    }
     201
     202    clientSpaces.m_clientSubspaceForTestClassWithJSBuiltinConstructor = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     203    return clientSpaces.m_clientSubspaceForTestClassWithJSBuiltinConstructor.get();
    181204}
    182205

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionalIncludes.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    785785JSC::GCClient::IsoSubspace* JSTestConditionalIncludes::subspaceForImpl(JSC::VM& vm)
    786786{
    787     return subspaceForImpl<JSTestConditionalIncludes, UseCustomHeapCellType::No>(vm,
    788         [] (auto& spaces) { return spaces.m_clientSubspaceForTestConditionalIncludes.get(); },
    789         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestConditionalIncludes = WTFMove(space); },
    790         [] (auto& spaces) { return spaces.m_subspaceForTestConditionalIncludes.get(); },
    791         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestConditionalIncludes = WTFMove(space); },
    792         nullptr
    793     );
     787    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     788    auto& clientSpaces = clientData.clientSubspaces();
     789    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestConditionalIncludes.get())
     790        return clientSpace;
     791
     792    auto& heapData = clientData.heapData();
     793    Locker locker { heapData.lock() };
     794
     795    auto& spaces = heapData.subspaces();
     796    IsoSubspace* space = spaces.m_subspaceForTestConditionalIncludes.get();
     797    if (!space) {
     798        Heap& heap = vm.heap;
     799        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestConditionalIncludes> || !JSTestConditionalIncludes::needsDestruction);
     800        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestConditionalIncludes>)
     801            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestConditionalIncludes);
     802        else
     803            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestConditionalIncludes);
     804        spaces.m_subspaceForTestConditionalIncludes = std::unique_ptr<IsoSubspace>(space);
     805IGNORE_WARNINGS_BEGIN("unreachable-code")
     806IGNORE_WARNINGS_BEGIN("tautological-compare")
     807        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestConditionalIncludes::visitOutputConstraints;
     808        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     809        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     810            heapData.outputConstraintSpaces().append(space);
     811IGNORE_WARNINGS_END
     812IGNORE_WARNINGS_END
     813    }
     814
     815    clientSpaces.m_clientSubspaceForTestConditionalIncludes = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     816    return clientSpaces.m_clientSubspaceForTestConditionalIncludes.get();
    794817}
    795818

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DOMPromiseProxy.h"
    2628#include "Document.h"
    27 #include "ExtendedDOMClientIsoSubspaces.h"
    28 #include "ExtendedDOMIsoSubspaces.h"
    2929#include "JSDOMAttribute.h"
    3030#include "JSDOMBinding.h"
    … …  
    607607JSC::GCClient::IsoSubspace* JSTestConditionallyReadWrite::subspaceForImpl(JSC::VM& vm)
    608608{
    609     return subspaceForImpl<JSTestConditionallyReadWrite, UseCustomHeapCellType::No>(vm,
    610         [] (auto& spaces) { return spaces.m_clientSubspaceForTestConditionallyReadWrite.get(); },
    611         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestConditionallyReadWrite = WTFMove(space); },
    612         [] (auto& spaces) { return spaces.m_subspaceForTestConditionallyReadWrite.get(); },
    613         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestConditionallyReadWrite = WTFMove(space); },
    614         nullptr
    615     );
     609    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     610    auto& clientSpaces = clientData.clientSubspaces();
     611    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestConditionallyReadWrite.get())
     612        return clientSpace;
     613
     614    auto& heapData = clientData.heapData();
     615    Locker locker { heapData.lock() };
     616
     617    auto& spaces = heapData.subspaces();
     618    IsoSubspace* space = spaces.m_subspaceForTestConditionallyReadWrite.get();
     619    if (!space) {
     620        Heap& heap = vm.heap;
     621        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestConditionallyReadWrite> || !JSTestConditionallyReadWrite::needsDestruction);
     622        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestConditionallyReadWrite>)
     623            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestConditionallyReadWrite);
     624        else
     625            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestConditionallyReadWrite);
     626        spaces.m_subspaceForTestConditionallyReadWrite = std::unique_ptr<IsoSubspace>(space);
     627IGNORE_WARNINGS_BEGIN("unreachable-code")
     628IGNORE_WARNINGS_BEGIN("tautological-compare")
     629        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestConditionallyReadWrite::visitOutputConstraints;
     630        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     631        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     632            heapData.outputConstraintSpaces().append(space);
     633IGNORE_WARNINGS_END
     634IGNORE_WARNINGS_END
     635    }
     636
     637    clientSpaces.m_clientSubspaceForTestConditionallyReadWrite = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     638    return clientSpaces.m_clientSubspaceForTestConditionallyReadWrite.get();
    616639}
    617640

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDOMJIT.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DOMJITAbstractHeapRepository.h"
    2628#include "DOMJITIDLConvert.h"
    2729#include "DOMJITIDLType.h"
    2830#include "DOMJITIDLTypeFilter.h"
    29 #include "ExtendedDOMClientIsoSubspaces.h"
    30 #include "ExtendedDOMIsoSubspaces.h"
    3131#include "JSDOMAttribute.h"
    3232#include "JSDOMBinding.h"
    … …  
    12481248JSC::GCClient::IsoSubspace* JSTestDOMJIT::subspaceForImpl(JSC::VM& vm)
    12491249{
    1250     return subspaceForImpl<JSTestDOMJIT, UseCustomHeapCellType::No>(vm,
    1251         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDOMJIT.get(); },
    1252         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDOMJIT = WTFMove(space); },
    1253         [] (auto& spaces) { return spaces.m_subspaceForTestDOMJIT.get(); },
    1254         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDOMJIT = WTFMove(space); },
    1255         nullptr
    1256     );
     1250    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     1251    auto& clientSpaces = clientData.clientSubspaces();
     1252    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDOMJIT.get())
     1253        return clientSpace;
     1254
     1255    auto& heapData = clientData.heapData();
     1256    Locker locker { heapData.lock() };
     1257
     1258    auto& spaces = heapData.subspaces();
     1259    IsoSubspace* space = spaces.m_subspaceForTestDOMJIT.get();
     1260    if (!space) {
     1261        Heap& heap = vm.heap;
     1262        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDOMJIT> || !JSTestDOMJIT::needsDestruction);
     1263        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDOMJIT>)
     1264            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDOMJIT);
     1265        else
     1266            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDOMJIT);
     1267        spaces.m_subspaceForTestDOMJIT = std::unique_ptr<IsoSubspace>(space);
     1268IGNORE_WARNINGS_BEGIN("unreachable-code")
     1269IGNORE_WARNINGS_BEGIN("tautological-compare")
     1270        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDOMJIT::visitOutputConstraints;
     1271        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     1272        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     1273            heapData.outputConstraintSpaces().append(space);
     1274IGNORE_WARNINGS_END
     1275IGNORE_WARNINGS_END
     1276    }
     1277
     1278    clientSpaces.m_clientSubspaceForTestDOMJIT = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     1279    return clientSpaces.m_clientSubspaceForTestDOMJIT.get();
    12571280}
    12581281

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSON.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "EventNames.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
    2828#include "JSDOMAttribute.h"
    2929#include "JSDOMBinding.h"
    … …  
    804804JSC::GCClient::IsoSubspace* JSTestDefaultToJSON::subspaceForImpl(JSC::VM& vm)
    805805{
    806     return subspaceForImpl<JSTestDefaultToJSON, UseCustomHeapCellType::No>(vm,
    807         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDefaultToJSON.get(); },
    808         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDefaultToJSON = WTFMove(space); },
    809         [] (auto& spaces) { return spaces.m_subspaceForTestDefaultToJSON.get(); },
    810         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDefaultToJSON = WTFMove(space); },
    811         nullptr
    812     );
     806    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     807    auto& clientSpaces = clientData.clientSubspaces();
     808    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDefaultToJSON.get())
     809        return clientSpace;
     810
     811    auto& heapData = clientData.heapData();
     812    Locker locker { heapData.lock() };
     813
     814    auto& spaces = heapData.subspaces();
     815    IsoSubspace* space = spaces.m_subspaceForTestDefaultToJSON.get();
     816    if (!space) {
     817        Heap& heap = vm.heap;
     818        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSON> || !JSTestDefaultToJSON::needsDestruction);
     819        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSON>)
     820            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDefaultToJSON);
     821        else
     822            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDefaultToJSON);
     823        spaces.m_subspaceForTestDefaultToJSON = std::unique_ptr<IsoSubspace>(space);
     824IGNORE_WARNINGS_BEGIN("unreachable-code")
     825IGNORE_WARNINGS_BEGIN("tautological-compare")
     826        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDefaultToJSON::visitOutputConstraints;
     827        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     828        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     829            heapData.outputConstraintSpaces().append(space);
     830IGNORE_WARNINGS_END
     831IGNORE_WARNINGS_END
     832    }
     833
     834    clientSpaces.m_clientSubspaceForTestDefaultToJSON = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     835    return clientSpaces.m_clientSubspaceForTestDefaultToJSON.get();
    813836}
    814837

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONFilteredByExposed.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    266266JSC::GCClient::IsoSubspace* JSTestDefaultToJSONFilteredByExposed::subspaceForImpl(JSC::VM& vm)
    267267{
    268     return subspaceForImpl<JSTestDefaultToJSONFilteredByExposed, UseCustomHeapCellType::No>(vm,
    269         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDefaultToJSONFilteredByExposed.get(); },
    270         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDefaultToJSONFilteredByExposed = WTFMove(space); },
    271         [] (auto& spaces) { return spaces.m_subspaceForTestDefaultToJSONFilteredByExposed.get(); },
    272         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDefaultToJSONFilteredByExposed = WTFMove(space); },
    273         nullptr
    274     );
     268    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     269    auto& clientSpaces = clientData.clientSubspaces();
     270    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDefaultToJSONFilteredByExposed.get())
     271        return clientSpace;
     272
     273    auto& heapData = clientData.heapData();
     274    Locker locker { heapData.lock() };
     275
     276    auto& spaces = heapData.subspaces();
     277    IsoSubspace* space = spaces.m_subspaceForTestDefaultToJSONFilteredByExposed.get();
     278    if (!space) {
     279        Heap& heap = vm.heap;
     280        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONFilteredByExposed> || !JSTestDefaultToJSONFilteredByExposed::needsDestruction);
     281        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONFilteredByExposed>)
     282            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDefaultToJSONFilteredByExposed);
     283        else
     284            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDefaultToJSONFilteredByExposed);
     285        spaces.m_subspaceForTestDefaultToJSONFilteredByExposed = std::unique_ptr<IsoSubspace>(space);
     286IGNORE_WARNINGS_BEGIN("unreachable-code")
     287IGNORE_WARNINGS_BEGIN("tautological-compare")
     288        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDefaultToJSONFilteredByExposed::visitOutputConstraints;
     289        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     290        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     291            heapData.outputConstraintSpaces().append(space);
     292IGNORE_WARNINGS_END
     293IGNORE_WARNINGS_END
     294    }
     295
     296    clientSpaces.m_clientSubspaceForTestDefaultToJSONFilteredByExposed = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     297    return clientSpaces.m_clientSubspaceForTestDefaultToJSONFilteredByExposed.get();
    275298}
    276299

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONIndirectInheritance.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    158158JSC::GCClient::IsoSubspace* JSTestDefaultToJSONIndirectInheritance::subspaceForImpl(JSC::VM& vm)
    159159{
    160     return subspaceForImpl<JSTestDefaultToJSONIndirectInheritance, UseCustomHeapCellType::No>(vm,
    161         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDefaultToJSONIndirectInheritance.get(); },
    162         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDefaultToJSONIndirectInheritance = WTFMove(space); },
    163         [] (auto& spaces) { return spaces.m_subspaceForTestDefaultToJSONIndirectInheritance.get(); },
    164         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDefaultToJSONIndirectInheritance = WTFMove(space); },
    165         nullptr
    166     );
     160    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     161    auto& clientSpaces = clientData.clientSubspaces();
     162    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDefaultToJSONIndirectInheritance.get())
     163        return clientSpace;
     164
     165    auto& heapData = clientData.heapData();
     166    Locker locker { heapData.lock() };
     167
     168    auto& spaces = heapData.subspaces();
     169    IsoSubspace* space = spaces.m_subspaceForTestDefaultToJSONIndirectInheritance.get();
     170    if (!space) {
     171        Heap& heap = vm.heap;
     172        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONIndirectInheritance> || !JSTestDefaultToJSONIndirectInheritance::needsDestruction);
     173        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONIndirectInheritance>)
     174            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDefaultToJSONIndirectInheritance);
     175        else
     176            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDefaultToJSONIndirectInheritance);
     177        spaces.m_subspaceForTestDefaultToJSONIndirectInheritance = std::unique_ptr<IsoSubspace>(space);
     178IGNORE_WARNINGS_BEGIN("unreachable-code")
     179IGNORE_WARNINGS_BEGIN("tautological-compare")
     180        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDefaultToJSONIndirectInheritance::visitOutputConstraints;
     181        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     182        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     183            heapData.outputConstraintSpaces().append(space);
     184IGNORE_WARNINGS_END
     185IGNORE_WARNINGS_END
     186    }
     187
     188    clientSpaces.m_clientSubspaceForTestDefaultToJSONIndirectInheritance = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     189    return clientSpaces.m_clientSubspaceForTestDefaultToJSONIndirectInheritance.get();
    167190}
    168191

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONInherit.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    288288JSC::GCClient::IsoSubspace* JSTestDefaultToJSONInherit::subspaceForImpl(JSC::VM& vm)
    289289{
    290     return subspaceForImpl<JSTestDefaultToJSONInherit, UseCustomHeapCellType::No>(vm,
    291         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDefaultToJSONInherit.get(); },
    292         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDefaultToJSONInherit = WTFMove(space); },
    293         [] (auto& spaces) { return spaces.m_subspaceForTestDefaultToJSONInherit.get(); },
    294         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDefaultToJSONInherit = WTFMove(space); },
    295         nullptr
    296     );
     290    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     291    auto& clientSpaces = clientData.clientSubspaces();
     292    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDefaultToJSONInherit.get())
     293        return clientSpace;
     294
     295    auto& heapData = clientData.heapData();
     296    Locker locker { heapData.lock() };
     297
     298    auto& spaces = heapData.subspaces();
     299    IsoSubspace* space = spaces.m_subspaceForTestDefaultToJSONInherit.get();
     300    if (!space) {
     301        Heap& heap = vm.heap;
     302        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONInherit> || !JSTestDefaultToJSONInherit::needsDestruction);
     303        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONInherit>)
     304            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDefaultToJSONInherit);
     305        else
     306            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDefaultToJSONInherit);
     307        spaces.m_subspaceForTestDefaultToJSONInherit = std::unique_ptr<IsoSubspace>(space);
     308IGNORE_WARNINGS_BEGIN("unreachable-code")
     309IGNORE_WARNINGS_BEGIN("tautological-compare")
     310        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDefaultToJSONInherit::visitOutputConstraints;
     311        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     312        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     313            heapData.outputConstraintSpaces().append(space);
     314IGNORE_WARNINGS_END
     315IGNORE_WARNINGS_END
     316    }
     317
     318    clientSpaces.m_clientSubspaceForTestDefaultToJSONInherit = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     319    return clientSpaces.m_clientSubspaceForTestDefaultToJSONInherit.get();
    297320}
    298321

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONInheritFinal.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    328328JSC::GCClient::IsoSubspace* JSTestDefaultToJSONInheritFinal::subspaceForImpl(JSC::VM& vm)
    329329{
    330     return subspaceForImpl<JSTestDefaultToJSONInheritFinal, UseCustomHeapCellType::No>(vm,
    331         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDefaultToJSONInheritFinal.get(); },
    332         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDefaultToJSONInheritFinal = WTFMove(space); },
    333         [] (auto& spaces) { return spaces.m_subspaceForTestDefaultToJSONInheritFinal.get(); },
    334         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDefaultToJSONInheritFinal = WTFMove(space); },
    335         nullptr
    336     );
     330    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     331    auto& clientSpaces = clientData.clientSubspaces();
     332    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDefaultToJSONInheritFinal.get())
     333        return clientSpace;
     334
     335    auto& heapData = clientData.heapData();
     336    Locker locker { heapData.lock() };
     337
     338    auto& spaces = heapData.subspaces();
     339    IsoSubspace* space = spaces.m_subspaceForTestDefaultToJSONInheritFinal.get();
     340    if (!space) {
     341        Heap& heap = vm.heap;
     342        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONInheritFinal> || !JSTestDefaultToJSONInheritFinal::needsDestruction);
     343        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDefaultToJSONInheritFinal>)
     344            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDefaultToJSONInheritFinal);
     345        else
     346            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDefaultToJSONInheritFinal);
     347        spaces.m_subspaceForTestDefaultToJSONInheritFinal = std::unique_ptr<IsoSubspace>(space);
     348IGNORE_WARNINGS_BEGIN("unreachable-code")
     349IGNORE_WARNINGS_BEGIN("tautological-compare")
     350        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDefaultToJSONInheritFinal::visitOutputConstraints;
     351        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     352        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     353            heapData.outputConstraintSpaces().append(space);
     354IGNORE_WARNINGS_END
     355IGNORE_WARNINGS_END
     356    }
     357
     358    clientSpaces.m_clientSubspaceForTestDefaultToJSONInheritFinal = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     359    return clientSpaces.m_clientSubspaceForTestDefaultToJSONInheritFinal.get();
    337360}
    338361

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDelegateToSharedSyntheticAttribute.cpp

    r290188 r290193  
    2424#include "ActiveDOMObject.h"
    2525#include "CustomElementReactionQueue.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
     26#include "DOMClientIsoSubspaces.h"
     27#include "DOMIsoSubspaces.h"
    2828#include "JSDOMAttribute.h"
    2929#include "JSDOMBinding.h"
    … …  
    242242JSC::GCClient::IsoSubspace* JSTestDelegateToSharedSyntheticAttribute::subspaceForImpl(JSC::VM& vm)
    243243{
    244     return subspaceForImpl<JSTestDelegateToSharedSyntheticAttribute, UseCustomHeapCellType::No>(vm,
    245         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDelegateToSharedSyntheticAttribute.get(); },
    246         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDelegateToSharedSyntheticAttribute = WTFMove(space); },
    247         [] (auto& spaces) { return spaces.m_subspaceForTestDelegateToSharedSyntheticAttribute.get(); },
    248         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDelegateToSharedSyntheticAttribute = WTFMove(space); },
    249         nullptr
    250     );
     244    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     245    auto& clientSpaces = clientData.clientSubspaces();
     246    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDelegateToSharedSyntheticAttribute.get())
     247        return clientSpace;
     248
     249    auto& heapData = clientData.heapData();
     250    Locker locker { heapData.lock() };
     251
     252    auto& spaces = heapData.subspaces();
     253    IsoSubspace* space = spaces.m_subspaceForTestDelegateToSharedSyntheticAttribute.get();
     254    if (!space) {
     255        Heap& heap = vm.heap;
     256        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDelegateToSharedSyntheticAttribute> || !JSTestDelegateToSharedSyntheticAttribute::needsDestruction);
     257        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDelegateToSharedSyntheticAttribute>)
     258            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDelegateToSharedSyntheticAttribute);
     259        else
     260            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDelegateToSharedSyntheticAttribute);
     261        spaces.m_subspaceForTestDelegateToSharedSyntheticAttribute = std::unique_ptr<IsoSubspace>(space);
     262IGNORE_WARNINGS_BEGIN("unreachable-code")
     263IGNORE_WARNINGS_BEGIN("tautological-compare")
     264        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDelegateToSharedSyntheticAttribute::visitOutputConstraints;
     265        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     266        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     267            heapData.outputConstraintSpaces().append(space);
     268IGNORE_WARNINGS_END
     269IGNORE_WARNINGS_END
     270    }
     271
     272    clientSpaces.m_clientSubspaceForTestDelegateToSharedSyntheticAttribute = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     273    return clientSpaces.m_clientSubspaceForTestDelegateToSharedSyntheticAttribute.get();
    251274}
    252275

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDomainSecurity.cpp

    r290188 r290193  
    2424#include "ActiveDOMObject.h"
    2525#include "CustomElementReactionQueue.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
     26#include "DOMClientIsoSubspaces.h"
     27#include "DOMIsoSubspaces.h"
    2828#include "IDLTypes.h"
    2929#include "JSDOMAttribute.h"
    … …  
    316316JSC::GCClient::IsoSubspace* JSTestDomainSecurity::subspaceForImpl(JSC::VM& vm)
    317317{
    318     return subspaceForImpl<JSTestDomainSecurity, UseCustomHeapCellType::No>(vm,
    319         [] (auto& spaces) { return spaces.m_clientSubspaceForTestDomainSecurity.get(); },
    320         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestDomainSecurity = WTFMove(space); },
    321         [] (auto& spaces) { return spaces.m_subspaceForTestDomainSecurity.get(); },
    322         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestDomainSecurity = WTFMove(space); },
    323         nullptr
    324     );
     318    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     319    auto& clientSpaces = clientData.clientSubspaces();
     320    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestDomainSecurity.get())
     321        return clientSpace;
     322
     323    auto& heapData = clientData.heapData();
     324    Locker locker { heapData.lock() };
     325
     326    auto& spaces = heapData.subspaces();
     327    IsoSubspace* space = spaces.m_subspaceForTestDomainSecurity.get();
     328    if (!space) {
     329        Heap& heap = vm.heap;
     330        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestDomainSecurity> || !JSTestDomainSecurity::needsDestruction);
     331        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDomainSecurity>)
     332            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestDomainSecurity);
     333        else
     334            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestDomainSecurity);
     335        spaces.m_subspaceForTestDomainSecurity = std::unique_ptr<IsoSubspace>(space);
     336IGNORE_WARNINGS_BEGIN("unreachable-code")
     337IGNORE_WARNINGS_BEGIN("tautological-compare")
     338        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestDomainSecurity::visitOutputConstraints;
     339        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     340        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     341            heapData.outputConstraintSpaces().append(space);
     342IGNORE_WARNINGS_END
     343IGNORE_WARNINGS_END
     344    }
     345
     346    clientSpaces.m_clientSubspaceForTestDomainSecurity = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     347    return clientSpaces.m_clientSubspaceForTestDomainSecurity.get();
    325348}
    326349

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestEnabledBySetting.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    455455JSC::GCClient::IsoSubspace* JSTestEnabledBySetting::subspaceForImpl(JSC::VM& vm)
    456456{
    457     return subspaceForImpl<JSTestEnabledBySetting, UseCustomHeapCellType::No>(vm,
    458         [] (auto& spaces) { return spaces.m_clientSubspaceForTestEnabledBySetting.get(); },
    459         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestEnabledBySetting = WTFMove(space); },
    460         [] (auto& spaces) { return spaces.m_subspaceForTestEnabledBySetting.get(); },
    461         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestEnabledBySetting = WTFMove(space); },
    462         nullptr
    463     );
     457    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     458    auto& clientSpaces = clientData.clientSubspaces();
     459    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestEnabledBySetting.get())
     460        return clientSpace;
     461
     462    auto& heapData = clientData.heapData();
     463    Locker locker { heapData.lock() };
     464
     465    auto& spaces = heapData.subspaces();
     466    IsoSubspace* space = spaces.m_subspaceForTestEnabledBySetting.get();
     467    if (!space) {
     468        Heap& heap = vm.heap;
     469        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestEnabledBySetting> || !JSTestEnabledBySetting::needsDestruction);
     470        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEnabledBySetting>)
     471            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestEnabledBySetting);
     472        else
     473            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestEnabledBySetting);
     474        spaces.m_subspaceForTestEnabledBySetting = std::unique_ptr<IsoSubspace>(space);
     475IGNORE_WARNINGS_BEGIN("unreachable-code")
     476IGNORE_WARNINGS_BEGIN("tautological-compare")
     477        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestEnabledBySetting::visitOutputConstraints;
     478        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     479        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     480            heapData.outputConstraintSpaces().append(space);
     481IGNORE_WARNINGS_END
     482IGNORE_WARNINGS_END
     483    }
     484
     485    clientSpaces.m_clientSubspaceForTestEnabledBySetting = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     486    return clientSpaces.m_clientSubspaceForTestEnabledBySetting.get();
    464487}
    465488

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestEnabledForContext.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    182182JSC::GCClient::IsoSubspace* JSTestEnabledForContext::subspaceForImpl(JSC::VM& vm)
    183183{
    184     return subspaceForImpl<JSTestEnabledForContext, UseCustomHeapCellType::No>(vm,
    185         [] (auto& spaces) { return spaces.m_clientSubspaceForTestEnabledForContext.get(); },
    186         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestEnabledForContext = WTFMove(space); },
    187         [] (auto& spaces) { return spaces.m_subspaceForTestEnabledForContext.get(); },
    188         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestEnabledForContext = WTFMove(space); },
    189         nullptr
    190     );
     184    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     185    auto& clientSpaces = clientData.clientSubspaces();
     186    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestEnabledForContext.get())
     187        return clientSpace;
     188
     189    auto& heapData = clientData.heapData();
     190    Locker locker { heapData.lock() };
     191
     192    auto& spaces = heapData.subspaces();
     193    IsoSubspace* space = spaces.m_subspaceForTestEnabledForContext.get();
     194    if (!space) {
     195        Heap& heap = vm.heap;
     196        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestEnabledForContext> || !JSTestEnabledForContext::needsDestruction);
     197        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEnabledForContext>)
     198            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestEnabledForContext);
     199        else
     200            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestEnabledForContext);
     201        spaces.m_subspaceForTestEnabledForContext = std::unique_ptr<IsoSubspace>(space);
     202IGNORE_WARNINGS_BEGIN("unreachable-code")
     203IGNORE_WARNINGS_BEGIN("tautological-compare")
     204        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestEnabledForContext::visitOutputConstraints;
     205        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     206        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     207            heapData.outputConstraintSpaces().append(space);
     208IGNORE_WARNINGS_END
     209IGNORE_WARNINGS_END
     210    }
     211
     212    clientSpaces.m_clientSubspaceForTestEnabledForContext = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     213    return clientSpaces.m_clientSubspaceForTestEnabledForContext.get();
    191214}
    192215

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestEventConstructor.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    319319JSC::GCClient::IsoSubspace* JSTestEventConstructor::subspaceForImpl(JSC::VM& vm)
    320320{
    321     return subspaceForImpl<JSTestEventConstructor, UseCustomHeapCellType::No>(vm,
    322         [] (auto& spaces) { return spaces.m_clientSubspaceForTestEventConstructor.get(); },
    323         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestEventConstructor = WTFMove(space); },
    324         [] (auto& spaces) { return spaces.m_subspaceForTestEventConstructor.get(); },
    325         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestEventConstructor = WTFMove(space); },
    326         nullptr
    327     );
     321    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     322    auto& clientSpaces = clientData.clientSubspaces();
     323    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestEventConstructor.get())
     324        return clientSpace;
     325
     326    auto& heapData = clientData.heapData();
     327    Locker locker { heapData.lock() };
     328
     329    auto& spaces = heapData.subspaces();
     330    IsoSubspace* space = spaces.m_subspaceForTestEventConstructor.get();
     331    if (!space) {
     332        Heap& heap = vm.heap;
     333        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestEventConstructor> || !JSTestEventConstructor::needsDestruction);
     334        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEventConstructor>)
     335            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestEventConstructor);
     336        else
     337            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestEventConstructor);
     338        spaces.m_subspaceForTestEventConstructor = std::unique_ptr<IsoSubspace>(space);
     339IGNORE_WARNINGS_BEGIN("unreachable-code")
     340IGNORE_WARNINGS_BEGIN("tautological-compare")
     341        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestEventConstructor::visitOutputConstraints;
     342        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     343        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     344            heapData.outputConstraintSpaces().append(space);
     345IGNORE_WARNINGS_END
     346IGNORE_WARNINGS_END
     347    }
     348
     349    clientSpaces.m_clientSubspaceForTestEventConstructor = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     350    return clientSpaces.m_clientSubspaceForTestEventConstructor.get();
    328351}
    329352

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestEventTarget.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    258258JSC::GCClient::IsoSubspace* JSTestEventTarget::subspaceForImpl(JSC::VM& vm)
    259259{
    260     return subspaceForImpl<JSTestEventTarget, UseCustomHeapCellType::No>(vm,
    261         [] (auto& spaces) { return spaces.m_clientSubspaceForTestEventTarget.get(); },
    262         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestEventTarget = WTFMove(space); },
    263         [] (auto& spaces) { return spaces.m_subspaceForTestEventTarget.get(); },
    264         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestEventTarget = WTFMove(space); },
    265         nullptr
    266     );
     260    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     261    auto& clientSpaces = clientData.clientSubspaces();
     262    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestEventTarget.get())
     263        return clientSpace;
     264
     265    auto& heapData = clientData.heapData();
     266    Locker locker { heapData.lock() };
     267
     268    auto& spaces = heapData.subspaces();
     269    IsoSubspace* space = spaces.m_subspaceForTestEventTarget.get();
     270    if (!space) {
     271        Heap& heap = vm.heap;
     272        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestEventTarget> || !JSTestEventTarget::needsDestruction);
     273        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEventTarget>)
     274            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestEventTarget);
     275        else
     276            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestEventTarget);
     277        spaces.m_subspaceForTestEventTarget = std::unique_ptr<IsoSubspace>(space);
     278IGNORE_WARNINGS_BEGIN("unreachable-code")
     279IGNORE_WARNINGS_BEGIN("tautological-compare")
     280        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestEventTarget::visitOutputConstraints;
     281        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     282        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     283            heapData.outputConstraintSpaces().append(space);
     284IGNORE_WARNINGS_END
     285IGNORE_WARNINGS_END
     286    }
     287
     288    clientSpaces.m_clientSubspaceForTestEventTarget = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     289    return clientSpaces.m_clientSubspaceForTestEventTarget.get();
    267290}
    268291

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestException.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    183183JSC::GCClient::IsoSubspace* JSTestException::subspaceForImpl(JSC::VM& vm)
    184184{
    185     return subspaceForImpl<JSTestException, UseCustomHeapCellType::No>(vm,
    186         [] (auto& spaces) { return spaces.m_clientSubspaceForTestException.get(); },
    187         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestException = WTFMove(space); },
    188         [] (auto& spaces) { return spaces.m_subspaceForTestException.get(); },
    189         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestException = WTFMove(space); },
    190         nullptr
    191     );
     185    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     186    auto& clientSpaces = clientData.clientSubspaces();
     187    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestException.get())
     188        return clientSpace;
     189
     190    auto& heapData = clientData.heapData();
     191    Locker locker { heapData.lock() };
     192
     193    auto& spaces = heapData.subspaces();
     194    IsoSubspace* space = spaces.m_subspaceForTestException.get();
     195    if (!space) {
     196        Heap& heap = vm.heap;
     197        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestException> || !JSTestException::needsDestruction);
     198        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestException>)
     199            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestException);
     200        else
     201            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestException);
     202        spaces.m_subspaceForTestException = std::unique_ptr<IsoSubspace>(space);
     203IGNORE_WARNINGS_BEGIN("unreachable-code")
     204IGNORE_WARNINGS_BEGIN("tautological-compare")
     205        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestException::visitOutputConstraints;
     206        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     207        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     208            heapData.outputConstraintSpaces().append(space);
     209IGNORE_WARNINGS_END
     210IGNORE_WARNINGS_END
     211    }
     212
     213    clientSpaces.m_clientSubspaceForTestException = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     214    return clientSpaces.m_clientSubspaceForTestException.get();
    192215}
    193216

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestGenerateAddOpaqueRoot.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    183183JSC::GCClient::IsoSubspace* JSTestGenerateAddOpaqueRoot::subspaceForImpl(JSC::VM& vm)
    184184{
    185     return subspaceForImpl<JSTestGenerateAddOpaqueRoot, UseCustomHeapCellType::No>(vm,
    186         [] (auto& spaces) { return spaces.m_clientSubspaceForTestGenerateAddOpaqueRoot.get(); },
    187         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestGenerateAddOpaqueRoot = WTFMove(space); },
    188         [] (auto& spaces) { return spaces.m_subspaceForTestGenerateAddOpaqueRoot.get(); },
    189         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestGenerateAddOpaqueRoot = WTFMove(space); },
    190         nullptr
    191     );
     185    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     186    auto& clientSpaces = clientData.clientSubspaces();
     187    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestGenerateAddOpaqueRoot.get())
     188        return clientSpace;
     189
     190    auto& heapData = clientData.heapData();
     191    Locker locker { heapData.lock() };
     192
     193    auto& spaces = heapData.subspaces();
     194    IsoSubspace* space = spaces.m_subspaceForTestGenerateAddOpaqueRoot.get();
     195    if (!space) {
     196        Heap& heap = vm.heap;
     197        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestGenerateAddOpaqueRoot> || !JSTestGenerateAddOpaqueRoot::needsDestruction);
     198        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestGenerateAddOpaqueRoot>)
     199            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestGenerateAddOpaqueRoot);
     200        else
     201            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestGenerateAddOpaqueRoot);
     202        spaces.m_subspaceForTestGenerateAddOpaqueRoot = std::unique_ptr<IsoSubspace>(space);
     203IGNORE_WARNINGS_BEGIN("unreachable-code")
     204IGNORE_WARNINGS_BEGIN("tautological-compare")
     205        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestGenerateAddOpaqueRoot::visitOutputConstraints;
     206        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     207        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     208            heapData.outputConstraintSpaces().append(space);
     209IGNORE_WARNINGS_END
     210IGNORE_WARNINGS_END
     211    }
     212
     213    clientSpaces.m_clientSubspaceForTestGenerateAddOpaqueRoot = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     214    return clientSpaces.m_clientSubspaceForTestGenerateAddOpaqueRoot.get();
    192215}
    193216

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    193193JSC::GCClient::IsoSubspace* JSTestGenerateIsReachable::subspaceForImpl(JSC::VM& vm)
    194194{
    195     return subspaceForImpl<JSTestGenerateIsReachable, UseCustomHeapCellType::No>(vm,
    196         [] (auto& spaces) { return spaces.m_clientSubspaceForTestGenerateIsReachable.get(); },
    197         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestGenerateIsReachable = WTFMove(space); },
    198         [] (auto& spaces) { return spaces.m_subspaceForTestGenerateIsReachable.get(); },
    199         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestGenerateIsReachable = WTFMove(space); },
    200         nullptr
    201     );
     195    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     196    auto& clientSpaces = clientData.clientSubspaces();
     197    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestGenerateIsReachable.get())
     198        return clientSpace;
     199
     200    auto& heapData = clientData.heapData();
     201    Locker locker { heapData.lock() };
     202
     203    auto& spaces = heapData.subspaces();
     204    IsoSubspace* space = spaces.m_subspaceForTestGenerateIsReachable.get();
     205    if (!space) {
     206        Heap& heap = vm.heap;
     207        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestGenerateIsReachable> || !JSTestGenerateIsReachable::needsDestruction);
     208        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestGenerateIsReachable>)
     209            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestGenerateIsReachable);
     210        else
     211            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestGenerateIsReachable);
     212        spaces.m_subspaceForTestGenerateIsReachable = std::unique_ptr<IsoSubspace>(space);
     213IGNORE_WARNINGS_BEGIN("unreachable-code")
     214IGNORE_WARNINGS_BEGIN("tautological-compare")
     215        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestGenerateIsReachable::visitOutputConstraints;
     216        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     217        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     218            heapData.outputConstraintSpaces().append(space);
     219IGNORE_WARNINGS_END
     220IGNORE_WARNINGS_END
     221    }
     222
     223    clientSpaces.m_clientSubspaceForTestGenerateIsReachable = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     224    return clientSpaces.m_clientSubspaceForTestGenerateIsReachable.get();
    202225}
    203226

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestGlobalObject.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DOMPromiseProxy.h"
    2628#include "DOMWrapperWorld.h"
    27 #include "ExtendedDOMClientIsoSubspaces.h"
    28 #include "ExtendedDOMIsoSubspaces.h"
    2929#include "IDLTypes.h"
    3030#include "JSDOMAttribute.h"
    … …  
    18261826JSC::GCClient::IsoSubspace* JSTestGlobalObject::subspaceForImpl(JSC::VM& vm)
    18271827{
    1828     return subspaceForImpl<JSTestGlobalObject, UseCustomHeapCellType::Yes>(vm,
    1829         [] (auto& spaces) { return spaces.m_clientSubspaceForTestGlobalObject.get(); },
    1830         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestGlobalObject = WTFMove(space); },
    1831         [] (auto& spaces) { return spaces.m_subspaceForTestGlobalObject.get(); },
    1832         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestGlobalObject = WTFMove(space); },
    1833         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSTestGlobalObject; }
    1834     );
     1828    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     1829    auto& clientSpaces = clientData.clientSubspaces();
     1830    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestGlobalObject.get())
     1831        return clientSpace;
     1832
     1833    auto& heapData = clientData.heapData();
     1834    Locker locker { heapData.lock() };
     1835
     1836    auto& spaces = heapData.subspaces();
     1837    IsoSubspace* space = spaces.m_subspaceForTestGlobalObject.get();
     1838    if (!space) {
     1839        Heap& heap = vm.heap;
     1840        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSTestGlobalObject, JSTestGlobalObject);
     1841        spaces.m_subspaceForTestGlobalObject = std::unique_ptr<IsoSubspace>(space);
     1842IGNORE_WARNINGS_BEGIN("unreachable-code")
     1843IGNORE_WARNINGS_BEGIN("tautological-compare")
     1844        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestGlobalObject::visitOutputConstraints;
     1845        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     1846        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     1847            heapData.outputConstraintSpaces().append(space);
     1848IGNORE_WARNINGS_END
     1849IGNORE_WARNINGS_END
     1850    }
     1851
     1852    clientSpaces.m_clientSubspaceForTestGlobalObject = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     1853    return clientSpaces.m_clientSubspaceForTestGlobalObject.get();
    18351854}
    18361855

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterNoIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    272272JSC::GCClient::IsoSubspace* JSTestIndexedSetterNoIdentifier::subspaceForImpl(JSC::VM& vm)
    273273{
    274     return subspaceForImpl<JSTestIndexedSetterNoIdentifier, UseCustomHeapCellType::No>(vm,
    275         [] (auto& spaces) { return spaces.m_clientSubspaceForTestIndexedSetterNoIdentifier.get(); },
    276         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestIndexedSetterNoIdentifier = WTFMove(space); },
    277         [] (auto& spaces) { return spaces.m_subspaceForTestIndexedSetterNoIdentifier.get(); },
    278         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestIndexedSetterNoIdentifier = WTFMove(space); },
    279         nullptr
    280     );
     274    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     275    auto& clientSpaces = clientData.clientSubspaces();
     276    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestIndexedSetterNoIdentifier.get())
     277        return clientSpace;
     278
     279    auto& heapData = clientData.heapData();
     280    Locker locker { heapData.lock() };
     281
     282    auto& spaces = heapData.subspaces();
     283    IsoSubspace* space = spaces.m_subspaceForTestIndexedSetterNoIdentifier.get();
     284    if (!space) {
     285        Heap& heap = vm.heap;
     286        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterNoIdentifier> || !JSTestIndexedSetterNoIdentifier::needsDestruction);
     287        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterNoIdentifier>)
     288            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestIndexedSetterNoIdentifier);
     289        else
     290            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestIndexedSetterNoIdentifier);
     291        spaces.m_subspaceForTestIndexedSetterNoIdentifier = std::unique_ptr<IsoSubspace>(space);
     292IGNORE_WARNINGS_BEGIN("unreachable-code")
     293IGNORE_WARNINGS_BEGIN("tautological-compare")
     294        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestIndexedSetterNoIdentifier::visitOutputConstraints;
     295        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     296        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     297            heapData.outputConstraintSpaces().append(space);
     298IGNORE_WARNINGS_END
     299IGNORE_WARNINGS_END
     300    }
     301
     302    clientSpaces.m_clientSubspaceForTestIndexedSetterNoIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     303    return clientSpaces.m_clientSubspaceForTestIndexedSetterNoIdentifier.get();
    281304}
    282305

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterThrowingException.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    272272JSC::GCClient::IsoSubspace* JSTestIndexedSetterThrowingException::subspaceForImpl(JSC::VM& vm)
    273273{
    274     return subspaceForImpl<JSTestIndexedSetterThrowingException, UseCustomHeapCellType::No>(vm,
    275         [] (auto& spaces) { return spaces.m_clientSubspaceForTestIndexedSetterThrowingException.get(); },
    276         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestIndexedSetterThrowingException = WTFMove(space); },
    277         [] (auto& spaces) { return spaces.m_subspaceForTestIndexedSetterThrowingException.get(); },
    278         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestIndexedSetterThrowingException = WTFMove(space); },
    279         nullptr
    280     );
     274    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     275    auto& clientSpaces = clientData.clientSubspaces();
     276    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestIndexedSetterThrowingException.get())
     277        return clientSpace;
     278
     279    auto& heapData = clientData.heapData();
     280    Locker locker { heapData.lock() };
     281
     282    auto& spaces = heapData.subspaces();
     283    IsoSubspace* space = spaces.m_subspaceForTestIndexedSetterThrowingException.get();
     284    if (!space) {
     285        Heap& heap = vm.heap;
     286        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterThrowingException> || !JSTestIndexedSetterThrowingException::needsDestruction);
     287        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterThrowingException>)
     288            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestIndexedSetterThrowingException);
     289        else
     290            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestIndexedSetterThrowingException);
     291        spaces.m_subspaceForTestIndexedSetterThrowingException = std::unique_ptr<IsoSubspace>(space);
     292IGNORE_WARNINGS_BEGIN("unreachable-code")
     293IGNORE_WARNINGS_BEGIN("tautological-compare")
     294        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestIndexedSetterThrowingException::visitOutputConstraints;
     295        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     296        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     297            heapData.outputConstraintSpaces().append(space);
     298IGNORE_WARNINGS_END
     299IGNORE_WARNINGS_END
     300    }
     301
     302    clientSpaces.m_clientSubspaceForTestIndexedSetterThrowingException = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     303    return clientSpaces.m_clientSubspaceForTestIndexedSetterThrowingException.get();
    281304}
    282305

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterWithIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMBinding.h"
    … …  
    304304JSC::GCClient::IsoSubspace* JSTestIndexedSetterWithIdentifier::subspaceForImpl(JSC::VM& vm)
    305305{
    306     return subspaceForImpl<JSTestIndexedSetterWithIdentifier, UseCustomHeapCellType::No>(vm,
    307         [] (auto& spaces) { return spaces.m_clientSubspaceForTestIndexedSetterWithIdentifier.get(); },
    308         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestIndexedSetterWithIdentifier = WTFMove(space); },
    309         [] (auto& spaces) { return spaces.m_subspaceForTestIndexedSetterWithIdentifier.get(); },
    310         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestIndexedSetterWithIdentifier = WTFMove(space); },
    311         nullptr
    312     );
     306    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     307    auto& clientSpaces = clientData.clientSubspaces();
     308    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestIndexedSetterWithIdentifier.get())
     309        return clientSpace;
     310
     311    auto& heapData = clientData.heapData();
     312    Locker locker { heapData.lock() };
     313
     314    auto& spaces = heapData.subspaces();
     315    IsoSubspace* space = spaces.m_subspaceForTestIndexedSetterWithIdentifier.get();
     316    if (!space) {
     317        Heap& heap = vm.heap;
     318        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterWithIdentifier> || !JSTestIndexedSetterWithIdentifier::needsDestruction);
     319        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterWithIdentifier>)
     320            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestIndexedSetterWithIdentifier);
     321        else
     322            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestIndexedSetterWithIdentifier);
     323        spaces.m_subspaceForTestIndexedSetterWithIdentifier = std::unique_ptr<IsoSubspace>(space);
     324IGNORE_WARNINGS_BEGIN("unreachable-code")
     325IGNORE_WARNINGS_BEGIN("tautological-compare")
     326        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestIndexedSetterWithIdentifier::visitOutputConstraints;
     327        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     328        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     329            heapData.outputConstraintSpaces().append(space);
     330IGNORE_WARNINGS_END
     331IGNORE_WARNINGS_END
     332    }
     333
     334    clientSpaces.m_clientSubspaceForTestIndexedSetterWithIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     335    return clientSpaces.m_clientSubspaceForTestIndexedSetterWithIdentifier.get();
    313336}
    314337

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp

    r290188 r290193  
    2626
    2727#include "ActiveDOMObject.h"
     28#include "DOMClientIsoSubspaces.h"
     29#include "DOMIsoSubspaces.h"
    2830#include "ElementInlines.h"
    29 #include "ExtendedDOMClientIsoSubspaces.h"
    30 #include "ExtendedDOMIsoSubspaces.h"
    3131#include "HTMLNames.h"
    3232#include "JSDOMAttribute.h"
    … …  
    11021102        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
    11031103            return nullptr;
    1104         return subspaceForImpl<TestInterfaceIterator, UseCustomHeapCellType::No>(vm,
    1105             [] (auto& spaces) { return spaces.m_clientSubspaceForTestInterfaceIterator.get(); },
    1106             [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestInterfaceIterator = WTFMove(space); },
    1107             [] (auto& spaces) { return spaces.m_subspaceForTestInterfaceIterator.get(); },
    1108             [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestInterfaceIterator = WTFMove(space); }
    1109         );
     1104        auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     1105        auto& clientSpaces = clientData.clientSubspaces();
     1106        if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestInterfaceIterator.get())
     1107            return clientSpace;
     1108
     1109        auto& heapData = clientData.heapData();
     1110        Locker locker { heapData.lock() };
     1111
     1112        auto& spaces = heapData.subspaces();
     1113        IsoSubspace* space = spaces.m_subspaceForTestInterfaceIterator.get();
     1114        if (!space) {
     1115            Heap& heap = vm.heap;
     1116            static_assert(std::is_base_of_v<JSC::JSDestructibleObject, TestInterfaceIterator> || !TestInterfaceIterator::needsDestruction);
     1117            if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, TestInterfaceIterator>)
     1118                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, TestInterfaceIterator);
     1119            else
     1120                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, TestInterfaceIterator);
     1121            spaces.m_subspaceForTestInterfaceIterator = std::unique_ptr<IsoSubspace>(space);
     1122IGNORE_WARNINGS_BEGIN("unreachable-code")
     1123IGNORE_WARNINGS_BEGIN("tautological-compare")
     1124            void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = TestInterfaceIterator::visitOutputConstraints;
     1125            void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     1126            if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     1127                heapData.outputConstraintSpaces().append(space);
     1128IGNORE_WARNINGS_END
     1129IGNORE_WARNINGS_END
     1130        }
     1131
     1132        clientSpaces.m_clientSubspaceForTestInterfaceIterator = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     1133        return clientSpaces.m_clientSubspaceForTestInterfaceIterator.get();
    11101134    }
    11111135
    … …  
    11811205JSC::GCClient::IsoSubspace* JSTestInterface::subspaceForImpl(JSC::VM& vm)
    11821206{
    1183     return subspaceForImpl<JSTestInterface, UseCustomHeapCellType::No>(vm,
    1184         [] (auto& spaces) { return spaces.m_clientSubspaceForTestInterface.get(); },
    1185         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestInterface = WTFMove(space); },
    1186         [] (auto& spaces) { return spaces.m_subspaceForTestInterface.get(); },
    1187         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestInterface = WTFMove(space); },
    1188         nullptr
    1189     );
     1207    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     1208    auto& clientSpaces = clientData.clientSubspaces();
     1209    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestInterface.get())
     1210        return clientSpace;
     1211
     1212    auto& heapData = clientData.heapData();
     1213    Locker locker { heapData.lock() };
     1214
     1215    auto& spaces = heapData.subspaces();
     1216    IsoSubspace* space = spaces.m_subspaceForTestInterface.get();
     1217    if (!space) {
     1218        Heap& heap = vm.heap;
     1219        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestInterface> || !JSTestInterface::needsDestruction);
     1220        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestInterface>)
     1221            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestInterface);
     1222        else
     1223            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestInterface);
     1224        spaces.m_subspaceForTestInterface = std::unique_ptr<IsoSubspace>(space);
     1225IGNORE_WARNINGS_BEGIN("unreachable-code")
     1226IGNORE_WARNINGS_BEGIN("tautological-compare")
     1227        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestInterface::visitOutputConstraints;
     1228        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     1229        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     1230            heapData.outputConstraintSpaces().append(space);
     1231IGNORE_WARNINGS_END
     1232IGNORE_WARNINGS_END
     1233    }
     1234
     1235    clientSpaces.m_clientSubspaceForTestInterface = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     1236    return clientSpaces.m_clientSubspaceForTestInterface.get();
    11901237}
    11911238

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestInterfaceLeadingUnderscore.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    183183JSC::GCClient::IsoSubspace* JSTestInterfaceLeadingUnderscore::subspaceForImpl(JSC::VM& vm)
    184184{
    185     return subspaceForImpl<JSTestInterfaceLeadingUnderscore, UseCustomHeapCellType::No>(vm,
    186         [] (auto& spaces) { return spaces.m_clientSubspaceForTestInterfaceLeadingUnderscore.get(); },
    187         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestInterfaceLeadingUnderscore = WTFMove(space); },
    188         [] (auto& spaces) { return spaces.m_subspaceForTestInterfaceLeadingUnderscore.get(); },
    189         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestInterfaceLeadingUnderscore = WTFMove(space); },
    190         nullptr
    191     );
     185    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     186    auto& clientSpaces = clientData.clientSubspaces();
     187    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestInterfaceLeadingUnderscore.get())
     188        return clientSpace;
     189
     190    auto& heapData = clientData.heapData();
     191    Locker locker { heapData.lock() };
     192
     193    auto& spaces = heapData.subspaces();
     194    IsoSubspace* space = spaces.m_subspaceForTestInterfaceLeadingUnderscore.get();
     195    if (!space) {
     196        Heap& heap = vm.heap;
     197        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestInterfaceLeadingUnderscore> || !JSTestInterfaceLeadingUnderscore::needsDestruction);
     198        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestInterfaceLeadingUnderscore>)
     199            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestInterfaceLeadingUnderscore);
     200        else
     201            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestInterfaceLeadingUnderscore);
     202        spaces.m_subspaceForTestInterfaceLeadingUnderscore = std::unique_ptr<IsoSubspace>(space);
     203IGNORE_WARNINGS_BEGIN("unreachable-code")
     204IGNORE_WARNINGS_BEGIN("tautological-compare")
     205        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestInterfaceLeadingUnderscore::visitOutputConstraints;
     206        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     207        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     208            heapData.outputConstraintSpaces().append(space);
     209IGNORE_WARNINGS_END
     210IGNORE_WARNINGS_END
     211    }
     212
     213    clientSpaces.m_clientSubspaceForTestInterfaceLeadingUnderscore = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     214    return clientSpaces.m_clientSubspaceForTestInterfaceLeadingUnderscore.get();
    192215}
    193216

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestIterable.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    197197        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
    198198            return nullptr;
    199         return subspaceForImpl<TestIterableIterator, UseCustomHeapCellType::No>(vm,
    200             [] (auto& spaces) { return spaces.m_clientSubspaceForTestIterableIterator.get(); },
    201             [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestIterableIterator = WTFMove(space); },
    202             [] (auto& spaces) { return spaces.m_subspaceForTestIterableIterator.get(); },
    203             [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestIterableIterator = WTFMove(space); }
    204         );
     199        auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     200        auto& clientSpaces = clientData.clientSubspaces();
     201        if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestIterableIterator.get())
     202            return clientSpace;
     203
     204        auto& heapData = clientData.heapData();
     205        Locker locker { heapData.lock() };
     206
     207        auto& spaces = heapData.subspaces();
     208        IsoSubspace* space = spaces.m_subspaceForTestIterableIterator.get();
     209        if (!space) {
     210            Heap& heap = vm.heap;
     211            static_assert(std::is_base_of_v<JSC::JSDestructibleObject, TestIterableIterator> || !TestIterableIterator::needsDestruction);
     212            if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, TestIterableIterator>)
     213                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, TestIterableIterator);
     214            else
     215                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, TestIterableIterator);
     216            spaces.m_subspaceForTestIterableIterator = std::unique_ptr<IsoSubspace>(space);
     217IGNORE_WARNINGS_BEGIN("unreachable-code")
     218IGNORE_WARNINGS_BEGIN("tautological-compare")
     219            void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = TestIterableIterator::visitOutputConstraints;
     220            void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     221            if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     222                heapData.outputConstraintSpaces().append(space);
     223IGNORE_WARNINGS_END
     224IGNORE_WARNINGS_END
     225        }
     226
     227        clientSpaces.m_clientSubspaceForTestIterableIterator = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     228        return clientSpaces.m_clientSubspaceForTestIterableIterator.get();
    205229    }
    206230
    … …  
    276300JSC::GCClient::IsoSubspace* JSTestIterable::subspaceForImpl(JSC::VM& vm)
    277301{
    278     return subspaceForImpl<JSTestIterable, UseCustomHeapCellType::No>(vm,
    279         [] (auto& spaces) { return spaces.m_clientSubspaceForTestIterable.get(); },
    280         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestIterable = WTFMove(space); },
    281         [] (auto& spaces) { return spaces.m_subspaceForTestIterable.get(); },
    282         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestIterable = WTFMove(space); },
    283         nullptr
    284     );
     302    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     303    auto& clientSpaces = clientData.clientSubspaces();
     304    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestIterable.get())
     305        return clientSpace;
     306
     307    auto& heapData = clientData.heapData();
     308    Locker locker { heapData.lock() };
     309
     310    auto& spaces = heapData.subspaces();
     311    IsoSubspace* space = spaces.m_subspaceForTestIterable.get();
     312    if (!space) {
     313        Heap& heap = vm.heap;
     314        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestIterable> || !JSTestIterable::needsDestruction);
     315        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIterable>)
     316            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestIterable);
     317        else
     318            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestIterable);
     319        spaces.m_subspaceForTestIterable = std::unique_ptr<IsoSubspace>(space);
     320IGNORE_WARNINGS_BEGIN("unreachable-code")
     321IGNORE_WARNINGS_BEGIN("tautological-compare")
     322        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestIterable::visitOutputConstraints;
     323        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     324        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     325            heapData.outputConstraintSpaces().append(space);
     326IGNORE_WARNINGS_END
     327IGNORE_WARNINGS_END
     328    }
     329
     330    clientSpaces.m_clientSubspaceForTestIterable = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     331    return clientSpaces.m_clientSubspaceForTestIterable.get();
    285332}
    286333

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestJSBuiltinConstructor.cpp

    r290188 r290193  
    2222#include "JSTestJSBuiltinConstructor.h"
    2323
    24 #include "ExtendedDOMClientIsoSubspaces.h"
    25 #include "ExtendedDOMIsoSubspaces.h"
     24#include "DOMClientIsoSubspaces.h"
     25#include "DOMIsoSubspaces.h"
    2626#include "JSDOMAttribute.h"
    2727#include "JSDOMBinding.h"
    … …  
    226226JSC::GCClient::IsoSubspace* JSTestJSBuiltinConstructor::subspaceForImpl(JSC::VM& vm)
    227227{
    228     return subspaceForImpl<JSTestJSBuiltinConstructor, UseCustomHeapCellType::No>(vm,
    229         [] (auto& spaces) { return spaces.m_clientSubspaceForTestJSBuiltinConstructor.get(); },
    230         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestJSBuiltinConstructor = WTFMove(space); },
    231         [] (auto& spaces) { return spaces.m_subspaceForTestJSBuiltinConstructor.get(); },
    232         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestJSBuiltinConstructor = WTFMove(space); },
    233         nullptr
    234     );
    235 }
    236 
    237 
    238 }
     228    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     229    auto& clientSpaces = clientData.clientSubspaces();
     230    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestJSBuiltinConstructor.get())
     231        return clientSpace;
     232
     233    auto& heapData = clientData.heapData();
     234    Locker locker { heapData.lock() };
     235
     236    auto& spaces = heapData.subspaces();
     237    IsoSubspace* space = spaces.m_subspaceForTestJSBuiltinConstructor.get();
     238    if (!space) {
     239        Heap& heap = vm.heap;
     240        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestJSBuiltinConstructor> || !JSTestJSBuiltinConstructor::needsDestruction);
     241        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestJSBuiltinConstructor>)
     242            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestJSBuiltinConstructor);
     243        else
     244            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestJSBuiltinConstructor);
     245        spaces.m_subspaceForTestJSBuiltinConstructor = std::unique_ptr<IsoSubspace>(space);
     246IGNORE_WARNINGS_BEGIN("unreachable-code")
     247IGNORE_WARNINGS_BEGIN("tautological-compare")
     248        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestJSBuiltinConstructor::visitOutputConstraints;
     249        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     250        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     251            heapData.outputConstraintSpaces().append(space);
     252IGNORE_WARNINGS_END
     253IGNORE_WARNINGS_END
     254    }
     255
     256    clientSpaces.m_clientSubspaceForTestJSBuiltinConstructor = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     257    return clientSpaces.m_clientSubspaceForTestJSBuiltinConstructor.get();
     258}
     259
     260
     261}

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestLegacyFactoryFunction.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "Document.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
    2828#include "JSDOMBinding.h"
    2929#include "JSDOMConstructorNotConstructable.h"
    … …  
    228228JSC::GCClient::IsoSubspace* JSTestLegacyFactoryFunction::subspaceForImpl(JSC::VM& vm)
    229229{
    230     return subspaceForImpl<JSTestLegacyFactoryFunction, UseCustomHeapCellType::No>(vm,
    231         [] (auto& spaces) { return spaces.m_clientSubspaceForTestLegacyFactoryFunction.get(); },
    232         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestLegacyFactoryFunction = WTFMove(space); },
    233         [] (auto& spaces) { return spaces.m_subspaceForTestLegacyFactoryFunction.get(); },
    234         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestLegacyFactoryFunction = WTFMove(space); },
    235         nullptr
    236     );
     230    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     231    auto& clientSpaces = clientData.clientSubspaces();
     232    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestLegacyFactoryFunction.get())
     233        return clientSpace;
     234
     235    auto& heapData = clientData.heapData();
     236    Locker locker { heapData.lock() };
     237
     238    auto& spaces = heapData.subspaces();
     239    IsoSubspace* space = spaces.m_subspaceForTestLegacyFactoryFunction.get();
     240    if (!space) {
     241        Heap& heap = vm.heap;
     242        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestLegacyFactoryFunction> || !JSTestLegacyFactoryFunction::needsDestruction);
     243        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestLegacyFactoryFunction>)
     244            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestLegacyFactoryFunction);
     245        else
     246            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestLegacyFactoryFunction);
     247        spaces.m_subspaceForTestLegacyFactoryFunction = std::unique_ptr<IsoSubspace>(space);
     248IGNORE_WARNINGS_BEGIN("unreachable-code")
     249IGNORE_WARNINGS_BEGIN("tautological-compare")
     250        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestLegacyFactoryFunction::visitOutputConstraints;
     251        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     252        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     253            heapData.outputConstraintSpaces().append(space);
     254IGNORE_WARNINGS_END
     255IGNORE_WARNINGS_END
     256    }
     257
     258    clientSpaces.m_clientSubspaceForTestLegacyFactoryFunction = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     259    return clientSpaces.m_clientSubspaceForTestLegacyFactoryFunction.get();
    237260}
    238261

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestLegacyNoInterfaceObject.cpp

    r290188 r290193  
    2626
    2727#include "ActiveDOMObject.h"
    28 #include "ExtendedDOMClientIsoSubspaces.h"
    29 #include "ExtendedDOMIsoSubspaces.h"
     28#include "DOMClientIsoSubspaces.h"
     29#include "DOMIsoSubspaces.h"
    3030#include "IDLTypes.h"
    3131#include "JSDOMAttribute.h"
    … …  
    331331JSC::GCClient::IsoSubspace* JSTestLegacyNoInterfaceObject::subspaceForImpl(JSC::VM& vm)
    332332{
    333     return subspaceForImpl<JSTestLegacyNoInterfaceObject, UseCustomHeapCellType::No>(vm,
    334         [] (auto& spaces) { return spaces.m_clientSubspaceForTestLegacyNoInterfaceObject.get(); },
    335         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestLegacyNoInterfaceObject = WTFMove(space); },
    336         [] (auto& spaces) { return spaces.m_subspaceForTestLegacyNoInterfaceObject.get(); },
    337         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestLegacyNoInterfaceObject = WTFMove(space); },
    338         nullptr
    339     );
     333    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     334    auto& clientSpaces = clientData.clientSubspaces();
     335    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestLegacyNoInterfaceObject.get())
     336        return clientSpace;
     337
     338    auto& heapData = clientData.heapData();
     339    Locker locker { heapData.lock() };
     340
     341    auto& spaces = heapData.subspaces();
     342    IsoSubspace* space = spaces.m_subspaceForTestLegacyNoInterfaceObject.get();
     343    if (!space) {
     344        Heap& heap = vm.heap;
     345        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestLegacyNoInterfaceObject> || !JSTestLegacyNoInterfaceObject::needsDestruction);
     346        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestLegacyNoInterfaceObject>)
     347            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestLegacyNoInterfaceObject);
     348        else
     349            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestLegacyNoInterfaceObject);
     350        spaces.m_subspaceForTestLegacyNoInterfaceObject = std::unique_ptr<IsoSubspace>(space);
     351IGNORE_WARNINGS_BEGIN("unreachable-code")
     352IGNORE_WARNINGS_BEGIN("tautological-compare")
     353        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestLegacyNoInterfaceObject::visitOutputConstraints;
     354        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     355        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     356            heapData.outputConstraintSpaces().append(space);
     357IGNORE_WARNINGS_END
     358IGNORE_WARNINGS_END
     359    }
     360
     361    clientSpaces.m_clientSubspaceForTestLegacyNoInterfaceObject = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     362    return clientSpaces.m_clientSubspaceForTestLegacyNoInterfaceObject.get();
    340363}
    341364

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestLegacyOverrideBuiltIns.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    245245JSC::GCClient::IsoSubspace* JSTestLegacyOverrideBuiltIns::subspaceForImpl(JSC::VM& vm)
    246246{
    247     return subspaceForImpl<JSTestLegacyOverrideBuiltIns, UseCustomHeapCellType::No>(vm,
    248         [] (auto& spaces) { return spaces.m_clientSubspaceForTestLegacyOverrideBuiltIns.get(); },
    249         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestLegacyOverrideBuiltIns = WTFMove(space); },
    250         [] (auto& spaces) { return spaces.m_subspaceForTestLegacyOverrideBuiltIns.get(); },
    251         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestLegacyOverrideBuiltIns = WTFMove(space); },
    252         nullptr
    253     );
     247    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     248    auto& clientSpaces = clientData.clientSubspaces();
     249    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestLegacyOverrideBuiltIns.get())
     250        return clientSpace;
     251
     252    auto& heapData = clientData.heapData();
     253    Locker locker { heapData.lock() };
     254
     255    auto& spaces = heapData.subspaces();
     256    IsoSubspace* space = spaces.m_subspaceForTestLegacyOverrideBuiltIns.get();
     257    if (!space) {
     258        Heap& heap = vm.heap;
     259        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestLegacyOverrideBuiltIns> || !JSTestLegacyOverrideBuiltIns::needsDestruction);
     260        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestLegacyOverrideBuiltIns>)
     261            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestLegacyOverrideBuiltIns);
     262        else
     263            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestLegacyOverrideBuiltIns);
     264        spaces.m_subspaceForTestLegacyOverrideBuiltIns = std::unique_ptr<IsoSubspace>(space);
     265IGNORE_WARNINGS_BEGIN("unreachable-code")
     266IGNORE_WARNINGS_BEGIN("tautological-compare")
     267        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestLegacyOverrideBuiltIns::visitOutputConstraints;
     268        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     269        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     270            heapData.outputConstraintSpaces().append(space);
     271IGNORE_WARNINGS_END
     272IGNORE_WARNINGS_END
     273    }
     274
     275    clientSpaces.m_clientSubspaceForTestLegacyOverrideBuiltIns = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     276    return clientSpaces.m_clientSubspaceForTestLegacyOverrideBuiltIns.get();
    254277}
    255278

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestMapLike.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    362362JSC::GCClient::IsoSubspace* JSTestMapLike::subspaceForImpl(JSC::VM& vm)
    363363{
    364     return subspaceForImpl<JSTestMapLike, UseCustomHeapCellType::No>(vm,
    365         [] (auto& spaces) { return spaces.m_clientSubspaceForTestMapLike.get(); },
    366         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestMapLike = WTFMove(space); },
    367         [] (auto& spaces) { return spaces.m_subspaceForTestMapLike.get(); },
    368         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestMapLike = WTFMove(space); },
    369         nullptr
    370     );
     364    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     365    auto& clientSpaces = clientData.clientSubspaces();
     366    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestMapLike.get())
     367        return clientSpace;
     368
     369    auto& heapData = clientData.heapData();
     370    Locker locker { heapData.lock() };
     371
     372    auto& spaces = heapData.subspaces();
     373    IsoSubspace* space = spaces.m_subspaceForTestMapLike.get();
     374    if (!space) {
     375        Heap& heap = vm.heap;
     376        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestMapLike> || !JSTestMapLike::needsDestruction);
     377        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestMapLike>)
     378            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestMapLike);
     379        else
     380            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestMapLike);
     381        spaces.m_subspaceForTestMapLike = std::unique_ptr<IsoSubspace>(space);
     382IGNORE_WARNINGS_BEGIN("unreachable-code")
     383IGNORE_WARNINGS_BEGIN("tautological-compare")
     384        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestMapLike::visitOutputConstraints;
     385        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     386        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     387            heapData.outputConstraintSpaces().append(space);
     388IGNORE_WARNINGS_END
     389IGNORE_WARNINGS_END
     390    }
     391
     392    clientSpaces.m_clientSubspaceForTestMapLike = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     393    return clientSpaces.m_clientSubspaceForTestMapLike.get();
    371394}
    372395

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestMapLikeWithOverriddenOperations.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAttribute.h"
    … …  
    376376JSC::GCClient::IsoSubspace* JSTestMapLikeWithOverriddenOperations::subspaceForImpl(JSC::VM& vm)
    377377{
    378     return subspaceForImpl<JSTestMapLikeWithOverriddenOperations, UseCustomHeapCellType::No>(vm,
    379         [] (auto& spaces) { return spaces.m_clientSubspaceForTestMapLikeWithOverriddenOperations.get(); },
    380         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestMapLikeWithOverriddenOperations = WTFMove(space); },
    381         [] (auto& spaces) { return spaces.m_subspaceForTestMapLikeWithOverriddenOperations.get(); },
    382         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestMapLikeWithOverriddenOperations = WTFMove(space); },
    383         nullptr
    384     );
     378    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     379    auto& clientSpaces = clientData.clientSubspaces();
     380    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestMapLikeWithOverriddenOperations.get())
     381        return clientSpace;
     382
     383    auto& heapData = clientData.heapData();
     384    Locker locker { heapData.lock() };
     385
     386    auto& spaces = heapData.subspaces();
     387    IsoSubspace* space = spaces.m_subspaceForTestMapLikeWithOverriddenOperations.get();
     388    if (!space) {
     389        Heap& heap = vm.heap;
     390        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestMapLikeWithOverriddenOperations> || !JSTestMapLikeWithOverriddenOperations::needsDestruction);
     391        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestMapLikeWithOverriddenOperations>)
     392            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestMapLikeWithOverriddenOperations);
     393        else
     394            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestMapLikeWithOverriddenOperations);
     395        spaces.m_subspaceForTestMapLikeWithOverriddenOperations = std::unique_ptr<IsoSubspace>(space);
     396IGNORE_WARNINGS_BEGIN("unreachable-code")
     397IGNORE_WARNINGS_BEGIN("tautological-compare")
     398        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestMapLikeWithOverriddenOperations::visitOutputConstraints;
     399        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     400        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     401            heapData.outputConstraintSpaces().append(space);
     402IGNORE_WARNINGS_END
     403IGNORE_WARNINGS_END
     404    }
     405
     406    clientSpaces.m_clientSubspaceForTestMapLikeWithOverriddenOperations = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     407    return clientSpaces.m_clientSubspaceForTestMapLikeWithOverriddenOperations.get();
    385408}
    386409

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterNoIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    340340JSC::GCClient::IsoSubspace* JSTestNamedAndIndexedSetterNoIdentifier::subspaceForImpl(JSC::VM& vm)
    341341{
    342     return subspaceForImpl<JSTestNamedAndIndexedSetterNoIdentifier, UseCustomHeapCellType::No>(vm,
    343         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedAndIndexedSetterNoIdentifier.get(); },
    344         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedAndIndexedSetterNoIdentifier = WTFMove(space); },
    345         [] (auto& spaces) { return spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier.get(); },
    346         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier = WTFMove(space); },
    347         nullptr
    348     );
     342    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     343    auto& clientSpaces = clientData.clientSubspaces();
     344    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterNoIdentifier.get())
     345        return clientSpace;
     346
     347    auto& heapData = clientData.heapData();
     348    Locker locker { heapData.lock() };
     349
     350    auto& spaces = heapData.subspaces();
     351    IsoSubspace* space = spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier.get();
     352    if (!space) {
     353        Heap& heap = vm.heap;
     354        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterNoIdentifier> || !JSTestNamedAndIndexedSetterNoIdentifier::needsDestruction);
     355        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterNoIdentifier>)
     356            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedAndIndexedSetterNoIdentifier);
     357        else
     358            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedAndIndexedSetterNoIdentifier);
     359        spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier = std::unique_ptr<IsoSubspace>(space);
     360IGNORE_WARNINGS_BEGIN("unreachable-code")
     361IGNORE_WARNINGS_BEGIN("tautological-compare")
     362        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedAndIndexedSetterNoIdentifier::visitOutputConstraints;
     363        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     364        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     365            heapData.outputConstraintSpaces().append(space);
     366IGNORE_WARNINGS_END
     367IGNORE_WARNINGS_END
     368    }
     369
     370    clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterNoIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     371    return clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterNoIdentifier.get();
    349372}
    350373

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterThrowingException.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    340340JSC::GCClient::IsoSubspace* JSTestNamedAndIndexedSetterThrowingException::subspaceForImpl(JSC::VM& vm)
    341341{
    342     return subspaceForImpl<JSTestNamedAndIndexedSetterThrowingException, UseCustomHeapCellType::No>(vm,
    343         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedAndIndexedSetterThrowingException.get(); },
    344         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedAndIndexedSetterThrowingException = WTFMove(space); },
    345         [] (auto& spaces) { return spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException.get(); },
    346         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException = WTFMove(space); },
    347         nullptr
    348     );
     342    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     343    auto& clientSpaces = clientData.clientSubspaces();
     344    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterThrowingException.get())
     345        return clientSpace;
     346
     347    auto& heapData = clientData.heapData();
     348    Locker locker { heapData.lock() };
     349
     350    auto& spaces = heapData.subspaces();
     351    IsoSubspace* space = spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException.get();
     352    if (!space) {
     353        Heap& heap = vm.heap;
     354        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterThrowingException> || !JSTestNamedAndIndexedSetterThrowingException::needsDestruction);
     355        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterThrowingException>)
     356            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedAndIndexedSetterThrowingException);
     357        else
     358            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedAndIndexedSetterThrowingException);
     359        spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException = std::unique_ptr<IsoSubspace>(space);
     360IGNORE_WARNINGS_BEGIN("unreachable-code")
     361IGNORE_WARNINGS_BEGIN("tautological-compare")
     362        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedAndIndexedSetterThrowingException::visitOutputConstraints;
     363        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     364        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     365            heapData.outputConstraintSpaces().append(space);
     366IGNORE_WARNINGS_END
     367IGNORE_WARNINGS_END
     368    }
     369
     370    clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterThrowingException = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     371    return clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterThrowingException.get();
    349372}
    350373

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterWithIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    397397JSC::GCClient::IsoSubspace* JSTestNamedAndIndexedSetterWithIdentifier::subspaceForImpl(JSC::VM& vm)
    398398{
    399     return subspaceForImpl<JSTestNamedAndIndexedSetterWithIdentifier, UseCustomHeapCellType::No>(vm,
    400         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedAndIndexedSetterWithIdentifier.get(); },
    401         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedAndIndexedSetterWithIdentifier = WTFMove(space); },
    402         [] (auto& spaces) { return spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier.get(); },
    403         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier = WTFMove(space); },
    404         nullptr
    405     );
     399    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     400    auto& clientSpaces = clientData.clientSubspaces();
     401    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterWithIdentifier.get())
     402        return clientSpace;
     403
     404    auto& heapData = clientData.heapData();
     405    Locker locker { heapData.lock() };
     406
     407    auto& spaces = heapData.subspaces();
     408    IsoSubspace* space = spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier.get();
     409    if (!space) {
     410        Heap& heap = vm.heap;
     411        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterWithIdentifier> || !JSTestNamedAndIndexedSetterWithIdentifier::needsDestruction);
     412        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterWithIdentifier>)
     413            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedAndIndexedSetterWithIdentifier);
     414        else
     415            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedAndIndexedSetterWithIdentifier);
     416        spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier = std::unique_ptr<IsoSubspace>(space);
     417IGNORE_WARNINGS_BEGIN("unreachable-code")
     418IGNORE_WARNINGS_BEGIN("tautological-compare")
     419        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedAndIndexedSetterWithIdentifier::visitOutputConstraints;
     420        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     421        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     422            heapData.outputConstraintSpaces().append(space);
     423IGNORE_WARNINGS_END
     424IGNORE_WARNINGS_END
     425    }
     426
     427    clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterWithIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     428    return clientSpaces.m_clientSubspaceForTestNamedAndIndexedSetterWithIdentifier.get();
    406429}
    407430

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterNoIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    242242JSC::GCClient::IsoSubspace* JSTestNamedDeleterNoIdentifier::subspaceForImpl(JSC::VM& vm)
    243243{
    244     return subspaceForImpl<JSTestNamedDeleterNoIdentifier, UseCustomHeapCellType::No>(vm,
    245         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedDeleterNoIdentifier.get(); },
    246         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedDeleterNoIdentifier = WTFMove(space); },
    247         [] (auto& spaces) { return spaces.m_subspaceForTestNamedDeleterNoIdentifier.get(); },
    248         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedDeleterNoIdentifier = WTFMove(space); },
    249         nullptr
    250     );
     244    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     245    auto& clientSpaces = clientData.clientSubspaces();
     246    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedDeleterNoIdentifier.get())
     247        return clientSpace;
     248
     249    auto& heapData = clientData.heapData();
     250    Locker locker { heapData.lock() };
     251
     252    auto& spaces = heapData.subspaces();
     253    IsoSubspace* space = spaces.m_subspaceForTestNamedDeleterNoIdentifier.get();
     254    if (!space) {
     255        Heap& heap = vm.heap;
     256        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterNoIdentifier> || !JSTestNamedDeleterNoIdentifier::needsDestruction);
     257        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterNoIdentifier>)
     258            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedDeleterNoIdentifier);
     259        else
     260            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedDeleterNoIdentifier);
     261        spaces.m_subspaceForTestNamedDeleterNoIdentifier = std::unique_ptr<IsoSubspace>(space);
     262IGNORE_WARNINGS_BEGIN("unreachable-code")
     263IGNORE_WARNINGS_BEGIN("tautological-compare")
     264        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedDeleterNoIdentifier::visitOutputConstraints;
     265        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     266        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     267            heapData.outputConstraintSpaces().append(space);
     268IGNORE_WARNINGS_END
     269IGNORE_WARNINGS_END
     270    }
     271
     272    clientSpaces.m_clientSubspaceForTestNamedDeleterNoIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     273    return clientSpaces.m_clientSubspaceForTestNamedDeleterNoIdentifier.get();
    251274}
    252275

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterThrowingException.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    242242JSC::GCClient::IsoSubspace* JSTestNamedDeleterThrowingException::subspaceForImpl(JSC::VM& vm)
    243243{
    244     return subspaceForImpl<JSTestNamedDeleterThrowingException, UseCustomHeapCellType::No>(vm,
    245         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedDeleterThrowingException.get(); },
    246         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedDeleterThrowingException = WTFMove(space); },
    247         [] (auto& spaces) { return spaces.m_subspaceForTestNamedDeleterThrowingException.get(); },
    248         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedDeleterThrowingException = WTFMove(space); },
    249         nullptr
    250     );
     244    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     245    auto& clientSpaces = clientData.clientSubspaces();
     246    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedDeleterThrowingException.get())
     247        return clientSpace;
     248
     249    auto& heapData = clientData.heapData();
     250    Locker locker { heapData.lock() };
     251
     252    auto& spaces = heapData.subspaces();
     253    IsoSubspace* space = spaces.m_subspaceForTestNamedDeleterThrowingException.get();
     254    if (!space) {
     255        Heap& heap = vm.heap;
     256        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterThrowingException> || !JSTestNamedDeleterThrowingException::needsDestruction);
     257        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterThrowingException>)
     258            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedDeleterThrowingException);
     259        else
     260            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedDeleterThrowingException);
     261        spaces.m_subspaceForTestNamedDeleterThrowingException = std::unique_ptr<IsoSubspace>(space);
     262IGNORE_WARNINGS_BEGIN("unreachable-code")
     263IGNORE_WARNINGS_BEGIN("tautological-compare")
     264        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedDeleterThrowingException::visitOutputConstraints;
     265        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     266        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     267            heapData.outputConstraintSpaces().append(space);
     268IGNORE_WARNINGS_END
     269IGNORE_WARNINGS_END
     270    }
     271
     272    clientSpaces.m_clientSubspaceForTestNamedDeleterThrowingException = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     273    return clientSpaces.m_clientSubspaceForTestNamedDeleterThrowingException.get();
    251274}
    252275

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterWithIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    266266JSC::GCClient::IsoSubspace* JSTestNamedDeleterWithIdentifier::subspaceForImpl(JSC::VM& vm)
    267267{
    268     return subspaceForImpl<JSTestNamedDeleterWithIdentifier, UseCustomHeapCellType::No>(vm,
    269         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedDeleterWithIdentifier.get(); },
    270         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedDeleterWithIdentifier = WTFMove(space); },
    271         [] (auto& spaces) { return spaces.m_subspaceForTestNamedDeleterWithIdentifier.get(); },
    272         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedDeleterWithIdentifier = WTFMove(space); },
    273         nullptr
    274     );
     268    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     269    auto& clientSpaces = clientData.clientSubspaces();
     270    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedDeleterWithIdentifier.get())
     271        return clientSpace;
     272
     273    auto& heapData = clientData.heapData();
     274    Locker locker { heapData.lock() };
     275
     276    auto& spaces = heapData.subspaces();
     277    IsoSubspace* space = spaces.m_subspaceForTestNamedDeleterWithIdentifier.get();
     278    if (!space) {
     279        Heap& heap = vm.heap;
     280        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterWithIdentifier> || !JSTestNamedDeleterWithIdentifier::needsDestruction);
     281        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterWithIdentifier>)
     282            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedDeleterWithIdentifier);
     283        else
     284            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedDeleterWithIdentifier);
     285        spaces.m_subspaceForTestNamedDeleterWithIdentifier = std::unique_ptr<IsoSubspace>(space);
     286IGNORE_WARNINGS_BEGIN("unreachable-code")
     287IGNORE_WARNINGS_BEGIN("tautological-compare")
     288        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedDeleterWithIdentifier::visitOutputConstraints;
     289        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     290        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     291            heapData.outputConstraintSpaces().append(space);
     292IGNORE_WARNINGS_END
     293IGNORE_WARNINGS_END
     294    }
     295
     296    clientSpaces.m_clientSubspaceForTestNamedDeleterWithIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     297    return clientSpaces.m_clientSubspaceForTestNamedDeleterWithIdentifier.get();
    275298}
    276299

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterWithIndexedGetter.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    258258JSC::GCClient::IsoSubspace* JSTestNamedDeleterWithIndexedGetter::subspaceForImpl(JSC::VM& vm)
    259259{
    260     return subspaceForImpl<JSTestNamedDeleterWithIndexedGetter, UseCustomHeapCellType::No>(vm,
    261         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedDeleterWithIndexedGetter.get(); },
    262         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedDeleterWithIndexedGetter = WTFMove(space); },
    263         [] (auto& spaces) { return spaces.m_subspaceForTestNamedDeleterWithIndexedGetter.get(); },
    264         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedDeleterWithIndexedGetter = WTFMove(space); },
    265         nullptr
    266     );
     260    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     261    auto& clientSpaces = clientData.clientSubspaces();
     262    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedDeleterWithIndexedGetter.get())
     263        return clientSpace;
     264
     265    auto& heapData = clientData.heapData();
     266    Locker locker { heapData.lock() };
     267
     268    auto& spaces = heapData.subspaces();
     269    IsoSubspace* space = spaces.m_subspaceForTestNamedDeleterWithIndexedGetter.get();
     270    if (!space) {
     271        Heap& heap = vm.heap;
     272        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterWithIndexedGetter> || !JSTestNamedDeleterWithIndexedGetter::needsDestruction);
     273        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterWithIndexedGetter>)
     274            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedDeleterWithIndexedGetter);
     275        else
     276            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedDeleterWithIndexedGetter);
     277        spaces.m_subspaceForTestNamedDeleterWithIndexedGetter = std::unique_ptr<IsoSubspace>(space);
     278IGNORE_WARNINGS_BEGIN("unreachable-code")
     279IGNORE_WARNINGS_BEGIN("tautological-compare")
     280        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedDeleterWithIndexedGetter::visitOutputConstraints;
     281        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     282        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     283            heapData.outputConstraintSpaces().append(space);
     284IGNORE_WARNINGS_END
     285IGNORE_WARNINGS_END
     286    }
     287
     288    clientSpaces.m_clientSubspaceForTestNamedDeleterWithIndexedGetter = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     289    return clientSpaces.m_clientSubspaceForTestNamedDeleterWithIndexedGetter.get();
    267290}
    268291

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterCallWith.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    216216JSC::GCClient::IsoSubspace* JSTestNamedGetterCallWith::subspaceForImpl(JSC::VM& vm)
    217217{
    218     return subspaceForImpl<JSTestNamedGetterCallWith, UseCustomHeapCellType::No>(vm,
    219         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedGetterCallWith.get(); },
    220         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedGetterCallWith = WTFMove(space); },
    221         [] (auto& spaces) { return spaces.m_subspaceForTestNamedGetterCallWith.get(); },
    222         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedGetterCallWith = WTFMove(space); },
    223         nullptr
    224     );
     218    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     219    auto& clientSpaces = clientData.clientSubspaces();
     220    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedGetterCallWith.get())
     221        return clientSpace;
     222
     223    auto& heapData = clientData.heapData();
     224    Locker locker { heapData.lock() };
     225
     226    auto& spaces = heapData.subspaces();
     227    IsoSubspace* space = spaces.m_subspaceForTestNamedGetterCallWith.get();
     228    if (!space) {
     229        Heap& heap = vm.heap;
     230        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterCallWith> || !JSTestNamedGetterCallWith::needsDestruction);
     231        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterCallWith>)
     232            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedGetterCallWith);
     233        else
     234            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedGetterCallWith);
     235        spaces.m_subspaceForTestNamedGetterCallWith = std::unique_ptr<IsoSubspace>(space);
     236IGNORE_WARNINGS_BEGIN("unreachable-code")
     237IGNORE_WARNINGS_BEGIN("tautological-compare")
     238        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedGetterCallWith::visitOutputConstraints;
     239        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     240        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     241            heapData.outputConstraintSpaces().append(space);
     242IGNORE_WARNINGS_END
     243IGNORE_WARNINGS_END
     244    }
     245
     246    clientSpaces.m_clientSubspaceForTestNamedGetterCallWith = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     247    return clientSpaces.m_clientSubspaceForTestNamedGetterCallWith.get();
    225248}
    226249

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterNoIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    216216JSC::GCClient::IsoSubspace* JSTestNamedGetterNoIdentifier::subspaceForImpl(JSC::VM& vm)
    217217{
    218     return subspaceForImpl<JSTestNamedGetterNoIdentifier, UseCustomHeapCellType::No>(vm,
    219         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedGetterNoIdentifier.get(); },
    220         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedGetterNoIdentifier = WTFMove(space); },
    221         [] (auto& spaces) { return spaces.m_subspaceForTestNamedGetterNoIdentifier.get(); },
    222         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedGetterNoIdentifier = WTFMove(space); },
    223         nullptr
    224     );
     218    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     219    auto& clientSpaces = clientData.clientSubspaces();
     220    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedGetterNoIdentifier.get())
     221        return clientSpace;
     222
     223    auto& heapData = clientData.heapData();
     224    Locker locker { heapData.lock() };
     225
     226    auto& spaces = heapData.subspaces();
     227    IsoSubspace* space = spaces.m_subspaceForTestNamedGetterNoIdentifier.get();
     228    if (!space) {
     229        Heap& heap = vm.heap;
     230        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterNoIdentifier> || !JSTestNamedGetterNoIdentifier::needsDestruction);
     231        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterNoIdentifier>)
     232            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedGetterNoIdentifier);
     233        else
     234            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedGetterNoIdentifier);
     235        spaces.m_subspaceForTestNamedGetterNoIdentifier = std::unique_ptr<IsoSubspace>(space);
     236IGNORE_WARNINGS_BEGIN("unreachable-code")
     237IGNORE_WARNINGS_BEGIN("tautological-compare")
     238        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedGetterNoIdentifier::visitOutputConstraints;
     239        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     240        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     241            heapData.outputConstraintSpaces().append(space);
     242IGNORE_WARNINGS_END
     243IGNORE_WARNINGS_END
     244    }
     245
     246    clientSpaces.m_clientSubspaceForTestNamedGetterNoIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     247    return clientSpaces.m_clientSubspaceForTestNamedGetterNoIdentifier.get();
    225248}
    226249

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterWithIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    242242JSC::GCClient::IsoSubspace* JSTestNamedGetterWithIdentifier::subspaceForImpl(JSC::VM& vm)
    243243{
    244     return subspaceForImpl<JSTestNamedGetterWithIdentifier, UseCustomHeapCellType::No>(vm,
    245         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedGetterWithIdentifier.get(); },
    246         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedGetterWithIdentifier = WTFMove(space); },
    247         [] (auto& spaces) { return spaces.m_subspaceForTestNamedGetterWithIdentifier.get(); },
    248         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedGetterWithIdentifier = WTFMove(space); },
    249         nullptr
    250     );
     244    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     245    auto& clientSpaces = clientData.clientSubspaces();
     246    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedGetterWithIdentifier.get())
     247        return clientSpace;
     248
     249    auto& heapData = clientData.heapData();
     250    Locker locker { heapData.lock() };
     251
     252    auto& spaces = heapData.subspaces();
     253    IsoSubspace* space = spaces.m_subspaceForTestNamedGetterWithIdentifier.get();
     254    if (!space) {
     255        Heap& heap = vm.heap;
     256        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterWithIdentifier> || !JSTestNamedGetterWithIdentifier::needsDestruction);
     257        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterWithIdentifier>)
     258            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedGetterWithIdentifier);
     259        else
     260            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedGetterWithIdentifier);
     261        spaces.m_subspaceForTestNamedGetterWithIdentifier = std::unique_ptr<IsoSubspace>(space);
     262IGNORE_WARNINGS_BEGIN("unreachable-code")
     263IGNORE_WARNINGS_BEGIN("tautological-compare")
     264        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedGetterWithIdentifier::visitOutputConstraints;
     265        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     266        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     267            heapData.outputConstraintSpaces().append(space);
     268IGNORE_WARNINGS_END
     269IGNORE_WARNINGS_END
     270    }
     271
     272    clientSpaces.m_clientSubspaceForTestNamedGetterWithIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     273    return clientSpaces.m_clientSubspaceForTestNamedGetterWithIdentifier.get();
    251274}
    252275

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterNoIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    296296JSC::GCClient::IsoSubspace* JSTestNamedSetterNoIdentifier::subspaceForImpl(JSC::VM& vm)
    297297{
    298     return subspaceForImpl<JSTestNamedSetterNoIdentifier, UseCustomHeapCellType::No>(vm,
    299         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterNoIdentifier.get(); },
    300         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterNoIdentifier = WTFMove(space); },
    301         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterNoIdentifier.get(); },
    302         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterNoIdentifier = WTFMove(space); },
    303         nullptr
    304     );
     298    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     299    auto& clientSpaces = clientData.clientSubspaces();
     300    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterNoIdentifier.get())
     301        return clientSpace;
     302
     303    auto& heapData = clientData.heapData();
     304    Locker locker { heapData.lock() };
     305
     306    auto& spaces = heapData.subspaces();
     307    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterNoIdentifier.get();
     308    if (!space) {
     309        Heap& heap = vm.heap;
     310        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterNoIdentifier> || !JSTestNamedSetterNoIdentifier::needsDestruction);
     311        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterNoIdentifier>)
     312            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterNoIdentifier);
     313        else
     314            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterNoIdentifier);
     315        spaces.m_subspaceForTestNamedSetterNoIdentifier = std::unique_ptr<IsoSubspace>(space);
     316IGNORE_WARNINGS_BEGIN("unreachable-code")
     317IGNORE_WARNINGS_BEGIN("tautological-compare")
     318        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterNoIdentifier::visitOutputConstraints;
     319        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     320        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     321            heapData.outputConstraintSpaces().append(space);
     322IGNORE_WARNINGS_END
     323IGNORE_WARNINGS_END
     324    }
     325
     326    clientSpaces.m_clientSubspaceForTestNamedSetterNoIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     327    return clientSpaces.m_clientSubspaceForTestNamedSetterNoIdentifier.get();
    305328}
    306329

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterThrowingException.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    296296JSC::GCClient::IsoSubspace* JSTestNamedSetterThrowingException::subspaceForImpl(JSC::VM& vm)
    297297{
    298     return subspaceForImpl<JSTestNamedSetterThrowingException, UseCustomHeapCellType::No>(vm,
    299         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterThrowingException.get(); },
    300         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterThrowingException = WTFMove(space); },
    301         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterThrowingException.get(); },
    302         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterThrowingException = WTFMove(space); },
    303         nullptr
    304     );
     298    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     299    auto& clientSpaces = clientData.clientSubspaces();
     300    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterThrowingException.get())
     301        return clientSpace;
     302
     303    auto& heapData = clientData.heapData();
     304    Locker locker { heapData.lock() };
     305
     306    auto& spaces = heapData.subspaces();
     307    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterThrowingException.get();
     308    if (!space) {
     309        Heap& heap = vm.heap;
     310        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterThrowingException> || !JSTestNamedSetterThrowingException::needsDestruction);
     311        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterThrowingException>)
     312            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterThrowingException);
     313        else
     314            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterThrowingException);
     315        spaces.m_subspaceForTestNamedSetterThrowingException = std::unique_ptr<IsoSubspace>(space);
     316IGNORE_WARNINGS_BEGIN("unreachable-code")
     317IGNORE_WARNINGS_BEGIN("tautological-compare")
     318        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterThrowingException::visitOutputConstraints;
     319        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     320        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     321            heapData.outputConstraintSpaces().append(space);
     322IGNORE_WARNINGS_END
     323IGNORE_WARNINGS_END
     324    }
     325
     326    clientSpaces.m_clientSubspaceForTestNamedSetterThrowingException = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     327    return clientSpaces.m_clientSubspaceForTestNamedSetterThrowingException.get();
    305328}
    306329

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIdentifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    327327JSC::GCClient::IsoSubspace* JSTestNamedSetterWithIdentifier::subspaceForImpl(JSC::VM& vm)
    328328{
    329     return subspaceForImpl<JSTestNamedSetterWithIdentifier, UseCustomHeapCellType::No>(vm,
    330         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterWithIdentifier.get(); },
    331         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterWithIdentifier = WTFMove(space); },
    332         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterWithIdentifier.get(); },
    333         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterWithIdentifier = WTFMove(space); },
    334         nullptr
    335     );
     329    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     330    auto& clientSpaces = clientData.clientSubspaces();
     331    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterWithIdentifier.get())
     332        return clientSpace;
     333
     334    auto& heapData = clientData.heapData();
     335    Locker locker { heapData.lock() };
     336
     337    auto& spaces = heapData.subspaces();
     338    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterWithIdentifier.get();
     339    if (!space) {
     340        Heap& heap = vm.heap;
     341        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIdentifier> || !JSTestNamedSetterWithIdentifier::needsDestruction);
     342        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIdentifier>)
     343            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterWithIdentifier);
     344        else
     345            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterWithIdentifier);
     346        spaces.m_subspaceForTestNamedSetterWithIdentifier = std::unique_ptr<IsoSubspace>(space);
     347IGNORE_WARNINGS_BEGIN("unreachable-code")
     348IGNORE_WARNINGS_BEGIN("tautological-compare")
     349        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterWithIdentifier::visitOutputConstraints;
     350        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     351        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     352            heapData.outputConstraintSpaces().append(space);
     353IGNORE_WARNINGS_END
     354IGNORE_WARNINGS_END
     355    }
     356
     357    clientSpaces.m_clientSubspaceForTestNamedSetterWithIdentifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     358    return clientSpaces.m_clientSubspaceForTestNamedSetterWithIdentifier.get();
    336359}
    337360

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetter.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    374374JSC::GCClient::IsoSubspace* JSTestNamedSetterWithIndexedGetter::subspaceForImpl(JSC::VM& vm)
    375375{
    376     return subspaceForImpl<JSTestNamedSetterWithIndexedGetter, UseCustomHeapCellType::No>(vm,
    377         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterWithIndexedGetter.get(); },
    378         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterWithIndexedGetter = WTFMove(space); },
    379         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterWithIndexedGetter.get(); },
    380         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterWithIndexedGetter = WTFMove(space); },
    381         nullptr
    382     );
     376    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     377    auto& clientSpaces = clientData.clientSubspaces();
     378    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterWithIndexedGetter.get())
     379        return clientSpace;
     380
     381    auto& heapData = clientData.heapData();
     382    Locker locker { heapData.lock() };
     383
     384    auto& spaces = heapData.subspaces();
     385    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterWithIndexedGetter.get();
     386    if (!space) {
     387        Heap& heap = vm.heap;
     388        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIndexedGetter> || !JSTestNamedSetterWithIndexedGetter::needsDestruction);
     389        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIndexedGetter>)
     390            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterWithIndexedGetter);
     391        else
     392            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterWithIndexedGetter);
     393        spaces.m_subspaceForTestNamedSetterWithIndexedGetter = std::unique_ptr<IsoSubspace>(space);
     394IGNORE_WARNINGS_BEGIN("unreachable-code")
     395IGNORE_WARNINGS_BEGIN("tautological-compare")
     396        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterWithIndexedGetter::visitOutputConstraints;
     397        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     398        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     399            heapData.outputConstraintSpaces().append(space);
     400IGNORE_WARNINGS_END
     401IGNORE_WARNINGS_END
     402    }
     403
     404    clientSpaces.m_clientSubspaceForTestNamedSetterWithIndexedGetter = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     405    return clientSpaces.m_clientSubspaceForTestNamedSetterWithIndexedGetter.get();
    383406}
    384407

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetterAndSetter.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    424424JSC::GCClient::IsoSubspace* JSTestNamedSetterWithIndexedGetterAndSetter::subspaceForImpl(JSC::VM& vm)
    425425{
    426     return subspaceForImpl<JSTestNamedSetterWithIndexedGetterAndSetter, UseCustomHeapCellType::No>(vm,
    427         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterWithIndexedGetterAndSetter.get(); },
    428         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterWithIndexedGetterAndSetter = WTFMove(space); },
    429         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter.get(); },
    430         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter = WTFMove(space); },
    431         nullptr
    432     );
     426    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     427    auto& clientSpaces = clientData.clientSubspaces();
     428    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterWithIndexedGetterAndSetter.get())
     429        return clientSpace;
     430
     431    auto& heapData = clientData.heapData();
     432    Locker locker { heapData.lock() };
     433
     434    auto& spaces = heapData.subspaces();
     435    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter.get();
     436    if (!space) {
     437        Heap& heap = vm.heap;
     438        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIndexedGetterAndSetter> || !JSTestNamedSetterWithIndexedGetterAndSetter::needsDestruction);
     439        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIndexedGetterAndSetter>)
     440            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterWithIndexedGetterAndSetter);
     441        else
     442            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterWithIndexedGetterAndSetter);
     443        spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter = std::unique_ptr<IsoSubspace>(space);
     444IGNORE_WARNINGS_BEGIN("unreachable-code")
     445IGNORE_WARNINGS_BEGIN("tautological-compare")
     446        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterWithIndexedGetterAndSetter::visitOutputConstraints;
     447        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     448        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     449            heapData.outputConstraintSpaces().append(space);
     450IGNORE_WARNINGS_END
     451IGNORE_WARNINGS_END
     452    }
     453
     454    clientSpaces.m_clientSubspaceForTestNamedSetterWithIndexedGetterAndSetter = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     455    return clientSpaces.m_clientSubspaceForTestNamedSetterWithIndexedGetterAndSetter.get();
    433456}
    434457

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithLegacyOverrideBuiltIns.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAbstractOperations.h"
    2828#include "JSDOMBinding.h"
    … …  
    273273JSC::GCClient::IsoSubspace* JSTestNamedSetterWithLegacyOverrideBuiltIns::subspaceForImpl(JSC::VM& vm)
    274274{
    275     return subspaceForImpl<JSTestNamedSetterWithLegacyOverrideBuiltIns, UseCustomHeapCellType::No>(vm,
    276         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterWithLegacyOverrideBuiltIns.get(); },
    277         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterWithLegacyOverrideBuiltIns = WTFMove(space); },
    278         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterWithLegacyOverrideBuiltIns.get(); },
    279         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterWithLegacyOverrideBuiltIns = WTFMove(space); },
    280         nullptr
    281     );
     275    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     276    auto& clientSpaces = clientData.clientSubspaces();
     277    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyOverrideBuiltIns.get())
     278        return clientSpace;
     279
     280    auto& heapData = clientData.heapData();
     281    Locker locker { heapData.lock() };
     282
     283    auto& spaces = heapData.subspaces();
     284    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterWithLegacyOverrideBuiltIns.get();
     285    if (!space) {
     286        Heap& heap = vm.heap;
     287        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithLegacyOverrideBuiltIns> || !JSTestNamedSetterWithLegacyOverrideBuiltIns::needsDestruction);
     288        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithLegacyOverrideBuiltIns>)
     289            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterWithLegacyOverrideBuiltIns);
     290        else
     291            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterWithLegacyOverrideBuiltIns);
     292        spaces.m_subspaceForTestNamedSetterWithLegacyOverrideBuiltIns = std::unique_ptr<IsoSubspace>(space);
     293IGNORE_WARNINGS_BEGIN("unreachable-code")
     294IGNORE_WARNINGS_BEGIN("tautological-compare")
     295        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterWithLegacyOverrideBuiltIns::visitOutputConstraints;
     296        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     297        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     298            heapData.outputConstraintSpaces().append(space);
     299IGNORE_WARNINGS_END
     300IGNORE_WARNINGS_END
     301    }
     302
     303    clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyOverrideBuiltIns = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     304    return clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyOverrideBuiltIns.get();
    282305}
    283306

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithLegacyUnforgeableProperties.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    357357JSC::GCClient::IsoSubspace* JSTestNamedSetterWithLegacyUnforgeableProperties::subspaceForImpl(JSC::VM& vm)
    358358{
    359     return subspaceForImpl<JSTestNamedSetterWithLegacyUnforgeableProperties, UseCustomHeapCellType::No>(vm,
    360         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeableProperties.get(); },
    361         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeableProperties = WTFMove(space); },
    362         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeableProperties.get(); },
    363         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeableProperties = WTFMove(space); },
    364         nullptr
    365     );
     359    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     360    auto& clientSpaces = clientData.clientSubspaces();
     361    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeableProperties.get())
     362        return clientSpace;
     363
     364    auto& heapData = clientData.heapData();
     365    Locker locker { heapData.lock() };
     366
     367    auto& spaces = heapData.subspaces();
     368    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeableProperties.get();
     369    if (!space) {
     370        Heap& heap = vm.heap;
     371        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithLegacyUnforgeableProperties> || !JSTestNamedSetterWithLegacyUnforgeableProperties::needsDestruction);
     372        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithLegacyUnforgeableProperties>)
     373            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterWithLegacyUnforgeableProperties);
     374        else
     375            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterWithLegacyUnforgeableProperties);
     376        spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeableProperties = std::unique_ptr<IsoSubspace>(space);
     377IGNORE_WARNINGS_BEGIN("unreachable-code")
     378IGNORE_WARNINGS_BEGIN("tautological-compare")
     379        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterWithLegacyUnforgeableProperties::visitOutputConstraints;
     380        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     381        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     382            heapData.outputConstraintSpaces().append(space);
     383IGNORE_WARNINGS_END
     384IGNORE_WARNINGS_END
     385    }
     386
     387    clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeableProperties = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     388    return clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeableProperties.get();
    366389}
    367390

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAbstractOperations.h"
    … …  
    334334JSC::GCClient::IsoSubspace* JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns::subspaceForImpl(JSC::VM& vm)
    335335{
    336     return subspaceForImpl<JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns, UseCustomHeapCellType::No>(vm,
    337         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns.get(); },
    338         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns = WTFMove(space); },
    339         [] (auto& spaces) { return spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns.get(); },
    340         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns = WTFMove(space); },
    341         nullptr
    342     );
     336    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     337    auto& clientSpaces = clientData.clientSubspaces();
     338    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns.get())
     339        return clientSpace;
     340
     341    auto& heapData = clientData.heapData();
     342    Locker locker { heapData.lock() };
     343
     344    auto& spaces = heapData.subspaces();
     345    IsoSubspace* space = spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns.get();
     346    if (!space) {
     347        Heap& heap = vm.heap;
     348        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns> || !JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns::needsDestruction);
     349        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns>)
     350            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns);
     351        else
     352            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns);
     353        spaces.m_subspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns = std::unique_ptr<IsoSubspace>(space);
     354IGNORE_WARNINGS_BEGIN("unreachable-code")
     355IGNORE_WARNINGS_BEGIN("tautological-compare")
     356        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns::visitOutputConstraints;
     357        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     358        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     359            heapData.outputConstraintSpaces().append(space);
     360IGNORE_WARNINGS_END
     361IGNORE_WARNINGS_END
     362    }
     363
     364    clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     365    return clientSpaces.m_clientSubspaceForTestNamedSetterWithLegacyUnforgeablePropertiesAndLegacyOverrideBuiltIns.get();
    343366}
    344367

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNamespaceObject.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    276276JSC::GCClient::IsoSubspace* JSTestNamespaceObject::subspaceForImpl(JSC::VM& vm)
    277277{
    278     return subspaceForImpl<JSTestNamespaceObject, UseCustomHeapCellType::No>(vm,
    279         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNamespaceObject.get(); },
    280         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNamespaceObject = WTFMove(space); },
    281         [] (auto& spaces) { return spaces.m_subspaceForTestNamespaceObject.get(); },
    282         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNamespaceObject = WTFMove(space); },
    283         nullptr
    284     );
    285 }
    286 
    287 
    288 }
     278    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     279    auto& clientSpaces = clientData.clientSubspaces();
     280    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNamespaceObject.get())
     281        return clientSpace;
     282
     283    auto& heapData = clientData.heapData();
     284    Locker locker { heapData.lock() };
     285
     286    auto& spaces = heapData.subspaces();
     287    IsoSubspace* space = spaces.m_subspaceForTestNamespaceObject.get();
     288    if (!space) {
     289        Heap& heap = vm.heap;
     290        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamespaceObject> || !JSTestNamespaceObject::needsDestruction);
     291        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamespaceObject>)
     292            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNamespaceObject);
     293        else
     294            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNamespaceObject);
     295        spaces.m_subspaceForTestNamespaceObject = std::unique_ptr<IsoSubspace>(space);
     296IGNORE_WARNINGS_BEGIN("unreachable-code")
     297IGNORE_WARNINGS_BEGIN("tautological-compare")
     298        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNamespaceObject::visitOutputConstraints;
     299        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     300        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     301            heapData.outputConstraintSpaces().append(space);
     302IGNORE_WARNINGS_END
     303IGNORE_WARNINGS_END
     304    }
     305
     306    clientSpaces.m_clientSubspaceForTestNamespaceObject = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     307    return clientSpaces.m_clientSubspaceForTestNamespaceObject.get();
     308}
     309
     310
     311}

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DOMPromiseProxy.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
    2828#include "IDLTypes.h"
    2929#include "JSDOMAttribute.h"
    … …  
    403403        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
    404404            return nullptr;
    405         return subspaceForImpl<TestNodeIterator, UseCustomHeapCellType::No>(vm,
    406             [] (auto& spaces) { return spaces.m_clientSubspaceForTestNodeIterator.get(); },
    407             [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNodeIterator = WTFMove(space); },
    408             [] (auto& spaces) { return spaces.m_subspaceForTestNodeIterator.get(); },
    409             [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNodeIterator = WTFMove(space); }
    410         );
     405        auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     406        auto& clientSpaces = clientData.clientSubspaces();
     407        if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNodeIterator.get())
     408            return clientSpace;
     409
     410        auto& heapData = clientData.heapData();
     411        Locker locker { heapData.lock() };
     412
     413        auto& spaces = heapData.subspaces();
     414        IsoSubspace* space = spaces.m_subspaceForTestNodeIterator.get();
     415        if (!space) {
     416            Heap& heap = vm.heap;
     417            static_assert(std::is_base_of_v<JSC::JSDestructibleObject, TestNodeIterator> || !TestNodeIterator::needsDestruction);
     418            if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, TestNodeIterator>)
     419                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, TestNodeIterator);
     420            else
     421                space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, TestNodeIterator);
     422            spaces.m_subspaceForTestNodeIterator = std::unique_ptr<IsoSubspace>(space);
     423IGNORE_WARNINGS_BEGIN("unreachable-code")
     424IGNORE_WARNINGS_BEGIN("tautological-compare")
     425            void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = TestNodeIterator::visitOutputConstraints;
     426            void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     427            if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     428                heapData.outputConstraintSpaces().append(space);
     429IGNORE_WARNINGS_END
     430IGNORE_WARNINGS_END
     431        }
     432
     433        clientSpaces.m_clientSubspaceForTestNodeIterator = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     434        return clientSpaces.m_clientSubspaceForTestNodeIterator.get();
    411435    }
    412436
    … …  
    482506JSC::GCClient::IsoSubspace* JSTestNode::subspaceForImpl(JSC::VM& vm)
    483507{
    484     return subspaceForImpl<JSTestNode, UseCustomHeapCellType::No>(vm,
    485         [] (auto& spaces) { return spaces.m_clientSubspaceForTestNode.get(); },
    486         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestNode = WTFMove(space); },
    487         [] (auto& spaces) { return spaces.m_subspaceForTestNode.get(); },
    488         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestNode = WTFMove(space); },
    489         nullptr
    490     );
     508    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     509    auto& clientSpaces = clientData.clientSubspaces();
     510    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestNode.get())
     511        return clientSpace;
     512
     513    auto& heapData = clientData.heapData();
     514    Locker locker { heapData.lock() };
     515
     516    auto& spaces = heapData.subspaces();
     517    IsoSubspace* space = spaces.m_subspaceForTestNode.get();
     518    if (!space) {
     519        Heap& heap = vm.heap;
     520        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestNode> || !JSTestNode::needsDestruction);
     521        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNode>)
     522            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestNode);
     523        else
     524            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestNode);
     525        spaces.m_subspaceForTestNode = std::unique_ptr<IsoSubspace>(space);
     526IGNORE_WARNINGS_BEGIN("unreachable-code")
     527IGNORE_WARNINGS_BEGIN("tautological-compare")
     528        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestNode::visitOutputConstraints;
     529        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     530        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     531            heapData.outputConstraintSpaces().append(space);
     532IGNORE_WARNINGS_END
     533IGNORE_WARNINGS_END
     534    }
     535
     536    clientSpaces.m_clientSubspaceForTestNode = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     537    return clientSpaces.m_clientSubspaceForTestNode.get();
    491538}
    492539

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DOMPromiseProxy.h"
    2628#include "DOMWindow.h"
    … …  
    2931#include "ElementInlines.h"
    3032#include "EventNames.h"
    31 #include "ExtendedDOMClientIsoSubspaces.h"
    32 #include "ExtendedDOMIsoSubspaces.h"
    3333#include "HTMLNames.h"
    3434#include "IDLTypes.h"
    … …  
    90639063JSC::GCClient::IsoSubspace* JSTestObj::subspaceForImpl(JSC::VM& vm)
    90649064{
    9065     return subspaceForImpl<JSTestObj, UseCustomHeapCellType::No>(vm,
    9066         [] (auto& spaces) { return spaces.m_clientSubspaceForTestObj.get(); },
    9067         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestObj = WTFMove(space); },
    9068         [] (auto& spaces) { return spaces.m_subspaceForTestObj.get(); },
    9069         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestObj = WTFMove(space); },
    9070         nullptr
    9071     );
     9065    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     9066    auto& clientSpaces = clientData.clientSubspaces();
     9067    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestObj.get())
     9068        return clientSpace;
     9069
     9070    auto& heapData = clientData.heapData();
     9071    Locker locker { heapData.lock() };
     9072
     9073    auto& spaces = heapData.subspaces();
     9074    IsoSubspace* space = spaces.m_subspaceForTestObj.get();
     9075    if (!space) {
     9076        Heap& heap = vm.heap;
     9077        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestObj> || !JSTestObj::needsDestruction);
     9078        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestObj>)
     9079            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestObj);
     9080        else
     9081            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestObj);
     9082        spaces.m_subspaceForTestObj = std::unique_ptr<IsoSubspace>(space);
     9083IGNORE_WARNINGS_BEGIN("unreachable-code")
     9084IGNORE_WARNINGS_BEGIN("tautological-compare")
     9085        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestObj::visitOutputConstraints;
     9086        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     9087        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     9088            heapData.outputConstraintSpaces().append(space);
     9089IGNORE_WARNINGS_END
     9090IGNORE_WARNINGS_END
     9091    }
     9092
     9093    clientSpaces.m_clientSubspaceForTestObj = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     9094    return clientSpaces.m_clientSubspaceForTestObj.get();
    90729095}
    90739096

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestOperationConditional.cpp

    r290188 r290193  
    2626
    2727#include "ActiveDOMObject.h"
    28 #include "ExtendedDOMClientIsoSubspaces.h"
    29 #include "ExtendedDOMIsoSubspaces.h"
     28#include "DOMClientIsoSubspaces.h"
     29#include "DOMIsoSubspaces.h"
    3030#include "JSDOMBinding.h"
    3131#include "JSDOMConstructorNotConstructable.h"
    … …  
    230230JSC::GCClient::IsoSubspace* JSTestOperationConditional::subspaceForImpl(JSC::VM& vm)
    231231{
    232     return subspaceForImpl<JSTestOperationConditional, UseCustomHeapCellType::No>(vm,
    233         [] (auto& spaces) { return spaces.m_clientSubspaceForTestOperationConditional.get(); },
    234         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestOperationConditional = WTFMove(space); },
    235         [] (auto& spaces) { return spaces.m_subspaceForTestOperationConditional.get(); },
    236         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestOperationConditional = WTFMove(space); },
    237         nullptr
    238     );
     232    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     233    auto& clientSpaces = clientData.clientSubspaces();
     234    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestOperationConditional.get())
     235        return clientSpace;
     236
     237    auto& heapData = clientData.heapData();
     238    Locker locker { heapData.lock() };
     239
     240    auto& spaces = heapData.subspaces();
     241    IsoSubspace* space = spaces.m_subspaceForTestOperationConditional.get();
     242    if (!space) {
     243        Heap& heap = vm.heap;
     244        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestOperationConditional> || !JSTestOperationConditional::needsDestruction);
     245        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestOperationConditional>)
     246            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestOperationConditional);
     247        else
     248            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestOperationConditional);
     249        spaces.m_subspaceForTestOperationConditional = std::unique_ptr<IsoSubspace>(space);
     250IGNORE_WARNINGS_BEGIN("unreachable-code")
     251IGNORE_WARNINGS_BEGIN("tautological-compare")
     252        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestOperationConditional::visitOutputConstraints;
     253        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     254        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     255            heapData.outputConstraintSpaces().append(space);
     256IGNORE_WARNINGS_END
     257IGNORE_WARNINGS_END
     258    }
     259
     260    clientSpaces.m_clientSubspaceForTestOperationConditional = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     261    return clientSpaces.m_clientSubspaceForTestOperationConditional.get();
    239262}
    240263

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSBlob.h"
    2828#include "JSDOMBinding.h"
    … …  
    301301JSC::GCClient::IsoSubspace* JSTestOverloadedConstructors::subspaceForImpl(JSC::VM& vm)
    302302{
    303     return subspaceForImpl<JSTestOverloadedConstructors, UseCustomHeapCellType::No>(vm,
    304         [] (auto& spaces) { return spaces.m_clientSubspaceForTestOverloadedConstructors.get(); },
    305         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestOverloadedConstructors = WTFMove(space); },
    306         [] (auto& spaces) { return spaces.m_subspaceForTestOverloadedConstructors.get(); },
    307         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestOverloadedConstructors = WTFMove(space); },
    308         nullptr
    309     );
     303    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     304    auto& clientSpaces = clientData.clientSubspaces();
     305    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestOverloadedConstructors.get())
     306        return clientSpace;
     307
     308    auto& heapData = clientData.heapData();
     309    Locker locker { heapData.lock() };
     310
     311    auto& spaces = heapData.subspaces();
     312    IsoSubspace* space = spaces.m_subspaceForTestOverloadedConstructors.get();
     313    if (!space) {
     314        Heap& heap = vm.heap;
     315        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverloadedConstructors> || !JSTestOverloadedConstructors::needsDestruction);
     316        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverloadedConstructors>)
     317            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestOverloadedConstructors);
     318        else
     319            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestOverloadedConstructors);
     320        spaces.m_subspaceForTestOverloadedConstructors = std::unique_ptr<IsoSubspace>(space);
     321IGNORE_WARNINGS_BEGIN("unreachable-code")
     322IGNORE_WARNINGS_BEGIN("tautological-compare")
     323        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestOverloadedConstructors::visitOutputConstraints;
     324        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     325        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     326            heapData.outputConstraintSpaces().append(space);
     327IGNORE_WARNINGS_END
     328IGNORE_WARNINGS_END
     329    }
     330
     331    clientSpaces.m_clientSubspaceForTestOverloadedConstructors = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     332    return clientSpaces.m_clientSubspaceForTestOverloadedConstructors.get();
    310333}
    311334

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructorsWithSequence.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructor.h"
    … …  
    238238JSC::GCClient::IsoSubspace* JSTestOverloadedConstructorsWithSequence::subspaceForImpl(JSC::VM& vm)
    239239{
    240     return subspaceForImpl<JSTestOverloadedConstructorsWithSequence, UseCustomHeapCellType::No>(vm,
    241         [] (auto& spaces) { return spaces.m_clientSubspaceForTestOverloadedConstructorsWithSequence.get(); },
    242         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestOverloadedConstructorsWithSequence = WTFMove(space); },
    243         [] (auto& spaces) { return spaces.m_subspaceForTestOverloadedConstructorsWithSequence.get(); },
    244         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestOverloadedConstructorsWithSequence = WTFMove(space); },
    245         nullptr
    246     );
     240    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     241    auto& clientSpaces = clientData.clientSubspaces();
     242    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestOverloadedConstructorsWithSequence.get())
     243        return clientSpace;
     244
     245    auto& heapData = clientData.heapData();
     246    Locker locker { heapData.lock() };
     247
     248    auto& spaces = heapData.subspaces();
     249    IsoSubspace* space = spaces.m_subspaceForTestOverloadedConstructorsWithSequence.get();
     250    if (!space) {
     251        Heap& heap = vm.heap;
     252        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverloadedConstructorsWithSequence> || !JSTestOverloadedConstructorsWithSequence::needsDestruction);
     253        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverloadedConstructorsWithSequence>)
     254            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestOverloadedConstructorsWithSequence);
     255        else
     256            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestOverloadedConstructorsWithSequence);
     257        spaces.m_subspaceForTestOverloadedConstructorsWithSequence = std::unique_ptr<IsoSubspace>(space);
     258IGNORE_WARNINGS_BEGIN("unreachable-code")
     259IGNORE_WARNINGS_BEGIN("tautological-compare")
     260        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestOverloadedConstructorsWithSequence::visitOutputConstraints;
     261        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     262        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     263            heapData.outputConstraintSpaces().append(space);
     264IGNORE_WARNINGS_END
     265IGNORE_WARNINGS_END
     266    }
     267
     268    clientSpaces.m_clientSubspaceForTestOverloadedConstructorsWithSequence = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     269    return clientSpaces.m_clientSubspaceForTestOverloadedConstructorsWithSequence.get();
    247270}
    248271

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestPluginInterface.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    240240JSC::GCClient::IsoSubspace* JSTestPluginInterface::subspaceForImpl(JSC::VM& vm)
    241241{
    242     return subspaceForImpl<JSTestPluginInterface, UseCustomHeapCellType::No>(vm,
    243         [] (auto& spaces) { return spaces.m_clientSubspaceForTestPluginInterface.get(); },
    244         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestPluginInterface = WTFMove(space); },
    245         [] (auto& spaces) { return spaces.m_subspaceForTestPluginInterface.get(); },
    246         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestPluginInterface = WTFMove(space); },
    247         nullptr
    248     );
     242    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     243    auto& clientSpaces = clientData.clientSubspaces();
     244    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestPluginInterface.get())
     245        return clientSpace;
     246
     247    auto& heapData = clientData.heapData();
     248    Locker locker { heapData.lock() };
     249
     250    auto& spaces = heapData.subspaces();
     251    IsoSubspace* space = spaces.m_subspaceForTestPluginInterface.get();
     252    if (!space) {
     253        Heap& heap = vm.heap;
     254        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestPluginInterface> || !JSTestPluginInterface::needsDestruction);
     255        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestPluginInterface>)
     256            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestPluginInterface);
     257        else
     258            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestPluginInterface);
     259        spaces.m_subspaceForTestPluginInterface = std::unique_ptr<IsoSubspace>(space);
     260IGNORE_WARNINGS_BEGIN("unreachable-code")
     261IGNORE_WARNINGS_BEGIN("tautological-compare")
     262        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestPluginInterface::visitOutputConstraints;
     263        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     264        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     265            heapData.outputConstraintSpaces().append(space);
     266IGNORE_WARNINGS_END
     267IGNORE_WARNINGS_END
     268    }
     269
     270    clientSpaces.m_clientSubspaceForTestPluginInterface = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     271    return clientSpaces.m_clientSubspaceForTestPluginInterface.get();
    249272}
    250273

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestPromiseRejectionEvent.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2527#include "DOMPromiseProxy.h"
    26 #include "ExtendedDOMClientIsoSubspaces.h"
    27 #include "ExtendedDOMIsoSubspaces.h"
    2828#include "JSDOMAttribute.h"
    2929#include "JSDOMBinding.h"
    … …  
    299299JSC::GCClient::IsoSubspace* JSTestPromiseRejectionEvent::subspaceForImpl(JSC::VM& vm)
    300300{
    301     return subspaceForImpl<JSTestPromiseRejectionEvent, UseCustomHeapCellType::No>(vm,
    302         [] (auto& spaces) { return spaces.m_clientSubspaceForTestPromiseRejectionEvent.get(); },
    303         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestPromiseRejectionEvent = WTFMove(space); },
    304         [] (auto& spaces) { return spaces.m_subspaceForTestPromiseRejectionEvent.get(); },
    305         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestPromiseRejectionEvent = WTFMove(space); },
    306         nullptr
    307     );
     301    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     302    auto& clientSpaces = clientData.clientSubspaces();
     303    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestPromiseRejectionEvent.get())
     304        return clientSpace;
     305
     306    auto& heapData = clientData.heapData();
     307    Locker locker { heapData.lock() };
     308
     309    auto& spaces = heapData.subspaces();
     310    IsoSubspace* space = spaces.m_subspaceForTestPromiseRejectionEvent.get();
     311    if (!space) {
     312        Heap& heap = vm.heap;
     313        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestPromiseRejectionEvent> || !JSTestPromiseRejectionEvent::needsDestruction);
     314        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestPromiseRejectionEvent>)
     315            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestPromiseRejectionEvent);
     316        else
     317            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestPromiseRejectionEvent);
     318        spaces.m_subspaceForTestPromiseRejectionEvent = std::unique_ptr<IsoSubspace>(space);
     319IGNORE_WARNINGS_BEGIN("unreachable-code")
     320IGNORE_WARNINGS_BEGIN("tautological-compare")
     321        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestPromiseRejectionEvent::visitOutputConstraints;
     322        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     323        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     324            heapData.outputConstraintSpaces().append(space);
     325IGNORE_WARNINGS_END
     326IGNORE_WARNINGS_END
     327    }
     328
     329    clientSpaces.m_clientSubspaceForTestPromiseRejectionEvent = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     330    return clientSpaces.m_clientSubspaceForTestPromiseRejectionEvent.get();
    308331}
    309332

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestReadOnlyMapLike.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    301301JSC::GCClient::IsoSubspace* JSTestReadOnlyMapLike::subspaceForImpl(JSC::VM& vm)
    302302{
    303     return subspaceForImpl<JSTestReadOnlyMapLike, UseCustomHeapCellType::No>(vm,
    304         [] (auto& spaces) { return spaces.m_clientSubspaceForTestReadOnlyMapLike.get(); },
    305         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestReadOnlyMapLike = WTFMove(space); },
    306         [] (auto& spaces) { return spaces.m_subspaceForTestReadOnlyMapLike.get(); },
    307         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestReadOnlyMapLike = WTFMove(space); },
    308         nullptr
    309     );
     303    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     304    auto& clientSpaces = clientData.clientSubspaces();
     305    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestReadOnlyMapLike.get())
     306        return clientSpace;
     307
     308    auto& heapData = clientData.heapData();
     309    Locker locker { heapData.lock() };
     310
     311    auto& spaces = heapData.subspaces();
     312    IsoSubspace* space = spaces.m_subspaceForTestReadOnlyMapLike.get();
     313    if (!space) {
     314        Heap& heap = vm.heap;
     315        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestReadOnlyMapLike> || !JSTestReadOnlyMapLike::needsDestruction);
     316        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestReadOnlyMapLike>)
     317            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestReadOnlyMapLike);
     318        else
     319            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestReadOnlyMapLike);
     320        spaces.m_subspaceForTestReadOnlyMapLike = std::unique_ptr<IsoSubspace>(space);
     321IGNORE_WARNINGS_BEGIN("unreachable-code")
     322IGNORE_WARNINGS_BEGIN("tautological-compare")
     323        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestReadOnlyMapLike::visitOutputConstraints;
     324        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     325        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     326            heapData.outputConstraintSpaces().append(space);
     327IGNORE_WARNINGS_END
     328IGNORE_WARNINGS_END
     329    }
     330
     331    clientSpaces.m_clientSubspaceForTestReadOnlyMapLike = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     332    return clientSpaces.m_clientSubspaceForTestReadOnlyMapLike.get();
    310333}
    311334

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestReadOnlySetLike.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    280280JSC::GCClient::IsoSubspace* JSTestReadOnlySetLike::subspaceForImpl(JSC::VM& vm)
    281281{
    282     return subspaceForImpl<JSTestReadOnlySetLike, UseCustomHeapCellType::No>(vm,
    283         [] (auto& spaces) { return spaces.m_clientSubspaceForTestReadOnlySetLike.get(); },
    284         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestReadOnlySetLike = WTFMove(space); },
    285         [] (auto& spaces) { return spaces.m_subspaceForTestReadOnlySetLike.get(); },
    286         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestReadOnlySetLike = WTFMove(space); },
    287         nullptr
    288     );
     282    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     283    auto& clientSpaces = clientData.clientSubspaces();
     284    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestReadOnlySetLike.get())
     285        return clientSpace;
     286
     287    auto& heapData = clientData.heapData();
     288    Locker locker { heapData.lock() };
     289
     290    auto& spaces = heapData.subspaces();
     291    IsoSubspace* space = spaces.m_subspaceForTestReadOnlySetLike.get();
     292    if (!space) {
     293        Heap& heap = vm.heap;
     294        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestReadOnlySetLike> || !JSTestReadOnlySetLike::needsDestruction);
     295        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestReadOnlySetLike>)
     296            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestReadOnlySetLike);
     297        else
     298            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestReadOnlySetLike);
     299        spaces.m_subspaceForTestReadOnlySetLike = std::unique_ptr<IsoSubspace>(space);
     300IGNORE_WARNINGS_BEGIN("unreachable-code")
     301IGNORE_WARNINGS_BEGIN("tautological-compare")
     302        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestReadOnlySetLike::visitOutputConstraints;
     303        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     304        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     305            heapData.outputConstraintSpaces().append(space);
     306IGNORE_WARNINGS_END
     307IGNORE_WARNINGS_END
     308    }
     309
     310    clientSpaces.m_clientSubspaceForTestReadOnlySetLike = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     311    return clientSpaces.m_clientSubspaceForTestReadOnlySetLike.get();
    289312}
    290313

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestReportExtraMemoryCost.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    167167JSC::GCClient::IsoSubspace* JSTestReportExtraMemoryCost::subspaceForImpl(JSC::VM& vm)
    168168{
    169     return subspaceForImpl<JSTestReportExtraMemoryCost, UseCustomHeapCellType::No>(vm,
    170         [] (auto& spaces) { return spaces.m_clientSubspaceForTestReportExtraMemoryCost.get(); },
    171         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestReportExtraMemoryCost = WTFMove(space); },
    172         [] (auto& spaces) { return spaces.m_subspaceForTestReportExtraMemoryCost.get(); },
    173         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestReportExtraMemoryCost = WTFMove(space); },
    174         nullptr
    175     );
     169    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     170    auto& clientSpaces = clientData.clientSubspaces();
     171    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestReportExtraMemoryCost.get())
     172        return clientSpace;
     173
     174    auto& heapData = clientData.heapData();
     175    Locker locker { heapData.lock() };
     176
     177    auto& spaces = heapData.subspaces();
     178    IsoSubspace* space = spaces.m_subspaceForTestReportExtraMemoryCost.get();
     179    if (!space) {
     180        Heap& heap = vm.heap;
     181        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestReportExtraMemoryCost> || !JSTestReportExtraMemoryCost::needsDestruction);
     182        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestReportExtraMemoryCost>)
     183            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestReportExtraMemoryCost);
     184        else
     185            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestReportExtraMemoryCost);
     186        spaces.m_subspaceForTestReportExtraMemoryCost = std::unique_ptr<IsoSubspace>(space);
     187IGNORE_WARNINGS_BEGIN("unreachable-code")
     188IGNORE_WARNINGS_BEGIN("tautological-compare")
     189        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestReportExtraMemoryCost::visitOutputConstraints;
     190        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     191        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     192            heapData.outputConstraintSpaces().append(space);
     193IGNORE_WARNINGS_END
     194IGNORE_WARNINGS_END
     195    }
     196
     197    clientSpaces.m_clientSubspaceForTestReportExtraMemoryCost = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     198    return clientSpaces.m_clientSubspaceForTestReportExtraMemoryCost.get();
    176199}
    177200

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp

    r290188 r290193  
    2626
    2727#include "ActiveDOMObject.h"
    28 #include "ExtendedDOMClientIsoSubspaces.h"
    29 #include "ExtendedDOMIsoSubspaces.h"
     28#include "DOMClientIsoSubspaces.h"
     29#include "DOMIsoSubspaces.h"
    3030#include "IDLTypes.h"
    3131#include "JSDOMAttribute.h"
    … …  
    345345JSC::GCClient::IsoSubspace* JSTestSerializedScriptValueInterface::subspaceForImpl(JSC::VM& vm)
    346346{
    347     return subspaceForImpl<JSTestSerializedScriptValueInterface, UseCustomHeapCellType::No>(vm,
    348         [] (auto& spaces) { return spaces.m_clientSubspaceForTestSerializedScriptValueInterface.get(); },
    349         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestSerializedScriptValueInterface = WTFMove(space); },
    350         [] (auto& spaces) { return spaces.m_subspaceForTestSerializedScriptValueInterface.get(); },
    351         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestSerializedScriptValueInterface = WTFMove(space); },
    352         nullptr
    353     );
     347    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     348    auto& clientSpaces = clientData.clientSubspaces();
     349    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestSerializedScriptValueInterface.get())
     350        return clientSpace;
     351
     352    auto& heapData = clientData.heapData();
     353    Locker locker { heapData.lock() };
     354
     355    auto& spaces = heapData.subspaces();
     356    IsoSubspace* space = spaces.m_subspaceForTestSerializedScriptValueInterface.get();
     357    if (!space) {
     358        Heap& heap = vm.heap;
     359        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerializedScriptValueInterface> || !JSTestSerializedScriptValueInterface::needsDestruction);
     360        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerializedScriptValueInterface>)
     361            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestSerializedScriptValueInterface);
     362        else
     363            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestSerializedScriptValueInterface);
     364        spaces.m_subspaceForTestSerializedScriptValueInterface = std::unique_ptr<IsoSubspace>(space);
     365IGNORE_WARNINGS_BEGIN("unreachable-code")
     366IGNORE_WARNINGS_BEGIN("tautological-compare")
     367        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestSerializedScriptValueInterface::visitOutputConstraints;
     368        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     369        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     370            heapData.outputConstraintSpaces().append(space);
     371IGNORE_WARNINGS_END
     372IGNORE_WARNINGS_END
     373    }
     374
     375    clientSpaces.m_clientSubspaceForTestSerializedScriptValueInterface = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     376    return clientSpaces.m_clientSubspaceForTestSerializedScriptValueInterface.get();
    354377}
    355378

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestSetLike.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    338338JSC::GCClient::IsoSubspace* JSTestSetLike::subspaceForImpl(JSC::VM& vm)
    339339{
    340     return subspaceForImpl<JSTestSetLike, UseCustomHeapCellType::No>(vm,
    341         [] (auto& spaces) { return spaces.m_clientSubspaceForTestSetLike.get(); },
    342         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestSetLike = WTFMove(space); },
    343         [] (auto& spaces) { return spaces.m_subspaceForTestSetLike.get(); },
    344         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestSetLike = WTFMove(space); },
    345         nullptr
    346     );
     340    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     341    auto& clientSpaces = clientData.clientSubspaces();
     342    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestSetLike.get())
     343        return clientSpace;
     344
     345    auto& heapData = clientData.heapData();
     346    Locker locker { heapData.lock() };
     347
     348    auto& spaces = heapData.subspaces();
     349    IsoSubspace* space = spaces.m_subspaceForTestSetLike.get();
     350    if (!space) {
     351        Heap& heap = vm.heap;
     352        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestSetLike> || !JSTestSetLike::needsDestruction);
     353        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSetLike>)
     354            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestSetLike);
     355        else
     356            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestSetLike);
     357        spaces.m_subspaceForTestSetLike = std::unique_ptr<IsoSubspace>(space);
     358IGNORE_WARNINGS_BEGIN("unreachable-code")
     359IGNORE_WARNINGS_BEGIN("tautological-compare")
     360        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestSetLike::visitOutputConstraints;
     361        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     362        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     363            heapData.outputConstraintSpaces().append(space);
     364IGNORE_WARNINGS_END
     365IGNORE_WARNINGS_END
     366    }
     367
     368    clientSpaces.m_clientSubspaceForTestSetLike = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     369    return clientSpaces.m_clientSubspaceForTestSetLike.get();
    347370}
    348371

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestSetLikeWithOverriddenOperations.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAttribute.h"
    … …  
    350350JSC::GCClient::IsoSubspace* JSTestSetLikeWithOverriddenOperations::subspaceForImpl(JSC::VM& vm)
    351351{
    352     return subspaceForImpl<JSTestSetLikeWithOverriddenOperations, UseCustomHeapCellType::No>(vm,
    353         [] (auto& spaces) { return spaces.m_clientSubspaceForTestSetLikeWithOverriddenOperations.get(); },
    354         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestSetLikeWithOverriddenOperations = WTFMove(space); },
    355         [] (auto& spaces) { return spaces.m_subspaceForTestSetLikeWithOverriddenOperations.get(); },
    356         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestSetLikeWithOverriddenOperations = WTFMove(space); },
    357         nullptr
    358     );
     352    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     353    auto& clientSpaces = clientData.clientSubspaces();
     354    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestSetLikeWithOverriddenOperations.get())
     355        return clientSpace;
     356
     357    auto& heapData = clientData.heapData();
     358    Locker locker { heapData.lock() };
     359
     360    auto& spaces = heapData.subspaces();
     361    IsoSubspace* space = spaces.m_subspaceForTestSetLikeWithOverriddenOperations.get();
     362    if (!space) {
     363        Heap& heap = vm.heap;
     364        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestSetLikeWithOverriddenOperations> || !JSTestSetLikeWithOverriddenOperations::needsDestruction);
     365        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSetLikeWithOverriddenOperations>)
     366            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestSetLikeWithOverriddenOperations);
     367        else
     368            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestSetLikeWithOverriddenOperations);
     369        spaces.m_subspaceForTestSetLikeWithOverriddenOperations = std::unique_ptr<IsoSubspace>(space);
     370IGNORE_WARNINGS_BEGIN("unreachable-code")
     371IGNORE_WARNINGS_BEGIN("tautological-compare")
     372        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestSetLikeWithOverriddenOperations::visitOutputConstraints;
     373        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     374        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     375            heapData.outputConstraintSpaces().append(space);
     376IGNORE_WARNINGS_END
     377IGNORE_WARNINGS_END
     378    }
     379
     380    clientSpaces.m_clientSubspaceForTestSetLikeWithOverriddenOperations = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     381    return clientSpaces.m_clientSubspaceForTestSetLikeWithOverriddenOperations.get();
    359382}
    360383

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifier.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    188188JSC::GCClient::IsoSubspace* JSTestStringifier::subspaceForImpl(JSC::VM& vm)
    189189{
    190     return subspaceForImpl<JSTestStringifier, UseCustomHeapCellType::No>(vm,
    191         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifier.get(); },
    192         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifier = WTFMove(space); },
    193         [] (auto& spaces) { return spaces.m_subspaceForTestStringifier.get(); },
    194         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifier = WTFMove(space); },
    195         nullptr
    196     );
     190    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     191    auto& clientSpaces = clientData.clientSubspaces();
     192    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifier.get())
     193        return clientSpace;
     194
     195    auto& heapData = clientData.heapData();
     196    Locker locker { heapData.lock() };
     197
     198    auto& spaces = heapData.subspaces();
     199    IsoSubspace* space = spaces.m_subspaceForTestStringifier.get();
     200    if (!space) {
     201        Heap& heap = vm.heap;
     202        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifier> || !JSTestStringifier::needsDestruction);
     203        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifier>)
     204            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifier);
     205        else
     206            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifier);
     207        spaces.m_subspaceForTestStringifier = std::unique_ptr<IsoSubspace>(space);
     208IGNORE_WARNINGS_BEGIN("unreachable-code")
     209IGNORE_WARNINGS_BEGIN("tautological-compare")
     210        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifier::visitOutputConstraints;
     211        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     212        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     213            heapData.outputConstraintSpaces().append(space);
     214IGNORE_WARNINGS_END
     215IGNORE_WARNINGS_END
     216    }
     217
     218    clientSpaces.m_clientSubspaceForTestStringifier = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     219    return clientSpaces.m_clientSubspaceForTestStringifier.get();
    197220}
    198221

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifierAnonymousOperation.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    188188JSC::GCClient::IsoSubspace* JSTestStringifierAnonymousOperation::subspaceForImpl(JSC::VM& vm)
    189189{
    190     return subspaceForImpl<JSTestStringifierAnonymousOperation, UseCustomHeapCellType::No>(vm,
    191         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifierAnonymousOperation.get(); },
    192         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifierAnonymousOperation = WTFMove(space); },
    193         [] (auto& spaces) { return spaces.m_subspaceForTestStringifierAnonymousOperation.get(); },
    194         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifierAnonymousOperation = WTFMove(space); },
    195         nullptr
    196     );
     190    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     191    auto& clientSpaces = clientData.clientSubspaces();
     192    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifierAnonymousOperation.get())
     193        return clientSpace;
     194
     195    auto& heapData = clientData.heapData();
     196    Locker locker { heapData.lock() };
     197
     198    auto& spaces = heapData.subspaces();
     199    IsoSubspace* space = spaces.m_subspaceForTestStringifierAnonymousOperation.get();
     200    if (!space) {
     201        Heap& heap = vm.heap;
     202        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierAnonymousOperation> || !JSTestStringifierAnonymousOperation::needsDestruction);
     203        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierAnonymousOperation>)
     204            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifierAnonymousOperation);
     205        else
     206            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifierAnonymousOperation);
     207        spaces.m_subspaceForTestStringifierAnonymousOperation = std::unique_ptr<IsoSubspace>(space);
     208IGNORE_WARNINGS_BEGIN("unreachable-code")
     209IGNORE_WARNINGS_BEGIN("tautological-compare")
     210        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifierAnonymousOperation::visitOutputConstraints;
     211        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     212        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     213            heapData.outputConstraintSpaces().append(space);
     214IGNORE_WARNINGS_END
     215IGNORE_WARNINGS_END
     216    }
     217
     218    clientSpaces.m_clientSubspaceForTestStringifierAnonymousOperation = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     219    return clientSpaces.m_clientSubspaceForTestStringifierAnonymousOperation.get();
    197220}
    198221

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifierNamedOperation.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    205205JSC::GCClient::IsoSubspace* JSTestStringifierNamedOperation::subspaceForImpl(JSC::VM& vm)
    206206{
    207     return subspaceForImpl<JSTestStringifierNamedOperation, UseCustomHeapCellType::No>(vm,
    208         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifierNamedOperation.get(); },
    209         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifierNamedOperation = WTFMove(space); },
    210         [] (auto& spaces) { return spaces.m_subspaceForTestStringifierNamedOperation.get(); },
    211         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifierNamedOperation = WTFMove(space); },
    212         nullptr
    213     );
     207    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     208    auto& clientSpaces = clientData.clientSubspaces();
     209    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifierNamedOperation.get())
     210        return clientSpace;
     211
     212    auto& heapData = clientData.heapData();
     213    Locker locker { heapData.lock() };
     214
     215    auto& spaces = heapData.subspaces();
     216    IsoSubspace* space = spaces.m_subspaceForTestStringifierNamedOperation.get();
     217    if (!space) {
     218        Heap& heap = vm.heap;
     219        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierNamedOperation> || !JSTestStringifierNamedOperation::needsDestruction);
     220        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierNamedOperation>)
     221            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifierNamedOperation);
     222        else
     223            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifierNamedOperation);
     224        spaces.m_subspaceForTestStringifierNamedOperation = std::unique_ptr<IsoSubspace>(space);
     225IGNORE_WARNINGS_BEGIN("unreachable-code")
     226IGNORE_WARNINGS_BEGIN("tautological-compare")
     227        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifierNamedOperation::visitOutputConstraints;
     228        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     229        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     230            heapData.outputConstraintSpaces().append(space);
     231IGNORE_WARNINGS_END
     232IGNORE_WARNINGS_END
     233    }
     234
     235    clientSpaces.m_clientSubspaceForTestStringifierNamedOperation = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     236    return clientSpaces.m_clientSubspaceForTestStringifierNamedOperation.get();
    214237}
    215238

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifierOperationImplementedAs.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    205205JSC::GCClient::IsoSubspace* JSTestStringifierOperationImplementedAs::subspaceForImpl(JSC::VM& vm)
    206206{
    207     return subspaceForImpl<JSTestStringifierOperationImplementedAs, UseCustomHeapCellType::No>(vm,
    208         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifierOperationImplementedAs.get(); },
    209         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifierOperationImplementedAs = WTFMove(space); },
    210         [] (auto& spaces) { return spaces.m_subspaceForTestStringifierOperationImplementedAs.get(); },
    211         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifierOperationImplementedAs = WTFMove(space); },
    212         nullptr
    213     );
     207    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     208    auto& clientSpaces = clientData.clientSubspaces();
     209    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifierOperationImplementedAs.get())
     210        return clientSpace;
     211
     212    auto& heapData = clientData.heapData();
     213    Locker locker { heapData.lock() };
     214
     215    auto& spaces = heapData.subspaces();
     216    IsoSubspace* space = spaces.m_subspaceForTestStringifierOperationImplementedAs.get();
     217    if (!space) {
     218        Heap& heap = vm.heap;
     219        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierOperationImplementedAs> || !JSTestStringifierOperationImplementedAs::needsDestruction);
     220        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierOperationImplementedAs>)
     221            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifierOperationImplementedAs);
     222        else
     223            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifierOperationImplementedAs);
     224        spaces.m_subspaceForTestStringifierOperationImplementedAs = std::unique_ptr<IsoSubspace>(space);
     225IGNORE_WARNINGS_BEGIN("unreachable-code")
     226IGNORE_WARNINGS_BEGIN("tautological-compare")
     227        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifierOperationImplementedAs::visitOutputConstraints;
     228        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     229        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     230            heapData.outputConstraintSpaces().append(space);
     231IGNORE_WARNINGS_END
     232IGNORE_WARNINGS_END
     233    }
     234
     235    clientSpaces.m_clientSubspaceForTestStringifierOperationImplementedAs = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     236    return clientSpaces.m_clientSubspaceForTestStringifierOperationImplementedAs.get();
    214237}
    215238

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifierOperationNamedToString.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    188188JSC::GCClient::IsoSubspace* JSTestStringifierOperationNamedToString::subspaceForImpl(JSC::VM& vm)
    189189{
    190     return subspaceForImpl<JSTestStringifierOperationNamedToString, UseCustomHeapCellType::No>(vm,
    191         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifierOperationNamedToString.get(); },
    192         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifierOperationNamedToString = WTFMove(space); },
    193         [] (auto& spaces) { return spaces.m_subspaceForTestStringifierOperationNamedToString.get(); },
    194         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifierOperationNamedToString = WTFMove(space); },
    195         nullptr
    196     );
     190    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     191    auto& clientSpaces = clientData.clientSubspaces();
     192    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifierOperationNamedToString.get())
     193        return clientSpace;
     194
     195    auto& heapData = clientData.heapData();
     196    Locker locker { heapData.lock() };
     197
     198    auto& spaces = heapData.subspaces();
     199    IsoSubspace* space = spaces.m_subspaceForTestStringifierOperationNamedToString.get();
     200    if (!space) {
     201        Heap& heap = vm.heap;
     202        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierOperationNamedToString> || !JSTestStringifierOperationNamedToString::needsDestruction);
     203        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierOperationNamedToString>)
     204            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifierOperationNamedToString);
     205        else
     206            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifierOperationNamedToString);
     207        spaces.m_subspaceForTestStringifierOperationNamedToString = std::unique_ptr<IsoSubspace>(space);
     208IGNORE_WARNINGS_BEGIN("unreachable-code")
     209IGNORE_WARNINGS_BEGIN("tautological-compare")
     210        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifierOperationNamedToString::visitOutputConstraints;
     211        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     212        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     213            heapData.outputConstraintSpaces().append(space);
     214IGNORE_WARNINGS_END
     215IGNORE_WARNINGS_END
     216    }
     217
     218    clientSpaces.m_clientSubspaceForTestStringifierOperationNamedToString = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     219    return clientSpaces.m_clientSubspaceForTestStringifierOperationNamedToString.get();
    197220}
    198221

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifierReadOnlyAttribute.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    204204JSC::GCClient::IsoSubspace* JSTestStringifierReadOnlyAttribute::subspaceForImpl(JSC::VM& vm)
    205205{
    206     return subspaceForImpl<JSTestStringifierReadOnlyAttribute, UseCustomHeapCellType::No>(vm,
    207         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifierReadOnlyAttribute.get(); },
    208         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifierReadOnlyAttribute = WTFMove(space); },
    209         [] (auto& spaces) { return spaces.m_subspaceForTestStringifierReadOnlyAttribute.get(); },
    210         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifierReadOnlyAttribute = WTFMove(space); },
    211         nullptr
    212     );
     206    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     207    auto& clientSpaces = clientData.clientSubspaces();
     208    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifierReadOnlyAttribute.get())
     209        return clientSpace;
     210
     211    auto& heapData = clientData.heapData();
     212    Locker locker { heapData.lock() };
     213
     214    auto& spaces = heapData.subspaces();
     215    IsoSubspace* space = spaces.m_subspaceForTestStringifierReadOnlyAttribute.get();
     216    if (!space) {
     217        Heap& heap = vm.heap;
     218        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierReadOnlyAttribute> || !JSTestStringifierReadOnlyAttribute::needsDestruction);
     219        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierReadOnlyAttribute>)
     220            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifierReadOnlyAttribute);
     221        else
     222            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifierReadOnlyAttribute);
     223        spaces.m_subspaceForTestStringifierReadOnlyAttribute = std::unique_ptr<IsoSubspace>(space);
     224IGNORE_WARNINGS_BEGIN("unreachable-code")
     225IGNORE_WARNINGS_BEGIN("tautological-compare")
     226        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifierReadOnlyAttribute::visitOutputConstraints;
     227        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     228        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     229            heapData.outputConstraintSpaces().append(space);
     230IGNORE_WARNINGS_END
     231IGNORE_WARNINGS_END
     232    }
     233
     234    clientSpaces.m_clientSubspaceForTestStringifierReadOnlyAttribute = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     235    return clientSpaces.m_clientSubspaceForTestStringifierReadOnlyAttribute.get();
    213236}
    214237

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStringifierReadWriteAttribute.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    223223JSC::GCClient::IsoSubspace* JSTestStringifierReadWriteAttribute::subspaceForImpl(JSC::VM& vm)
    224224{
    225     return subspaceForImpl<JSTestStringifierReadWriteAttribute, UseCustomHeapCellType::No>(vm,
    226         [] (auto& spaces) { return spaces.m_clientSubspaceForTestStringifierReadWriteAttribute.get(); },
    227         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestStringifierReadWriteAttribute = WTFMove(space); },
    228         [] (auto& spaces) { return spaces.m_subspaceForTestStringifierReadWriteAttribute.get(); },
    229         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestStringifierReadWriteAttribute = WTFMove(space); },
    230         nullptr
    231     );
     225    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     226    auto& clientSpaces = clientData.clientSubspaces();
     227    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestStringifierReadWriteAttribute.get())
     228        return clientSpace;
     229
     230    auto& heapData = clientData.heapData();
     231    Locker locker { heapData.lock() };
     232
     233    auto& spaces = heapData.subspaces();
     234    IsoSubspace* space = spaces.m_subspaceForTestStringifierReadWriteAttribute.get();
     235    if (!space) {
     236        Heap& heap = vm.heap;
     237        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierReadWriteAttribute> || !JSTestStringifierReadWriteAttribute::needsDestruction);
     238        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierReadWriteAttribute>)
     239            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestStringifierReadWriteAttribute);
     240        else
     241            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestStringifierReadWriteAttribute);
     242        spaces.m_subspaceForTestStringifierReadWriteAttribute = std::unique_ptr<IsoSubspace>(space);
     243IGNORE_WARNINGS_BEGIN("unreachable-code")
     244IGNORE_WARNINGS_BEGIN("tautological-compare")
     245        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestStringifierReadWriteAttribute::visitOutputConstraints;
     246        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     247        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     248            heapData.outputConstraintSpaces().append(space);
     249IGNORE_WARNINGS_END
     250IGNORE_WARNINGS_END
     251    }
     252
     253    clientSpaces.m_clientSubspaceForTestStringifierReadWriteAttribute = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     254    return clientSpaces.m_clientSubspaceForTestStringifierReadWriteAttribute.get();
    232255}
    233256

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestTaggedWrapper.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMBinding.h"
    2828#include "JSDOMConstructorNotConstructable.h"
    … …  
    166166JSC::GCClient::IsoSubspace* JSTestTaggedWrapper::subspaceForImpl(JSC::VM& vm)
    167167{
    168     return subspaceForImpl<JSTestTaggedWrapper, UseCustomHeapCellType::No>(vm,
    169         [] (auto& spaces) { return spaces.m_clientSubspaceForTestTaggedWrapper.get(); },
    170         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestTaggedWrapper = WTFMove(space); },
    171         [] (auto& spaces) { return spaces.m_subspaceForTestTaggedWrapper.get(); },
    172         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestTaggedWrapper = WTFMove(space); },
    173         nullptr
    174     );
     168    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     169    auto& clientSpaces = clientData.clientSubspaces();
     170    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestTaggedWrapper.get())
     171        return clientSpace;
     172
     173    auto& heapData = clientData.heapData();
     174    Locker locker { heapData.lock() };
     175
     176    auto& spaces = heapData.subspaces();
     177    IsoSubspace* space = spaces.m_subspaceForTestTaggedWrapper.get();
     178    if (!space) {
     179        Heap& heap = vm.heap;
     180        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestTaggedWrapper> || !JSTestTaggedWrapper::needsDestruction);
     181        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestTaggedWrapper>)
     182            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestTaggedWrapper);
     183        else
     184            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestTaggedWrapper);
     185        spaces.m_subspaceForTestTaggedWrapper = std::unique_ptr<IsoSubspace>(space);
     186IGNORE_WARNINGS_BEGIN("unreachable-code")
     187IGNORE_WARNINGS_BEGIN("tautological-compare")
     188        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestTaggedWrapper::visitOutputConstraints;
     189        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     190        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     191            heapData.outputConstraintSpaces().append(space);
     192IGNORE_WARNINGS_END
     193IGNORE_WARNINGS_END
     194    }
     195
     196    clientSpaces.m_clientSubspaceForTestTaggedWrapper = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     197    return clientSpaces.m_clientSubspaceForTestTaggedWrapper.get();
    175198}
    176199

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestTypedefs.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "IDLTypes.h"
    2828#include "JSDOMAttribute.h"
    … …  
    776776JSC::GCClient::IsoSubspace* JSTestTypedefs::subspaceForImpl(JSC::VM& vm)
    777777{
    778     return subspaceForImpl<JSTestTypedefs, UseCustomHeapCellType::No>(vm,
    779         [] (auto& spaces) { return spaces.m_clientSubspaceForTestTypedefs.get(); },
    780         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForTestTypedefs = WTFMove(space); },
    781         [] (auto& spaces) { return spaces.m_subspaceForTestTypedefs.get(); },
    782         [] (auto& spaces, auto&& space) { spaces.m_subspaceForTestTypedefs = WTFMove(space); },
    783         nullptr
    784     );
     778    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     779    auto& clientSpaces = clientData.clientSubspaces();
     780    if (auto* clientSpace = clientSpaces.m_clientSubspaceForTestTypedefs.get())
     781        return clientSpace;
     782
     783    auto& heapData = clientData.heapData();
     784    Locker locker { heapData.lock() };
     785
     786    auto& spaces = heapData.subspaces();
     787    IsoSubspace* space = spaces.m_subspaceForTestTypedefs.get();
     788    if (!space) {
     789        Heap& heap = vm.heap;
     790        static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestTypedefs> || !JSTestTypedefs::needsDestruction);
     791        if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestTypedefs>)
     792            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.destructibleObjectHeapCellType, JSTestTypedefs);
     793        else
     794            space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heap.cellHeapCellType, JSTestTypedefs);
     795        spaces.m_subspaceForTestTypedefs = std::unique_ptr<IsoSubspace>(space);
     796IGNORE_WARNINGS_BEGIN("unreachable-code")
     797IGNORE_WARNINGS_BEGIN("tautological-compare")
     798        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSTestTypedefs::visitOutputConstraints;
     799        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     800        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     801            heapData.outputConstraintSpaces().append(space);
     802IGNORE_WARNINGS_END
     803IGNORE_WARNINGS_END
     804    }
     805
     806    clientSpaces.m_clientSubspaceForTestTypedefs = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     807    return clientSpaces.m_clientSubspaceForTestTypedefs.get();
    785808}
    786809

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSWorkerGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    247247JSC::GCClient::IsoSubspace* JSWorkerGlobalScope::subspaceForImpl(JSC::VM& vm)
    248248{
    249     return subspaceForImpl<JSWorkerGlobalScope, UseCustomHeapCellType::Yes>(vm,
    250         [] (auto& spaces) { return spaces.m_clientSubspaceForWorkerGlobalScope.get(); },
    251         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForWorkerGlobalScope = WTFMove(space); },
    252         [] (auto& spaces) { return spaces.m_subspaceForWorkerGlobalScope.get(); },
    253         [] (auto& spaces, auto&& space) { spaces.m_subspaceForWorkerGlobalScope = WTFMove(space); },
    254         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSWorkerGlobalScope; }
    255     );
     249    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     250    auto& clientSpaces = clientData.clientSubspaces();
     251    if (auto* clientSpace = clientSpaces.m_clientSubspaceForWorkerGlobalScope.get())
     252        return clientSpace;
     253
     254    auto& heapData = clientData.heapData();
     255    Locker locker { heapData.lock() };
     256
     257    auto& spaces = heapData.subspaces();
     258    IsoSubspace* space = spaces.m_subspaceForWorkerGlobalScope.get();
     259    if (!space) {
     260        Heap& heap = vm.heap;
     261        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSWorkerGlobalScope, JSWorkerGlobalScope);
     262        spaces.m_subspaceForWorkerGlobalScope = std::unique_ptr<IsoSubspace>(space);
     263IGNORE_WARNINGS_BEGIN("unreachable-code")
     264IGNORE_WARNINGS_BEGIN("tautological-compare")
     265        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSWorkerGlobalScope::visitOutputConstraints;
     266        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     267        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     268            heapData.outputConstraintSpaces().append(space);
     269IGNORE_WARNINGS_END
     270IGNORE_WARNINGS_END
     271    }
     272
     273    clientSpaces.m_clientSubspaceForWorkerGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     274    return clientSpaces.m_clientSubspaceForWorkerGlobalScope.get();
    256275}
    257276

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSWorkletGlobalScope.cpp

    r290188 r290193  
    2323
    2424#include "ActiveDOMObject.h"
    25 #include "ExtendedDOMClientIsoSubspaces.h"
    26 #include "ExtendedDOMIsoSubspaces.h"
     25#include "DOMClientIsoSubspaces.h"
     26#include "DOMIsoSubspaces.h"
    2727#include "JSDOMAttribute.h"
    2828#include "JSDOMBinding.h"
    … …  
    161161JSC::GCClient::IsoSubspace* JSWorkletGlobalScope::subspaceForImpl(JSC::VM& vm)
    162162{
    163     return subspaceForImpl<JSWorkletGlobalScope, UseCustomHeapCellType::Yes>(vm,
    164         [] (auto& spaces) { return spaces.m_clientSubspaceForWorkletGlobalScope.get(); },
    165         [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForWorkletGlobalScope = WTFMove(space); },
    166         [] (auto& spaces) { return spaces.m_subspaceForWorkletGlobalScope.get(); },
    167         [] (auto& spaces, auto&& space) { spaces.m_subspaceForWorkletGlobalScope = WTFMove(space); },
    168         [] (auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSWorkletGlobalScope; }
    169     );
     163    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
     164    auto& clientSpaces = clientData.clientSubspaces();
     165    if (auto* clientSpace = clientSpaces.m_clientSubspaceForWorkletGlobalScope.get())
     166        return clientSpace;
     167
     168    auto& heapData = clientData.heapData();
     169    Locker locker { heapData.lock() };
     170
     171    auto& spaces = heapData.subspaces();
     172    IsoSubspace* space = spaces.m_subspaceForWorkletGlobalScope.get();
     173    if (!space) {
     174        Heap& heap = vm.heap;
     175        space = new IsoSubspace ISO_SUBSPACE_INIT(heap, heapData.m_heapCellTypeForJSWorkletGlobalScope, JSWorkletGlobalScope);
     176        spaces.m_subspaceForWorkletGlobalScope = std::unique_ptr<IsoSubspace>(space);
     177IGNORE_WARNINGS_BEGIN("unreachable-code")
     178IGNORE_WARNINGS_BEGIN("tautological-compare")
     179        void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSWorkletGlobalScope::visitOutputConstraints;
     180        void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
     181        if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
     182            heapData.outputConstraintSpaces().append(space);
     183IGNORE_WARNINGS_END
     184IGNORE_WARNINGS_END
     185    }
     186
     187    clientSpaces.m_clientSubspaceForWorkletGlobalScope = makeUnique<JSC::GCClient::IsoSubspace>(*space);
     188    return clientSpaces.m_clientSubspaceForWorkletGlobalScope.get();
    170189}
    171190
Note: See TracChangeset for help on using the changeset viewer.