⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 243467 in webkit


Ignore:
Timestamp:
Mar 25, 2019, 3:40:58 PM (7 years ago)
Author:
ysuzuki@apple.com
Message:

Heap::isMarked and friends should be instance methods
​https://bugs.webkit.org/show_bug.cgi?id=179988

Reviewed by Saam Barati.

Almost all the callers of Heap::isMarked have VM& reference. We should make Heap::isMarked instance function instead of static function
so that we do not need to look up Heap from the cell.

  • API/JSAPIWrapperObject.mm:

(JSAPIWrapperObjectHandleOwner::isReachableFromOpaqueRoots):

  • API/JSMarkingConstraintPrivate.cpp:

(JSC::isMarked):

  • API/glib/JSAPIWrapperObjectGLib.cpp:

(JSAPIWrapperObjectHandleOwner::isReachableFromOpaqueRoots):

  • builtins/BuiltinExecutables.cpp:

(JSC::BuiltinExecutables::finalizeUnconditionally):

  • bytecode/AccessCase.cpp:

(JSC::AccessCase::visitWeak const):
(JSC::AccessCase::propagateTransitions const):

  • bytecode/CallLinkInfo.cpp:

(JSC::CallLinkInfo::visitWeak):

  • bytecode/CallLinkStatus.cpp:

(JSC::CallLinkStatus::finalize):

  • bytecode/CallLinkStatus.h:
  • bytecode/CallVariant.cpp:

(JSC::CallVariant::finalize):

  • bytecode/CallVariant.h:
  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::shouldJettisonDueToWeakReference):
(JSC::CodeBlock::shouldJettisonDueToOldAge):
(JSC::shouldMarkTransition):
(JSC::CodeBlock::propagateTransitions):
(JSC::CodeBlock::determineLiveness):
(JSC::CodeBlock::finalizeLLIntInlineCaches):
(JSC::CodeBlock::finalizeUnconditionally):
(JSC::CodeBlock::jettison):

  • bytecode/CodeBlock.h:
  • bytecode/ExecutableToCodeBlockEdge.cpp:

(JSC::ExecutableToCodeBlockEdge::visitChildren):
(JSC::ExecutableToCodeBlockEdge::finalizeUnconditionally):
(JSC::ExecutableToCodeBlockEdge::runConstraint):

  • bytecode/GetByIdStatus.cpp:

(JSC::GetByIdStatus::finalize):

  • bytecode/GetByIdStatus.h:
  • bytecode/GetByIdVariant.cpp:

(JSC::GetByIdVariant::finalize):

  • bytecode/GetByIdVariant.h:
  • bytecode/InByIdStatus.cpp:

(JSC::InByIdStatus::finalize):

  • bytecode/InByIdStatus.h:
  • bytecode/InByIdVariant.cpp:

(JSC::InByIdVariant::finalize):

  • bytecode/InByIdVariant.h:
  • bytecode/ObjectPropertyCondition.cpp:

(JSC::ObjectPropertyCondition::isStillLive const):

  • bytecode/ObjectPropertyCondition.h:
  • bytecode/ObjectPropertyConditionSet.cpp:

(JSC::ObjectPropertyConditionSet::areStillLive const):

  • bytecode/ObjectPropertyConditionSet.h:
  • bytecode/PolymorphicAccess.cpp:

(JSC::PolymorphicAccess::visitWeak const):

  • bytecode/PropertyCondition.cpp:

(JSC::PropertyCondition::isStillLive const):

  • bytecode/PropertyCondition.h:
  • bytecode/PutByIdStatus.cpp:

(JSC::PutByIdStatus::finalize):

  • bytecode/PutByIdStatus.h:
  • bytecode/PutByIdVariant.cpp:

(JSC::PutByIdVariant::finalize):

  • bytecode/PutByIdVariant.h:
  • bytecode/RecordedStatuses.cpp:

(JSC::RecordedStatuses::finalizeWithoutDeleting):
(JSC::RecordedStatuses::finalize):

  • bytecode/RecordedStatuses.h:
  • bytecode/StructureSet.cpp:

(JSC::StructureSet::isStillAlive const):

  • bytecode/StructureSet.h:
  • bytecode/StructureStubInfo.cpp:

(JSC::StructureStubInfo::visitWeakReferences):

  • dfg/DFGPlan.cpp:

(JSC::DFG::Plan::finalizeInGC):
(JSC::DFG::Plan::isKnownToBeLiveDuringGC):

  • heap/GCIncomingRefCounted.h:
  • heap/GCIncomingRefCountedInlines.h:

(JSC::GCIncomingRefCounted<T>::filterIncomingReferences):

  • heap/GCIncomingRefCountedSet.h:
  • heap/GCIncomingRefCountedSetInlines.h:

(JSC::GCIncomingRefCountedSet<T>::lastChanceToFinalize):
(JSC::GCIncomingRefCountedSet<T>::sweep):
(JSC::GCIncomingRefCountedSet<T>::removeAll): Deleted.
(JSC::GCIncomingRefCountedSet<T>::removeDead): Deleted.

  • heap/Heap.cpp:

(JSC::Heap::addToRememberedSet):
(JSC::Heap::runEndPhase):
(JSC::Heap::sweepArrayBuffers):
(JSC::Heap::addCoreConstraints):

  • heap/Heap.h:
  • heap/HeapInlines.h:

(JSC::Heap::isMarked):

  • heap/HeapSnapshotBuilder.cpp:

(JSC::HeapSnapshotBuilder::appendNode):

  • heap/SlotVisitor.cpp:

(JSC::SlotVisitor::appendToMarkStack):
(JSC::SlotVisitor::visitChildren):

  • jit/PolymorphicCallStubRoutine.cpp:

(JSC::PolymorphicCallStubRoutine::visitWeak):

  • runtime/ErrorInstance.cpp:

(JSC::ErrorInstance::finalizeUnconditionally):

  • runtime/InferredValueInlines.h:

(JSC::InferredValue::finalizeUnconditionally):

  • runtime/StackFrame.h:

(JSC::StackFrame::isMarked const):

  • runtime/Structure.cpp:

(JSC::Structure::isCheapDuringGC):
(JSC::Structure::markIfCheap):

  • runtime/Structure.h:
  • runtime/TypeProfiler.cpp:

(JSC::TypeProfiler::invalidateTypeSetCache):

  • runtime/TypeProfiler.h:
  • runtime/TypeSet.cpp:

(JSC::TypeSet::invalidateCache):

  • runtime/TypeSet.h:
  • runtime/WeakMapImpl.cpp:

(JSC::WeakMapImpl<WeakMapBucket<WeakMapBucketDataKeyValue>>::visitOutputConstraints):

  • runtime/WeakMapImplInlines.h:

(JSC::WeakMapImpl<WeakMapBucket>::finalizeUnconditionally):

Location:
trunk/Source/JavaScriptCore
Files:
60 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/JSAPIWrapperObject.mm

    r235271 r243467  
    6464    if (!wrapperObject->wrappedObject())
    6565        return false;
    66     return JSC::Heap::isMarked(wrapperObject->structure()->globalObject()) && visitor.containsOpaqueRoot(wrapperObject->wrappedObject());
     66    return visitor.vm().heap.isMarked(wrapperObject->structure()->globalObject()) && visitor.containsOpaqueRoot(wrapperObject->wrappedObject());
    6767}
    6868

  • trunk/Source/JavaScriptCore/API/JSMarkingConstraintPrivate.cpp

    r225524 r243467  
    4141};
    4242
    43 bool isMarked(JSMarkerRef, JSObjectRef objectRef)
     43bool isMarked(JSMarkerRef markerRef, JSObjectRef objectRef)
    4444{
    4545    if (!objectRef)
    4646        return true; // Null is an immortal object.
    4747   
    48     return Heap::isMarked(toJS(objectRef));
     48    return static_cast<Marker*>(markerRef)->visitor->vm().heap.isMarked(toJS(objectRef));
    4949}
    5050

  • trunk/Source/JavaScriptCore/API/glib/JSAPIWrapperObjectGLib.cpp

    r235271 r243467  
    6363    if (!wrapperObject->wrappedObject())
    6464        return false;
    65     return JSC::Heap::isMarked(wrapperObject->structure()->globalObject()) && visitor.containsOpaqueRoot(wrapperObject->wrappedObject());
     65    return visitor.vm().heap.isMarked(wrapperObject->structure()->globalObject()) && visitor.containsOpaqueRoot(wrapperObject->wrappedObject());
    6666}
    6767

  • trunk/Source/JavaScriptCore/ChangeLog

    r243448 r243467  
     12019-03-25  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        Heap::isMarked and friends should be instance methods
     4        https://bugs.webkit.org/show_bug.cgi?id=179988
     5
     6        Reviewed by Saam Barati.
     7
     8        Almost all the callers of Heap::isMarked have VM& reference. We should make Heap::isMarked instance function instead of static function
     9        so that we do not need to look up Heap from the cell.
     10
     11        * API/JSAPIWrapperObject.mm:
     12        (JSAPIWrapperObjectHandleOwner::isReachableFromOpaqueRoots):
     13        * API/JSMarkingConstraintPrivate.cpp:
     14        (JSC::isMarked):
     15        * API/glib/JSAPIWrapperObjectGLib.cpp:
     16        (JSAPIWrapperObjectHandleOwner::isReachableFromOpaqueRoots):
     17        * builtins/BuiltinExecutables.cpp:
     18        (JSC::BuiltinExecutables::finalizeUnconditionally):
     19        * bytecode/AccessCase.cpp:
     20        (JSC::AccessCase::visitWeak const):
     21        (JSC::AccessCase::propagateTransitions const):
     22        * bytecode/CallLinkInfo.cpp:
     23        (JSC::CallLinkInfo::visitWeak):
     24        * bytecode/CallLinkStatus.cpp:
     25        (JSC::CallLinkStatus::finalize):
     26        * bytecode/CallLinkStatus.h:
     27        * bytecode/CallVariant.cpp:
     28        (JSC::CallVariant::finalize):
     29        * bytecode/CallVariant.h:
     30        * bytecode/CodeBlock.cpp:
     31        (JSC::CodeBlock::shouldJettisonDueToWeakReference):
     32        (JSC::CodeBlock::shouldJettisonDueToOldAge):
     33        (JSC::shouldMarkTransition):
     34        (JSC::CodeBlock::propagateTransitions):
     35        (JSC::CodeBlock::determineLiveness):
     36        (JSC::CodeBlock::finalizeLLIntInlineCaches):
     37        (JSC::CodeBlock::finalizeUnconditionally):
     38        (JSC::CodeBlock::jettison):
     39        * bytecode/CodeBlock.h:
     40        * bytecode/ExecutableToCodeBlockEdge.cpp:
     41        (JSC::ExecutableToCodeBlockEdge::visitChildren):
     42        (JSC::ExecutableToCodeBlockEdge::finalizeUnconditionally):
     43        (JSC::ExecutableToCodeBlockEdge::runConstraint):
     44        * bytecode/GetByIdStatus.cpp:
     45        (JSC::GetByIdStatus::finalize):
     46        * bytecode/GetByIdStatus.h:
     47        * bytecode/GetByIdVariant.cpp:
     48        (JSC::GetByIdVariant::finalize):
     49        * bytecode/GetByIdVariant.h:
     50        * bytecode/InByIdStatus.cpp:
     51        (JSC::InByIdStatus::finalize):
     52        * bytecode/InByIdStatus.h:
     53        * bytecode/InByIdVariant.cpp:
     54        (JSC::InByIdVariant::finalize):
     55        * bytecode/InByIdVariant.h:
     56        * bytecode/ObjectPropertyCondition.cpp:
     57        (JSC::ObjectPropertyCondition::isStillLive const):
     58        * bytecode/ObjectPropertyCondition.h:
     59        * bytecode/ObjectPropertyConditionSet.cpp:
     60        (JSC::ObjectPropertyConditionSet::areStillLive const):
     61        * bytecode/ObjectPropertyConditionSet.h:
     62        * bytecode/PolymorphicAccess.cpp:
     63        (JSC::PolymorphicAccess::visitWeak const):
     64        * bytecode/PropertyCondition.cpp:
     65        (JSC::PropertyCondition::isStillLive const):
     66        * bytecode/PropertyCondition.h:
     67        * bytecode/PutByIdStatus.cpp:
     68        (JSC::PutByIdStatus::finalize):
     69        * bytecode/PutByIdStatus.h:
     70        * bytecode/PutByIdVariant.cpp:
     71        (JSC::PutByIdVariant::finalize):
     72        * bytecode/PutByIdVariant.h:
     73        * bytecode/RecordedStatuses.cpp:
     74        (JSC::RecordedStatuses::finalizeWithoutDeleting):
     75        (JSC::RecordedStatuses::finalize):
     76        * bytecode/RecordedStatuses.h:
     77        * bytecode/StructureSet.cpp:
     78        (JSC::StructureSet::isStillAlive const):
     79        * bytecode/StructureSet.h:
     80        * bytecode/StructureStubInfo.cpp:
     81        (JSC::StructureStubInfo::visitWeakReferences):
     82        * dfg/DFGPlan.cpp:
     83        (JSC::DFG::Plan::finalizeInGC):
     84        (JSC::DFG::Plan::isKnownToBeLiveDuringGC):
     85        * heap/GCIncomingRefCounted.h:
     86        * heap/GCIncomingRefCountedInlines.h:
     87        (JSC::GCIncomingRefCounted<T>::filterIncomingReferences):
     88        * heap/GCIncomingRefCountedSet.h:
     89        * heap/GCIncomingRefCountedSetInlines.h:
     90        (JSC::GCIncomingRefCountedSet<T>::lastChanceToFinalize):
     91        (JSC::GCIncomingRefCountedSet<T>::sweep):
     92        (JSC::GCIncomingRefCountedSet<T>::removeAll): Deleted.
     93        (JSC::GCIncomingRefCountedSet<T>::removeDead): Deleted.
     94        * heap/Heap.cpp:
     95        (JSC::Heap::addToRememberedSet):
     96        (JSC::Heap::runEndPhase):
     97        (JSC::Heap::sweepArrayBuffers):
     98        (JSC::Heap::addCoreConstraints):
     99        * heap/Heap.h:
     100        * heap/HeapInlines.h:
     101        (JSC::Heap::isMarked):
     102        * heap/HeapSnapshotBuilder.cpp:
     103        (JSC::HeapSnapshotBuilder::appendNode):
     104        * heap/SlotVisitor.cpp:
     105        (JSC::SlotVisitor::appendToMarkStack):
     106        (JSC::SlotVisitor::visitChildren):
     107        * jit/PolymorphicCallStubRoutine.cpp:
     108        (JSC::PolymorphicCallStubRoutine::visitWeak):
     109        * runtime/ErrorInstance.cpp:
     110        (JSC::ErrorInstance::finalizeUnconditionally):
     111        * runtime/InferredValueInlines.h:
     112        (JSC::InferredValue::finalizeUnconditionally):
     113        * runtime/StackFrame.h:
     114        (JSC::StackFrame::isMarked const):
     115        * runtime/Structure.cpp:
     116        (JSC::Structure::isCheapDuringGC):
     117        (JSC::Structure::markIfCheap):
     118        * runtime/Structure.h:
     119        * runtime/TypeProfiler.cpp:
     120        (JSC::TypeProfiler::invalidateTypeSetCache):
     121        * runtime/TypeProfiler.h:
     122        * runtime/TypeSet.cpp:
     123        (JSC::TypeSet::invalidateCache):
     124        * runtime/TypeSet.h:
     125        * runtime/WeakMapImpl.cpp:
     126        (JSC::WeakMapImpl<WeakMapBucket<WeakMapBucketDataKeyValue>>::visitOutputConstraints):
     127        * runtime/WeakMapImplInlines.h:
     128        (JSC::WeakMapImpl<WeakMapBucket>::finalizeUnconditionally):
     129
    11302019-03-25  Keith Miller  <keith_miller@apple.com>
    2131

  • trunk/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp

    r242722 r243467  
    263263{
    264264    for (auto*& unlinkedExecutable : m_unlinkedExecutables) {
    265         if (unlinkedExecutable && !Heap::isMarked(unlinkedExecutable))
     265        if (unlinkedExecutable && !m_vm.heap.isMarked(unlinkedExecutable))
    266266            unlinkedExecutable = nullptr;
    267267    }

  • trunk/Source/JavaScriptCore/bytecode/AccessCase.cpp

    r242397 r243467  
    324324bool AccessCase::visitWeak(VM& vm) const
    325325{
    326     if (m_structure && !Heap::isMarked(m_structure.get()))
     326    if (m_structure && !vm.heap.isMarked(m_structure.get()))
    327327        return false;
    328328    if (m_polyProtoAccessChain) {
    329329        for (Structure* structure : m_polyProtoAccessChain->chain()) {
    330             if (!Heap::isMarked(structure))
     330            if (!vm.heap.isMarked(structure))
    331331                return false;
    332332        }
    333333    }
    334     if (!m_conditionSet.areStillLive())
     334    if (!m_conditionSet.areStillLive(vm))
    335335        return false;
    336336    if (isAccessor()) {
    … …  
    338338        if (accessor.callLinkInfo())
    339339            accessor.callLinkInfo()->visitWeak(vm);
    340         if (accessor.customSlotBase() && !Heap::isMarked(accessor.customSlotBase()))
     340        if (accessor.customSlotBase() && !vm.heap.isMarked(accessor.customSlotBase()))
    341341            return false;
    342342    } else if (type() == IntrinsicGetter) {
    343343        auto& intrinsic = this->as<IntrinsicGetterAccessCase>();
    344         if (intrinsic.intrinsicFunction() && !Heap::isMarked(intrinsic.intrinsicFunction()))
     344        if (intrinsic.intrinsicFunction() && !vm.heap.isMarked(intrinsic.intrinsicFunction()))
    345345            return false;
    346346    } else if (type() == ModuleNamespaceLoad) {
    347347        auto& accessCase = this->as<ModuleNamespaceAccessCase>();
    348         if (accessCase.moduleNamespaceObject() && !Heap::isMarked(accessCase.moduleNamespaceObject()))
     348        if (accessCase.moduleNamespaceObject() && !vm.heap.isMarked(accessCase.moduleNamespaceObject()))
    349349            return false;
    350         if (accessCase.moduleEnvironment() && !Heap::isMarked(accessCase.moduleEnvironment()))
     350        if (accessCase.moduleEnvironment() && !vm.heap.isMarked(accessCase.moduleEnvironment()))
    351351            return false;
    352352    } else if (type() == InstanceOfHit || type() == InstanceOfMiss) {
    353         if (as<InstanceOfAccessCase>().prototype() && !Heap::isMarked(as<InstanceOfAccessCase>().prototype()))
     353        if (as<InstanceOfAccessCase>().prototype() && !vm.heap.isMarked(as<InstanceOfAccessCase>().prototype()))
    354354            return false;
    355355    }
    … …  
    372372    switch (m_type) {
    373373    case Transition:
    374         if (Heap::isMarked(m_structure->previousID()))
     374        if (visitor.vm().heap.isMarked(m_structure->previousID()))
    375375            visitor.appendUnbarriered(m_structure.get());
    376376        else

  • trunk/Source/JavaScriptCore/bytecode/CallLinkInfo.cpp

    r234086 r243467  
    211211{
    212212    auto handleSpecificCallee = [&] (JSFunction* callee) {
    213         if (Heap::isMarked(callee->executable()))
     213        if (vm.heap.isMarked(callee->executable()))
    214214            m_hasSeenClosure = true;
    215215        else
    … …  
    229229                m_clearedByGC = true;
    230230            }
    231         } else if (!Heap::isMarked(m_calleeOrCodeBlock.get())) {
     231        } else if (!vm.heap.isMarked(m_calleeOrCodeBlock.get())) {
    232232            if (isDirect()) {
    233233                if (Options::verboseOSR()) {
    … …  
    253253            }
    254254            unlink(vm);
    255         } else if (isDirect() && !Heap::isMarked(m_lastSeenCalleeOrExecutable.get())) {
     255        } else if (isDirect() && !vm.heap.isMarked(m_lastSeenCalleeOrExecutable.get())) {
    256256            if (Options::verboseOSR()) {
    257257                dataLog(
    … …  
    265265        }
    266266    }
    267     if (!isDirect() && haveLastSeenCallee() && !Heap::isMarked(lastSeenCallee())) {
     267    if (!isDirect() && haveLastSeenCallee() && !vm.heap.isMarked(lastSeenCallee())) {
    268268        if (lastSeenCallee()->type() == JSFunctionType)
    269269            handleSpecificCallee(jsCast<JSFunction*>(lastSeenCallee()));

  • trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp

    r243232 r243467  
    419419}
    420420
    421 bool CallLinkStatus::finalize()
     421bool CallLinkStatus::finalize(VM& vm)
    422422{
    423423    for (CallVariant& variant : m_variants) {
    424         if (!variant.finalize())
     424        if (!variant.finalize(vm))
    425425            return false;
    426426    }

  • trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.h

    r234086 r243467  
    107107    unsigned maxNumArguments() const { return m_maxNumArguments; }
    108108   
    109     bool finalize();
     109    bool finalize(VM&);
    110110   
    111111    void merge(const CallLinkStatus&);

  • trunk/Source/JavaScriptCore/bytecode/CallVariant.cpp

    r237241 r243467  
    3232namespace JSC {
    3333
    34 bool CallVariant::finalize()
     34bool CallVariant::finalize(VM& vm)
    3535{
    36     if (m_callee && !Heap::isMarked(m_callee))
     36    if (m_callee && !vm.heap.isMarked(m_callee))
    3737        return false;
    3838    return true;

  • trunk/Source/JavaScriptCore/bytecode/CallVariant.h

    r241037 r243467  
    138138    }
    139139   
    140     bool finalize();
     140    bool finalize(VM&);
    141141   
    142142    bool merge(const CallVariant&);

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r243232 r243467  
    999999}
    10001000
    1001 bool CodeBlock::shouldJettisonDueToWeakReference()
     1001bool CodeBlock::shouldJettisonDueToWeakReference(VM& vm)
    10021002{
    10031003    if (!JITCode::isOptimizingJIT(jitType()))
    10041004        return false;
    1005     return !Heap::isMarked(this);
     1005    return !vm.heap.isMarked(this);
    10061006}
    10071007
    … …  
    10411041bool CodeBlock::shouldJettisonDueToOldAge(const ConcurrentJSLocker&)
    10421042{
    1043     if (Heap::isMarked(this))
     1043    if (m_vm->heap.isMarked(this))
    10441044        return false;
    10451045
    … …  
    10541054
    10551055#if ENABLE(DFG_JIT)
    1056 static bool shouldMarkTransition(DFG::WeakReferenceTransition& transition)
    1057 {
    1058     if (transition.m_codeOrigin && !Heap::isMarked(transition.m_codeOrigin.get()))
     1056static bool shouldMarkTransition(VM& vm, DFG::WeakReferenceTransition& transition)
     1057{
     1058    if (transition.m_codeOrigin && !vm.heap.isMarked(transition.m_codeOrigin.get()))
    10591059        return false;
    10601060   
    1061     if (!Heap::isMarked(transition.m_from.get()))
     1061    if (!vm.heap.isMarked(transition.m_from.get()))
    10621062        return false;
    10631063   
    … …  
    10871087                Structure* newStructure =
    10881088                    vm.heap.structureIDTable().get(newStructureID);
    1089                 if (Heap::isMarked(oldStructure))
     1089                if (vm.heap.isMarked(oldStructure))
    10901090                    visitor.appendUnbarriered(newStructure);
    10911091                continue;
    … …  
    11131113
    11141114        for (auto& transition : dfgCommon->transitions) {
    1115             if (shouldMarkTransition(transition)) {
     1115            if (shouldMarkTransition(vm, transition)) {
    11161116                // If the following three things are live, then the target of the
    11171117                // transition is also live:
    … …  
    11451145   
    11461146#if ENABLE(DFG_JIT)
    1147     if (Heap::isMarked(this))
     1147    VM& vm = *m_vm;
     1148    if (vm.heap.isMarked(this))
    11481149        return;
    11491150   
    … …  
    11611162    for (unsigned i = 0; i < dfgCommon->weakReferences.size(); ++i) {
    11621163        JSCell* reference = dfgCommon->weakReferences[i].get();
    1163         ASSERT(!jsDynamicCast<CodeBlock*>(*reference->vm(), reference));
    1164         if (!Heap::isMarked(reference)) {
     1164        ASSERT(!jsDynamicCast<CodeBlock*>(vm, reference));
     1165        if (!vm.heap.isMarked(reference)) {
    11651166            allAreLiveSoFar = false;
    11661167            break;
    … …  
    11691170    if (allAreLiveSoFar) {
    11701171        for (unsigned i = 0; i < dfgCommon->weakStructureReferences.size(); ++i) {
    1171             if (!Heap::isMarked(dfgCommon->weakStructureReferences[i].get())) {
     1172            if (!vm.heap.isMarked(dfgCommon->weakStructureReferences[i].get())) {
    11721173                allAreLiveSoFar = false;
    11731174                break;
    … …  
    11921193    const Vector<InstructionStream::Offset>& propertyAccessInstructions = m_unlinkedCode->propertyAccessInstructions();
    11931194
    1194     auto handleGetPutFromScope = [](auto& metadata) {
     1195    auto handleGetPutFromScope = [&] (auto& metadata) {
    11951196        GetPutInfo getPutInfo = metadata.m_getPutInfo;
    11961197        if (getPutInfo.resolveType() == GlobalVar || getPutInfo.resolveType() == GlobalVarWithVarInjectionChecks
    … …  
    11981199            return;
    11991200        WriteBarrierBase<Structure>& structure = metadata.m_structure;
    1200         if (!structure || Heap::isMarked(structure.get()))
     1201        if (!structure || vm.heap.isMarked(structure.get()))
    12011202            return;
    12021203        if (Options::verboseOSR())
    … …  
    12141215                break;
    12151216            StructureID oldStructureID = metadata.m_modeMetadata.defaultMode.structureID;
    1216             if (!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
     1217            if (!oldStructureID || vm.heap.isMarked(vm.heap.structureIDTable().get(oldStructureID)))
    12171218                break;
    12181219            if (Options::verboseOSR())
    … …  
    12241225            auto& metadata = curInstruction->as<OpGetByIdDirect>().metadata(this);
    12251226            StructureID oldStructureID = metadata.m_structureID;
    1226             if (!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
     1227            if (!oldStructureID || vm.heap.isMarked(vm.heap.structureIDTable().get(oldStructureID)))
    12271228                break;
    12281229            if (Options::verboseOSR())
    … …  
    12371238            StructureID newStructureID = metadata.m_newStructureID;
    12381239            StructureChain* chain = metadata.m_structureChain.get();
    1239             if ((!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
    1240                 && (!newStructureID || Heap::isMarked(vm.heap.structureIDTable().get(newStructureID)))
    1241                 && (!chain || Heap::isMarked(chain)))
     1240            if ((!oldStructureID || vm.heap.isMarked(vm.heap.structureIDTable().get(oldStructureID)))
     1241                && (!newStructureID || vm.heap.isMarked(vm.heap.structureIDTable().get(newStructureID)))
     1242                && (!chain || vm.heap.isMarked(chain)))
    12421243                break;
    12431244            if (Options::verboseOSR())
    … …  
    12551256        case op_to_this: {
    12561257            auto& metadata = curInstruction->as<OpToThis>().metadata(this);
    1257             if (!metadata.m_cachedStructure || Heap::isMarked(metadata.m_cachedStructure.get()))
     1258            if (!metadata.m_cachedStructure || vm.heap.isMarked(metadata.m_cachedStructure.get()))
    12581259                break;
    12591260            if (Options::verboseOSR())
    … …  
    12691270                break;
    12701271            JSCell* cachedFunction = cacheWriteBarrier.get();
    1271             if (Heap::isMarked(cachedFunction))
     1272            if (vm.heap.isMarked(cachedFunction))
    12721273                break;
    12731274            if (Options::verboseOSR())
    … …  
    12821283            auto& metadata = curInstruction->as<OpResolveScope>().metadata(this);
    12831284            WriteBarrierBase<SymbolTable>& symbolTable = metadata.m_symbolTable;
    1284             if (!symbolTable || Heap::isMarked(symbolTable.get()))
     1285            if (!symbolTable || vm.heap.isMarked(symbolTable.get()))
    12851286                break;
    12861287            if (Options::verboseOSR())
    … …  
    13151316        };
    13161317
    1317         if (!Heap::isMarked(std::get<0>(pair.key)))
     1318        if (!vm.heap.isMarked(std::get<0>(pair.key)))
    13181319            return clear();
    13191320
    13201321        for (const LLIntPrototypeLoadAdaptiveStructureWatchpoint* watchpoint : pair.value) {
    1321             if (!watchpoint->key().isStillLive())
     1322            if (!watchpoint->key().isStillLive(vm))
    13221323                return clear();
    13231324        }
    … …  
    13271328
    13281329    forEachLLIntCallLinkInfo([&](LLIntCallLinkInfo& callLinkInfo) {
    1329         if (callLinkInfo.isLinked() && !Heap::isMarked(callLinkInfo.callee.get())) {
     1330        if (callLinkInfo.isLinked() && !vm.heap.isMarked(callLinkInfo.callee.get())) {
    13301331            if (Options::verboseOSR())
    13311332                dataLog("Clearing LLInt call from ", *this, "\n");
    13321333            callLinkInfo.unlink();
    13331334        }
    1334         if (!!callLinkInfo.lastSeenCallee && !Heap::isMarked(callLinkInfo.lastSeenCallee.get()))
     1335        if (!!callLinkInfo.lastSeenCallee && !vm.heap.isMarked(callLinkInfo.lastSeenCallee.get()))
    13351336            callLinkInfo.lastSeenCallee.clear();
    13361337    });
    … …  
    13571358#endif
    13581359
    1359 void CodeBlock::finalizeUnconditionally(VM&)
    1360 {
     1360void CodeBlock::finalizeUnconditionally(VM& vm)
     1361{
     1362    UNUSED_PARAM(vm);
     1363
    13611364    updateAllPredictions();
    13621365   
    … …  
    13721375    if (JITCode::isOptimizingJIT(jitType())) {
    13731376        DFG::CommonData* dfgCommon = m_jitCode->dfgCommon();
    1374         dfgCommon->recordedStatuses.finalize();
     1377        dfgCommon->recordedStatuses.finalize(vm);
    13751378    }
    13761379#endif // ENABLE(DFG_JIT)
    … …  
    19531956    UNUSED_PARAM(detail);
    19541957#endif
     1958
     1959    VM& vm = *m_vm;
    19551960   
    19561961    CODEBLOCK_LOG_EVENT(this, "jettison", ("due to ", reason, ", counting = ", mode == CountReoptimization, ", detail = ", pointerDump(detail)));
    … …  
    19771982                JSCell* from = transition.m_from.get();
    19781983                JSCell* to = transition.m_to.get();
    1979                 if ((!origin || Heap::isMarked(origin)) && Heap::isMarked(from))
     1984                if ((!origin || vm.heap.isMarked(origin)) && vm.heap.isMarked(from))
    19801985                    continue;
    19811986                dataLog("    Transition under ", RawPointer(origin), ", ", RawPointer(from), " -> ", RawPointer(to), ".\n");
    … …  
    19831988            for (unsigned i = 0; i < dfgCommon->weakReferences.size(); ++i) {
    19841989                JSCell* weak = dfgCommon->weakReferences[i].get();
    1985                 if (Heap::isMarked(weak))
     1990                if (vm.heap.isMarked(weak))
    19861991                    continue;
    19871992                dataLog("    Weak reference ", RawPointer(weak), ".\n");
    … …  
    19911996#endif // ENABLE(DFG_JIT)
    19921997
    1993     VM& vm = *m_vm;
    19941998    DeferGCForAWhile deferGC(*heap());
    19951999   
    … …  
    20112015        if (!jitCode()->dfgCommon()->invalidate()) {
    20122016            // We've already been invalidated.
    2013             RELEASE_ASSERT(this != replacement() || (vm.heap.isCurrentThreadBusy() && !Heap::isMarked(ownerExecutable())));
     2017            RELEASE_ASSERT(this != replacement() || (vm.heap.isCurrentThreadBusy() && !vm.heap.isMarked(ownerExecutable())));
    20142018            return;
    20152019        }
    … …  
    20432047    // Jettison can happen during GC. We don't want to install code to a dead executable
    20442048    // because that would add a dead object to the remembered set.
    2045     if (vm.heap.isCurrentThreadBusy() && !Heap::isMarked(ownerExecutable()))
     2049    if (vm.heap.isCurrentThreadBusy() && !vm.heap.isMarked(ownerExecutable()))
    20462050        return;
    20472051

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

    r242928 r243467  
    920920
    921921    bool shouldVisitStrongly(const ConcurrentJSLocker&);
    922     bool shouldJettisonDueToWeakReference();
     922    bool shouldJettisonDueToWeakReference(VM&);
    923923    bool shouldJettisonDueToOldAge(const ConcurrentJSLocker&);
    924924   

  • trunk/Source/JavaScriptCore/bytecode/ExecutableToCodeBlockEdge.cpp

    r240951 r243467  
    7676        visitor.appendUnbarriered(codeBlock);
    7777   
    78     if (!Heap::isMarked(codeBlock))
     78    if (!vm.heap.isMarked(codeBlock))
    7979        vm.executableToCodeBlockEdgesWithFinalizers.add(edge);
    8080   
    … …  
    126126    CodeBlock* codeBlock = m_codeBlock.get();
    127127   
    128     if (!Heap::isMarked(codeBlock)) {
    129         if (codeBlock->shouldJettisonDueToWeakReference())
     128    if (!vm.heap.isMarked(codeBlock)) {
     129        if (codeBlock->shouldJettisonDueToWeakReference(vm))
    130130            codeBlock->jettison(Profiler::JettisonDueToWeakReference);
    131131        else
    … …  
    190190    codeBlock->determineLiveness(locker, visitor);
    191191   
    192     if (Heap::isMarked(codeBlock))
     192    if (vm.heap.isMarked(codeBlock))
    193193        vm.executableToCodeBlockEdgesWithConstraints.remove(this);
    194194}

  • trunk/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp

    r243232 r243467  
    477477}
    478478
    479 bool GetByIdStatus::finalize()
     479bool GetByIdStatus::finalize(VM& vm)
    480480{
    481481    for (GetByIdVariant& variant : m_variants) {
    482         if (!variant.finalize())
     482        if (!variant.finalize(vm))
    483483            return false;
    484484    }
    485     if (m_moduleNamespaceObject && !Heap::isMarked(m_moduleNamespaceObject))
     485    if (m_moduleNamespaceObject && !vm.heap.isMarked(m_moduleNamespaceObject))
    486486        return false;
    487     if (m_moduleEnvironment && !Heap::isMarked(m_moduleEnvironment))
     487    if (m_moduleEnvironment && !vm.heap.isMarked(m_moduleEnvironment))
    488488        return false;
    489489    return true;

  • trunk/Source/JavaScriptCore/bytecode/GetByIdStatus.h

    r242659 r243467  
    142142   
    143143    void markIfCheap(SlotVisitor&);
    144     bool finalize(); // Return true if this gets to live.
     144    bool finalize(VM&); // Return true if this gets to live.
    145145   
    146146    void dump(PrintStream&) const;

  • trunk/Source/JavaScriptCore/bytecode/GetByIdVariant.cpp

    r239427 r243467  
    150150}
    151151
    152 bool GetByIdVariant::finalize()
     152bool GetByIdVariant::finalize(VM& vm)
    153153{
    154     if (!m_structureSet.isStillAlive())
     154    if (!m_structureSet.isStillAlive(vm))
    155155        return false;
    156     if (!m_conditionSet.areStillLive())
     156    if (!m_conditionSet.areStillLive(vm))
    157157        return false;
    158     if (m_callLinkStatus && !m_callLinkStatus->finalize())
     158    if (m_callLinkStatus && !m_callLinkStatus->finalize(vm))
    159159        return false;
    160     if (m_intrinsicFunction && !Heap::isMarked(m_intrinsicFunction))
     160    if (m_intrinsicFunction && !vm.heap.isMarked(m_intrinsicFunction))
    161161        return false;
    162162    return true;

  • trunk/Source/JavaScriptCore/bytecode/GetByIdVariant.h

    r239427 r243467  
    7575   
    7676    void markIfCheap(SlotVisitor&);
    77     bool finalize();
     77    bool finalize(VM&);
    7878   
    7979    void dump(PrintStream&) const;

  • trunk/Source/JavaScriptCore/bytecode/InByIdStatus.cpp

    r243232 r243467  
    259259}
    260260
    261 bool InByIdStatus::finalize()
     261bool InByIdStatus::finalize(VM& vm)
    262262{
    263263    for (InByIdVariant& variant : m_variants) {
    264         if (!variant.finalize())
     264        if (!variant.finalize(vm))
    265265            return false;
    266266    }

  • trunk/Source/JavaScriptCore/bytecode/InByIdStatus.h

    r234086 r243467  
    107107   
    108108    void markIfCheap(SlotVisitor&);
    109     bool finalize();
     109    bool finalize(VM&);
    110110
    111111    void dump(PrintStream&) const;

  • trunk/Source/JavaScriptCore/bytecode/InByIdVariant.cpp

    r234090 r243467  
    7373}
    7474
    75 bool InByIdVariant::finalize()
     75bool InByIdVariant::finalize(VM& vm)
    7676{
    77     if (!m_structureSet.isStillAlive())
     77    if (!m_structureSet.isStillAlive(vm))
    7878        return false;
    79     if (!m_conditionSet.areStillLive())
     79    if (!m_conditionSet.areStillLive(vm))
    8080        return false;
    8181    return true;

  • trunk/Source/JavaScriptCore/bytecode/InByIdVariant.h

    r234086 r243467  
    5858   
    5959    void markIfCheap(SlotVisitor&);
    60     bool finalize();
     60    bool finalize(VM&);
    6161
    6262    void dump(PrintStream&) const;

  • trunk/Source/JavaScriptCore/bytecode/ObjectPropertyCondition.cpp

    r243420 r243467  
    143143}
    144144
    145 bool ObjectPropertyCondition::isStillLive() const
     145bool ObjectPropertyCondition::isStillLive(VM& vm) const
    146146{
    147147    if (!*this)
    148148        return false;
    149149   
    150     if (!Heap::isMarked(m_object))
     150    if (!vm.heap.isMarked(m_object))
    151151        return false;
    152152   
    153     return m_condition.isStillLive();
     153    return m_condition.isStillLive(vm);
    154154}
    155155

  • trunk/Source/JavaScriptCore/bytecode/ObjectPropertyCondition.h

    r231961 r243467  
    245245   
    246246    // This means that the objects involved in this are still live.
    247     bool isStillLive() const;
     247    bool isStillLive(VM&) const;
    248248   
    249249    void validateReferences(const TrackedReferences&) const;

  • trunk/Source/JavaScriptCore/bytecode/ObjectPropertyConditionSet.cpp

    r233124 r243467  
    142142}
    143143
    144 bool ObjectPropertyConditionSet::areStillLive() const
    145 {
    146     for (const ObjectPropertyCondition& condition : *this) {
    147         if (!condition.isStillLive())
     144bool ObjectPropertyConditionSet::areStillLive(VM& vm) const
     145{
     146    for (const ObjectPropertyCondition& condition : *this) {
     147        if (!condition.isStillLive(vm))
    148148            return false;
    149149    }

  • trunk/Source/JavaScriptCore/bytecode/ObjectPropertyConditionSet.h

    r232313 r243467  
    112112   
    113113    bool needImpurePropertyWatchpoint() const;
    114     bool areStillLive() const;
     114    bool areStillLive(VM&) const;
    115115   
    116116    void dumpInContext(PrintStream&, DumpContext*) const;

  • trunk/Source/JavaScriptCore/bytecode/PolymorphicAccess.cpp

    r235527 r243467  
    325325    if (Vector<WriteBarrier<JSCell>>* weakReferences = m_weakReferences.get()) {
    326326        for (WriteBarrier<JSCell>& weakReference : *weakReferences) {
    327             if (!Heap::isMarked(weakReference.get()))
     327            if (!vm.heap.isMarked(weakReference.get()))
    328328                return false;
    329329        }

  • trunk/Source/JavaScriptCore/bytecode/PropertyCondition.cpp

    r239062 r243467  
    353353}
    354354
    355 bool PropertyCondition::isStillLive() const
    356 {
    357     if (hasPrototype() && prototype() && !Heap::isMarked(prototype()))
     355bool PropertyCondition::isStillLive(VM& vm) const
     356{
     357    if (hasPrototype() && prototype() && !vm.heap.isMarked(prototype()))
    358358        return false;
    359359   
    … …  
    361361        && requiredValue()
    362362        && requiredValue().isCell()
    363         && !Heap::isMarked(requiredValue().asCell()))
     363        && !vm.heap.isMarked(requiredValue().asCell()))
    364364        return false;
    365365   

  • trunk/Source/JavaScriptCore/bytecode/PropertyCondition.h

    r234677 r243467  
    298298   
    299299    // This means that the objects involved in this are still live.
    300     bool isStillLive() const;
     300    bool isStillLive(VM&) const;
    301301   
    302302    void validateReferences(const TrackedReferences&) const;

  • trunk/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp

    r243232 r243467  
    387387}
    388388
    389 bool PutByIdStatus::finalize()
     389bool PutByIdStatus::finalize(VM& vm)
    390390{
    391391    for (PutByIdVariant& variant : m_variants) {
    392         if (!variant.finalize())
     392        if (!variant.finalize(vm))
    393393            return false;
    394394    }

  • trunk/Source/JavaScriptCore/bytecode/PutByIdStatus.h

    r238346 r243467  
    117117   
    118118    void markIfCheap(SlotVisitor&);
    119     bool finalize();
     119    bool finalize(VM&);
    120120   
    121121    void merge(const PutByIdStatus&);

  • trunk/Source/JavaScriptCore/bytecode/PutByIdVariant.cpp

    r240023 r243467  
    271271}
    272272
    273 bool PutByIdVariant::finalize()
    274 {
    275     if (!m_oldStructure.isStillAlive())
    276         return false;
    277     if (m_newStructure && !Heap::isMarked(m_newStructure))
    278         return false;
    279     if (!m_conditionSet.areStillLive())
    280         return false;
    281     if (m_callLinkStatus && !m_callLinkStatus->finalize())
     273bool PutByIdVariant::finalize(VM& vm)
     274{
     275    if (!m_oldStructure.isStillAlive(vm))
     276        return false;
     277    if (m_newStructure && !vm.heap.isMarked(m_newStructure))
     278        return false;
     279    if (!m_conditionSet.areStillLive(vm))
     280        return false;
     281    if (m_callLinkStatus && !m_callLinkStatus->finalize(vm))
    282282        return false;
    283283    return true;

  • trunk/Source/JavaScriptCore/bytecode/PutByIdVariant.h

    r242657 r243467  
    133133   
    134134    void markIfCheap(SlotVisitor&);
    135     bool finalize();
     135    bool finalize(VM&);
    136136   
    137137    void dump(PrintStream&) const;

  • trunk/Source/JavaScriptCore/bytecode/RecordedStatuses.cpp

    r234086 r243467  
    8686}
    8787
    88 void RecordedStatuses::finalizeWithoutDeleting()
     88void RecordedStatuses::finalizeWithoutDeleting(VM& vm)
    8989{
    9090    // This variant of finalize gets called from within graph safepoints -- so there may be DFG IR in
    … …  
    9393    // anything from the vector or delete the unique_ptrs.
    9494   
    95     auto finalize = [] (auto& vector) {
     95    auto finalize = [&] (auto& vector) {
    9696        for (auto& pair : vector) {
    97             if (!pair.second->finalize())
     97            if (!pair.second->finalize(vm))
    9898                *pair.second = { };
    9999        }
    … …  
    102102}
    103103
    104 void RecordedStatuses::finalize()
     104void RecordedStatuses::finalize(VM& vm)
    105105{
    106     auto finalize = [] (auto& vector) {
     106    auto finalize = [&] (auto& vector) {
    107107        vector.removeAllMatching(
    108108            [&] (auto& pair) -> bool {
    109                 return !*pair.second || !pair.second->finalize();
     109                return !*pair.second || !pair.second->finalize(vm);
    110110            });
    111111        vector.shrinkToFit();

  • trunk/Source/JavaScriptCore/bytecode/RecordedStatuses.h

    r234086 r243467  
    5151    void markIfCheap(SlotVisitor& slotVisitor);
    5252   
    53     void finalizeWithoutDeleting();
    54     void finalize();
     53    void finalizeWithoutDeleting(VM&);
     54    void finalize(VM&);
    5555   
    5656    void shrinkToFit();

  • trunk/Source/JavaScriptCore/bytecode/StructureSet.cpp

    r234086 r243467  
    3838}
    3939
    40 bool StructureSet::isStillAlive() const
     40bool StructureSet::isStillAlive(VM& vm) const
    4141{
    4242    for (Structure* structure : *this) {
    43         if (!Heap::isMarked(structure))
     43        if (!vm.heap.isMarked(structure))
    4444            return false;
    4545    }

  • trunk/Source/JavaScriptCore/bytecode/StructureSet.h

    r243163 r243467  
    5656
    5757    void markIfCheap(SlotVisitor&) const;
    58     bool isStillAlive() const;
     58    bool isStillAlive(VM&) const;
    5959   
    6060    void dumpInContext(PrintStream&, DumpContext*) const;

  • trunk/Source/JavaScriptCore/bytecode/StructureStubInfo.cpp

    r235517 r243467  
    273273    bufferedStructures.genericFilter(
    274274        [&] (Structure* structure) -> bool {
    275             return Heap::isMarked(structure);
     275            return vm.heap.isMarked(structure);
    276276        });
    277277
    … …  
    280280    case CacheType::PutByIdReplace:
    281281    case CacheType::InByIdSelf:
    282         if (Heap::isMarked(u.byIdSelf.baseObjectStructure.get()))
     282        if (vm.heap.isMarked(u.byIdSelf.baseObjectStructure.get()))
    283283            return;
    284284        break;

  • trunk/Source/JavaScriptCore/dfg/DFGPlan.cpp

    r242812 r243467  
    665665void Plan::finalizeInGC()
    666666{
    667     m_recordedStatuses.finalizeWithoutDeleting();
     667    ASSERT(m_vm);
     668    m_recordedStatuses.finalizeWithoutDeleting(*m_vm);
    668669}
    669670
    … …  
    672673    if (m_stage == Cancelled)
    673674        return false;
    674     if (!Heap::isMarked(m_codeBlock->ownerExecutable()))
     675    if (!m_vm->heap.isMarked(m_codeBlock->ownerExecutable()))
    675676        return false;
    676     if (!Heap::isMarked(m_codeBlock->alternative()))
     677    if (!m_vm->heap.isMarked(m_codeBlock->alternative()))
    677678        return false;
    678     if (!!m_profiledDFGCodeBlock && !Heap::isMarked(m_profiledDFGCodeBlock))
     679    if (!!m_profiledDFGCodeBlock && !m_vm->heap.isMarked(m_profiledDFGCodeBlock))
    679680        return false;
    680681    return true;

  • trunk/Source/JavaScriptCore/heap/GCIncomingRefCounted.h

    r222113 r243467  
    8383    // you're also walking the GC's list.
    8484    template<typename FilterFunctionType>
    85     bool filterIncomingReferences(FilterFunctionType&);
     85    bool filterIncomingReferences(FilterFunctionType&&);
    8686   
    8787private:

  • trunk/Source/JavaScriptCore/heap/GCIncomingRefCountedInlines.h

    r206525 r243467  
    5858template<typename T>
    5959template<typename FilterFunctionType>
    60 bool GCIncomingRefCounted<T>::filterIncomingReferences(FilterFunctionType& filterFunction)
     60bool GCIncomingRefCounted<T>::filterIncomingReferences(FilterFunctionType&& filterFunction)
    6161{
    6262    const bool verbose = false;

  • trunk/Source/JavaScriptCore/heap/GCIncomingRefCountedSet.h

    r206525 r243467  
    4242    bool addReference(JSCell*, T*);
    4343   
    44     void sweep();
     44    void sweep(VM&);
    4545   
    4646    size_t size() const { return m_bytes; };
    4747   
    4848private:
    49     static bool removeAll(JSCell*);
    50     static bool removeDead(JSCell*);
    51    
    5249    Vector<T*> m_vector;
    5350    size_t m_bytes;

  • trunk/Source/JavaScriptCore/heap/GCIncomingRefCountedSetInlines.h

    r206525 r243467  
    4141{
    4242    for (size_t i = m_vector.size(); i--;)
    43         m_vector[i]->filterIncomingReferences(removeAll);
     43        m_vector[i]->filterIncomingReferences([] (JSCell*) { return false; });
    4444}
    4545
    … …  
    6060
    6161template<typename T>
    62 void GCIncomingRefCountedSet<T>::sweep()
     62void GCIncomingRefCountedSet<T>::sweep(VM& vm)
    6363{
    6464    for (size_t i = 0; i < m_vector.size(); ++i) {
    … …  
    6767        ASSERT(object->isDeferred());
    6868        ASSERT(object->numberOfIncomingReferences());
    69         if (!object->filterIncomingReferences(removeDead))
     69        if (!object->filterIncomingReferences([&] (JSCell* cell) { return vm.heap.isMarked(cell); }))
    7070            continue;
    7171        m_bytes -= size;
    … …  
    7575}
    7676
    77 template<typename T>
    78 bool GCIncomingRefCountedSet<T>::removeAll(JSCell*)
    79 {
    80     return false;
    81 }
    82 
    83 template<typename T>
    84 bool GCIncomingRefCountedSet<T>::removeDead(JSCell* cell)
    85 {
    86     return Heap::isMarked(cell);
    87 }
    88 
    8977} // namespace JSC

  • trunk/Source/JavaScriptCore/heap/Heap.cpp

    r243312 r243467  
    10111011        }
    10121012    } else
    1013         ASSERT(Heap::isMarked(cell));
     1013        ASSERT(isMarked(cell));
    10141014    // It could be that the object was *just* marked. This means that the collector may set the
    10151015    // state to DefinitelyGrey and then to PossiblyOldOrBlack at any time. It's OK for us to
    … …  
    14951495       
    14961496    if (vm()->typeProfiler())
    1497         vm()->typeProfiler()->invalidateTypeSetCache();
     1497        vm()->typeProfiler()->invalidateTypeSetCache(*vm());
    14981498
    14991499    reapWeakHandles();
    … …  
    22132213void Heap::sweepArrayBuffers()
    22142214{
    2215     m_arrayBuffers.sweep();
     2215    m_arrayBuffers.sweep(*vm());
    22162216}
    22172217
    … …  
    28342834                [&] (CodeBlock* codeBlock) {
    28352835                    // Visit the CodeBlock as a constraint only if it's black.
    2836                     if (Heap::isMarked(codeBlock)
     2836                    if (isMarked(codeBlock)
    28372837                        && codeBlock->cellState() == CellState::PossiblyBlack)
    28382838                        slotVisitor.visitAsConstraint(codeBlock);

  • trunk/Source/JavaScriptCore/heap/Heap.h

    r243086 r243467  
    124124    static const unsigned s_timeCheckResolution = 16;
    125125
    126     static bool isMarked(const void*);
     126    bool isMarked(const void*);
    127127    static bool testAndSetMarked(HeapVersion, const void*);
    128128   

  • trunk/Source/JavaScriptCore/heap/HeapInlines.h

    r242070 r243467  
    6969}
    7070
    71 // FIXME: This should be an instance method, so that it can get the markingVersion() quickly.
    72 // https://bugs.webkit.org/show_bug.cgi?id=179988
    7371ALWAYS_INLINE bool Heap::isMarked(const void* rawCell)
    7472{
    … …  
    7775        return cell->largeAllocation().isMarked();
    7876    MarkedBlock& block = cell->markedBlock();
    79     return block.isMarked(block.vm()->heap.objectSpace().markingVersion(), cell);
     77    return block.isMarked(m_objectSpace.markingVersion(), cell);
    8078}
    8179

  • trunk/Source/JavaScriptCore/heap/HeapSnapshotBuilder.cpp

    r241787 r243467  
    8181    ASSERT(m_profiler.activeSnapshotBuilder() == this);
    8282
    83     ASSERT(Heap::isMarked(cell));
     83    ASSERT(m_profiler.vm().heap.isMarked(cell));
    8484
    8585    NodeIdentifier identifier;

  • trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp

    r242096 r243467  
    286286ALWAYS_INLINE void SlotVisitor::appendToMarkStack(ContainerType& container, JSCell* cell)
    287287{
    288     ASSERT(Heap::isMarked(cell));
     288    ASSERT(m_heap.isMarked(cell));
    289289    ASSERT(!cell->isZapped());
    290290   
    … …  
    355355ALWAYS_INLINE void SlotVisitor::visitChildren(const JSCell* cell)
    356356{
    357     ASSERT(Heap::isMarked(cell));
     357    ASSERT(m_heap.isMarked(cell));
    358358   
    359359    SetCurrentCellScope currentCellScope(*this, cell);

  • trunk/Source/JavaScriptCore/jit/PolymorphicCallStubRoutine.cpp

    r234086 r243467  
    131131}
    132132
    133 bool PolymorphicCallStubRoutine::visitWeak(VM&)
     133bool PolymorphicCallStubRoutine::visitWeak(VM& vm)
    134134{
    135135    for (auto& variant : m_variants) {
    136         if (!Heap::isMarked(variant.get()))
     136        if (!vm.heap.isMarked(variant.get()))
    137137            return false;
    138138    }

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

    r243232 r243467  
    213213    // get caught in a trace.
    214214    for (const auto& frame : *m_stackTrace.get()) {
    215         if (!frame.isMarked()) {
     215        if (!frame.isMarked(vm)) {
    216216            computeErrorInfo(vm);
    217217            return;

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

    r240965 r243467  
    3535   
    3636    if (value && value.isCell()) {
    37         if (Heap::isMarked(value.asCell()))
     37        if (vm.heap.isMarked(value.asCell()))
    3838            return;
    3939       

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

    r240255 r243467  
    5959   
    6060    void visitChildren(SlotVisitor&);
    61     bool isMarked() const { return (!m_callee || Heap::isMarked(m_callee.get())) && (!m_codeBlock || Heap::isMarked(m_codeBlock.get())); }
     61    bool isMarked(VM& vm) const { return (!m_callee || vm.heap.isMarked(m_callee.get())) && (!m_codeBlock || vm.heap.isMarked(m_codeBlock.get())); }
    6262
    6363private:

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

    r243069 r243467  
    10551055}
    10561056
    1057 bool Structure::isCheapDuringGC()
     1057bool Structure::isCheapDuringGC(VM& vm)
    10581058{
    10591059    // FIXME: We could make this even safer by returning false if this structure's property table
    … …  
    10611061    // https://bugs.webkit.org/show_bug.cgi?id=157334
    10621062   
    1063     return (!m_globalObject || Heap::isMarked(m_globalObject.get()))
    1064         && (hasPolyProto() || !storedPrototypeObject() || Heap::isMarked(storedPrototypeObject()));
     1063    return (!m_globalObject || vm.heap.isMarked(m_globalObject.get()))
     1064        && (hasPolyProto() || !storedPrototypeObject() || vm.heap.isMarked(storedPrototypeObject()));
    10651065}
    10661066
    10671067bool Structure::markIfCheap(SlotVisitor& visitor)
    10681068{
    1069     if (!isCheapDuringGC())
    1070         return Heap::isMarked(this);
     1069    VM& vm = visitor.vm();
     1070    if (!isCheapDuringGC(vm))
     1071        return vm.heap.isMarked(this);
    10711072   
    10721073    visitor.appendUnbarriered(this);

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

    r242100 r243467  
    300300    // returns true if all user-controlled (and hence unbounded in size) objects referenced from the
    301301    // Structure are already marked.
    302     bool isCheapDuringGC();
     302    bool isCheapDuringGC(VM&);
    303303   
    304304    // Returns true if this structure is now marked.

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

    r221954 r243467  
    149149}
    150150
    151 void TypeProfiler::invalidateTypeSetCache()
     151void TypeProfiler::invalidateTypeSetCache(VM& vm)
    152152{
    153153    for (Bag<TypeLocation>::iterator iter = m_typeLocationInfo.begin(); !!iter; ++iter) {
    154154        TypeLocation* location = *iter;
    155         location->m_instructionTypeSet->invalidateCache();
     155        location->m_instructionTypeSet->invalidateCache(vm);
    156156        if (location->m_globalTypeSet)
    157             location->m_globalTypeSet->invalidateCache();
     157            location->m_globalTypeSet->invalidateCache(vm);
    158158    }
    159159}

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

    r218794 r243467  
    125125    GlobalVariableID getNextUniqueVariableID() { return m_nextUniqueVariableID++; }
    126126    TypeLocation* nextTypeLocation();
    127     void invalidateTypeSetCache();
     127    void invalidateTypeSetCache(VM&);
    128128    void dumpTypeProfilerData(VM&);
    129129   

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

    r242812 r243467  
    8080}
    8181
    82 void TypeSet::invalidateCache()
     82void TypeSet::invalidateCache(VM& vm)
    8383{
    8484    ConcurrentJSLocker locker(m_lock);
    85     auto keepMarkedStructuresFilter = [] (Structure* structure) -> bool { return Heap::isMarked(structure); };
     85    auto keepMarkedStructuresFilter = [&] (Structure* structure) -> bool {
     86        return vm.heap.isMarked(structure);
     87    };
    8688    m_structureSet.genericFilter(keepMarkedStructuresFilter);
    8789}

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

    r242812 r243467  
    8787    TypeSet();
    8888    void addTypeInformation(RuntimeType, RefPtr<StructureShape>&&, Structure*, bool sawPolyProtoStructure);
    89     void invalidateCache();
     89    void invalidateCache(VM&);
    9090    String dumpTypes() const;
    9191    String displayName() const;

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

    r233765 r243467  
    6565void WeakMapImpl<WeakMapBucket<WeakMapBucketDataKeyValue>>::visitOutputConstraints(JSCell* cell, SlotVisitor& visitor)
    6666{
     67    VM& vm = visitor.vm();
    6768    auto* thisObject = jsCast<WeakMapImpl*>(cell);
    6869    auto locker = holdLock(thisObject->cellLock());
    … …  
    7273        if (bucket->isEmpty() || bucket->isDeleted())
    7374            continue;
    74         if (!Heap::isMarked(bucket->key()))
     75        if (!vm.heap.isMarked(bucket->key()))
    7576            continue;
    7677        bucket->visitAggregate(visitor);

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

    r226017 r243467  
    3232// Note that this function can be executed in parallel as long as the mutator stops.
    3333template<typename WeakMapBucket>
    34 void WeakMapImpl<WeakMapBucket>::finalizeUnconditionally(VM&)
     34void WeakMapImpl<WeakMapBucket>::finalizeUnconditionally(VM& vm)
    3535{
    3636    auto* buffer = this->buffer();
    … …  
    4040            continue;
    4141
    42         if (Heap::isMarked(bucket->key()))
     42        if (vm.heap.isMarked(bucket->key()))
    4343            continue;
    4444
Note: See TracChangeset for help on using the changeset viewer.