From 211e335615ae4a9ac7204b000b235ff9d2782ec5 Mon Sep 17 00:00:00 2001 From: Ted Campbell Date: Thu, 13 Feb 2020 14:33:33 +0000 Subject: [PATCH] Bug 1615143 - Eliminate TraceKind::LazyScript. r=jonco Now that JSScript and LazyScript share a trace method, we can use a single TraceKind within the GC. To acheive this we also must remove eager marking of LazyScripts. Differential Revision: https://phabricator.services.mozilla.com/D62681 --HG-- extra : moz-landing-system : lando --- js/public/HeapAPI.h | 2 + js/public/MemoryMetrics.h | 6 --- js/public/TraceKind.h | 18 ++++----- js/public/TracingAPI.h | 12 ++---- js/public/UbiNode.h | 12 ++++-- js/src/debugger/Script-inl.h | 12 +++--- js/src/debugger/Script.cpp | 9 +---- js/src/gc/AllocKind.h | 2 +- js/src/gc/ClearEdgesTracer.h | 3 +- js/src/gc/GC.cpp | 10 +---- js/src/gc/GC.h | 1 + js/src/gc/GCInternals.h | 6 +-- js/src/gc/GCMarker.h | 1 - js/src/gc/Marking-inl.h | 3 +- js/src/gc/Marking.cpp | 65 +++++++------------------------ js/src/gc/RootMarking.cpp | 2 +- js/src/gc/Tracer.cpp | 10 ----- js/src/gdb/mozilla/GCCellPtr.py | 3 +- js/src/vm/JSFunction.cpp | 10 +---- js/src/vm/JSScript.cpp | 20 +--------- js/src/vm/JSScript.h | 26 +++---------- js/src/vm/MemoryMetrics.cpp | 8 ---- js/src/vm/UbiNode.cpp | 14 +++---- js/xpconnect/src/XPCJSRuntime.cpp | 20 ---------- 24 files changed, 69 insertions(+), 206 deletions(-) diff --git a/js/public/HeapAPI.h b/js/public/HeapAPI.h index 4007d5fe3dff..13e806ca1525 100644 --- a/js/public/HeapAPI.h +++ b/js/public/HeapAPI.h @@ -310,6 +310,8 @@ class JS_FRIEND_API GCCellPtr { : ptr(checkedCast(p, JS::MapTypeToTraceKind::kind)) {} explicit GCCellPtr(JSFunction* p) : ptr(checkedCast(p, JS::TraceKind::Object)) {} + explicit GCCellPtr(JSScript* p) + : ptr(checkedCast(p, JS::TraceKind::Script)) {} explicit GCCellPtr(const Value& v); JS::TraceKind kind() const { diff --git a/js/public/MemoryMetrics.h b/js/public/MemoryMetrics.h index 9a009a56ddb1..8c331166a320 100644 --- a/js/public/MemoryMetrics.h +++ b/js/public/MemoryMetrics.h @@ -538,7 +538,6 @@ struct UnusedGCThingSizes { #define FOR_EACH_SIZE(MACRO) \ MACRO(Other, GCHeapUnused, object) \ MACRO(Other, GCHeapUnused, script) \ - MACRO(Other, GCHeapUnused, lazyScript) \ MACRO(Other, GCHeapUnused, shape) \ MACRO(Other, GCHeapUnused, baseShape) \ MACRO(Other, GCHeapUnused, objectGroup) \ @@ -578,9 +577,6 @@ struct UnusedGCThingSizes { case JS::TraceKind::JitCode: jitcode += n; break; - case JS::TraceKind::LazyScript: - lazyScript += n; - break; case JS::TraceKind::ObjectGroup: objectGroup += n; break; @@ -624,8 +620,6 @@ struct ZoneStats { MACRO(Other, GCHeapUsed, bigIntsGCHeap) \ MACRO(Other, MallocHeap, bigIntsMallocHeap) \ MACRO(Other, GCHeapAdmin, gcHeapArenaAdmin) \ - MACRO(Other, GCHeapUsed, lazyScriptsGCHeap) \ - MACRO(Other, MallocHeap, lazyScriptsMallocHeap) \ MACRO(Other, GCHeapUsed, jitCodesGCHeap) \ MACRO(Other, GCHeapUsed, objectGroupsGCHeap) \ MACRO(Other, MallocHeap, objectGroupsMallocHeap) \ diff --git a/js/public/TraceKind.h b/js/public/TraceKind.h index d2d8bc0dd16b..84a56c5c24f5 100644 --- a/js/public/TraceKind.h +++ b/js/public/TraceKind.h @@ -13,8 +13,8 @@ // Forward declarations of all the types a TraceKind can denote. namespace js { +class BaseScript; class BaseShape; -class LazyScript; class ObjectGroup; class RegExpShared; class Shape; @@ -58,9 +58,8 @@ enum class TraceKind { BaseShape = 0x0F, JitCode = 0x1F, Script = 0x2F, - LazyScript = 0x3F, - Scope = 0x4F, - RegExpShared = 0x5F + Scope = 0x3F, + RegExpShared = 0x4F }; const static uintptr_t OutOfLineTraceKindMask = 0x07; @@ -70,7 +69,7 @@ const static uintptr_t OutOfLineTraceKindMask = 0x07; "mask bits are set") ASSERT_TRACE_KIND(JS::TraceKind::BaseShape); ASSERT_TRACE_KIND(JS::TraceKind::JitCode); -ASSERT_TRACE_KIND(JS::TraceKind::LazyScript); +ASSERT_TRACE_KIND(JS::TraceKind::Script); ASSERT_TRACE_KIND(JS::TraceKind::Scope); ASSERT_TRACE_KIND(JS::TraceKind::RegExpShared); #undef ASSERT_TRACE_KIND @@ -96,11 +95,10 @@ struct MapTypeToTraceKind { /* name type canBeGray inCCGraph */ \ D(BaseShape, js::BaseShape, true, false) \ D(JitCode, js::jit::JitCode, true, false) \ - D(LazyScript, js::LazyScript, true, true) \ D(Scope, js::Scope, true, true) \ D(Object, JSObject, true, true) \ D(ObjectGroup, js::ObjectGroup, true, false) \ - D(Script, JSScript, true, true) \ + D(Script, js::BaseScript, true, true) \ D(Shape, js::Shape, true, false) \ D(String, JSString, false, false) \ D(Symbol, JS::Symbol, false, false) \ @@ -192,6 +190,8 @@ struct MapTypeToRootKind { }; template <> struct MapTypeToRootKind : public MapTypeToRootKind {}; +template <> +struct MapTypeToRootKind : public MapTypeToRootKind {}; // Fortunately, few places in the system need to deal with fully abstract // cells. In those places that do, we generally want to move to a layout @@ -209,8 +209,8 @@ struct MapTypeToRootKind : public MapTypeToRootKind {}; template auto DispatchTraceKindTyped(F f, JS::TraceKind traceKind, Args&&... args) { switch (traceKind) { -#define JS_EXPAND_DEF(name, type, _, _1) \ - case JS::TraceKind::name: \ +#define JS_EXPAND_DEF(name, type, _, _1) \ + case JS::TraceKind::name: \ return f.template operator()(std::forward(args)...); JS_FOR_EACH_TRACEKIND(JS_EXPAND_DEF); #undef JS_EXPAND_DEF diff --git a/js/public/TracingAPI.h b/js/public/TracingAPI.h index 95df84cea3ca..b595ca906450 100644 --- a/js/public/TracingAPI.h +++ b/js/public/TracingAPI.h @@ -162,7 +162,7 @@ class JS_PUBLIC_API CallbackTracer : public JSTracer { virtual bool onBigIntEdge(JS::BigInt** bip) { return onChild(JS::GCCellPtr(*bip)); } - virtual bool onScriptEdge(JSScript** scriptp) { + virtual bool onScriptEdge(js::BaseScript** scriptp) { return onChild(JS::GCCellPtr(*scriptp)); } virtual bool onShapeEdge(js::Shape** shapep) { @@ -177,9 +177,6 @@ class JS_PUBLIC_API CallbackTracer : public JSTracer { virtual bool onJitCodeEdge(js::jit::JitCode** codep) { return onChild(JS::GCCellPtr(*codep, JS::TraceKind::JitCode)); } - virtual bool onLazyScriptEdge(js::LazyScript** lazyp) { - return onChild(JS::GCCellPtr(*lazyp, JS::TraceKind::LazyScript)); - } virtual bool onScopeEdge(js::Scope** scopep) { return onChild(JS::GCCellPtr(*scopep, JS::TraceKind::Scope)); } @@ -263,7 +260,9 @@ class JS_PUBLIC_API CallbackTracer : public JSTracer { bool dispatchToOnEdge(JSString** strp) { return onStringEdge(strp); } bool dispatchToOnEdge(JS::Symbol** symp) { return onSymbolEdge(symp); } bool dispatchToOnEdge(JS::BigInt** bip) { return onBigIntEdge(bip); } - bool dispatchToOnEdge(JSScript** scriptp) { return onScriptEdge(scriptp); } + bool dispatchToOnEdge(js::BaseScript** scriptp) { + return onScriptEdge(scriptp); + } bool dispatchToOnEdge(js::Shape** shapep) { return onShapeEdge(shapep); } bool dispatchToOnEdge(js::ObjectGroup** groupp) { return onObjectGroupEdge(groupp); @@ -274,9 +273,6 @@ class JS_PUBLIC_API CallbackTracer : public JSTracer { bool dispatchToOnEdge(js::jit::JitCode** codep) { return onJitCodeEdge(codep); } - bool dispatchToOnEdge(js::LazyScript** lazyp) { - return onLazyScriptEdge(lazyp); - } bool dispatchToOnEdge(js::Scope** scopep) { return onScopeEdge(scopep); } bool dispatchToOnEdge(js::RegExpShared** sharedp) { return onRegExpSharedEdge(sharedp); diff --git a/js/public/UbiNode.h b/js/public/UbiNode.h index 4c3e2132540c..83f88325e788 100644 --- a/js/public/UbiNode.h +++ b/js/public/UbiNode.h @@ -174,6 +174,10 @@ class StackFrame; } // namespace ubi } // namespace JS +namespace js { +class BaseScript; +} // namespace js + namespace JS { namespace ubi { @@ -1107,12 +1111,14 @@ class JS_PUBLIC_API Concrete : TracerConcrete { }; template <> -class JS_PUBLIC_API Concrete : TracerConcreteWithRealm { +class JS_PUBLIC_API Concrete + : TracerConcreteWithRealm { protected: - explicit Concrete(JSScript* ptr) : TracerConcreteWithRealm(ptr) {} + explicit Concrete(js::BaseScript* ptr) + : TracerConcreteWithRealm(ptr) {} public: - static void construct(void* storage, JSScript* ptr) { + static void construct(void* storage, js::BaseScript* ptr) { new (storage) Concrete(ptr); } diff --git a/js/src/debugger/Script-inl.h b/js/src/debugger/Script-inl.h index 87679ca9ef10..f0afbcbe3672 100644 --- a/js/src/debugger/Script-inl.h +++ b/js/src/debugger/Script-inl.h @@ -29,12 +29,12 @@ js::gc::Cell* js::DebuggerScript::getReferentCell() const { js::DebuggerScriptReferent js::DebuggerScript::getReferent() const { if (gc::Cell* cell = getReferentCell()) { - if (cell->is()) { + if (cell->is()) { + if (cell->as()->isLazyScript()) { + return mozilla::AsVariant(cell->as()); + } return mozilla::AsVariant(cell->as()); } - if (cell->is()) { - return mozilla::AsVariant(cell->as()); - } MOZ_ASSERT(cell->is()); return mozilla::AsVariant( &static_cast(cell)->as()); @@ -44,9 +44,7 @@ js::DebuggerScriptReferent js::DebuggerScript::getReferent() const { js::BaseScript* js::DebuggerScript::getReferentScript() const { gc::Cell* cell = getReferentCell(); - - MOZ_ASSERT(cell->is() || cell->is()); - return static_cast(cell); + return cell->as(); } #endif /* debugger_Script_inl_h */ diff --git a/js/src/debugger/Script.cpp b/js/src/debugger/Script.cpp index a7aa3c85bd80..321416afa79c 100644 --- a/js/src/debugger/Script.cpp +++ b/js/src/debugger/Script.cpp @@ -80,16 +80,11 @@ void DebuggerScript::trace(JSTracer* trc) { // This comes from a private pointer, so no barrier needed. gc::Cell* cell = getReferentCell(); if (cell) { - if (cell->is()) { - JSScript* script = cell->as(); + if (cell->is()) { + BaseScript* script = cell->as(); TraceManuallyBarrieredCrossCompartmentEdge( trc, upcast, &script, "Debugger.Script script referent"); setPrivateUnbarriered(script); - } else if (cell->is()) { - LazyScript* lazyScript = cell->as(); - TraceManuallyBarrieredCrossCompartmentEdge( - trc, upcast, &lazyScript, "Debugger.Script lazy script referent"); - setPrivateUnbarriered(lazyScript); } else { JSObject* wasm = cell->as(); TraceManuallyBarrieredCrossCompartmentEdge( diff --git a/js/src/gc/AllocKind.h b/js/src/gc/AllocKind.h index 51164846e624..bc6ad738c850 100644 --- a/js/src/gc/AllocKind.h +++ b/js/src/gc/AllocKind.h @@ -61,7 +61,7 @@ namespace gc { #define FOR_EACH_NONOBJECT_NONNURSERY_ALLOCKIND(D) \ /* AllocKind TraceKind TypeName SizedType BGFinal Nursery Compact */ \ D(SCRIPT, Script, JSScript, JSScript, false, false, true) \ - D(LAZY_SCRIPT, LazyScript, js::LazyScript, js::LazyScript, true, false, true) \ + D(LAZY_SCRIPT, Script, js::LazyScript, js::LazyScript, true, false, true) \ D(SHAPE, Shape, js::Shape, js::Shape, true, false, true) \ D(ACCESSOR_SHAPE, Shape, js::AccessorShape, js::AccessorShape, true, false, true) \ D(BASE_SHAPE, BaseShape, js::BaseShape, js::BaseShape, true, false, true) \ diff --git a/js/src/gc/ClearEdgesTracer.h b/js/src/gc/ClearEdgesTracer.h index b776e95536aa..3e3dca1e2e01 100644 --- a/js/src/gc/ClearEdgesTracer.h +++ b/js/src/gc/ClearEdgesTracer.h @@ -27,12 +27,11 @@ struct ClearEdgesTracer final : public JS::CallbackTracer { bool onStringEdge(JSString** strp) override; bool onSymbolEdge(JS::Symbol** symp) override; bool onBigIntEdge(JS::BigInt** bip) override; - bool onScriptEdge(JSScript** scriptp) override; + bool onScriptEdge(js::BaseScript** scriptp) override; bool onShapeEdge(js::Shape** shapep) override; bool onObjectGroupEdge(js::ObjectGroup** groupp) override; bool onBaseShapeEdge(js::BaseShape** basep) override; bool onJitCodeEdge(js::jit::JitCode** codep) override; - bool onLazyScriptEdge(js::LazyScript** lazyp) override; bool onScopeEdge(js::Scope** scopep) override; bool onRegExpSharedEdge(js::RegExpShared** sharedp) override; bool onChild(const JS::GCCellPtr& thing) override; diff --git a/js/src/gc/GC.cpp b/js/src/gc/GC.cpp index 8444faf11257..63601e923e0c 100644 --- a/js/src/gc/GC.cpp +++ b/js/src/gc/GC.cpp @@ -2085,12 +2085,9 @@ bool MovingTracer::onShapeEdge(Shape** shapep) { return updateEdge(shapep); } bool MovingTracer::onStringEdge(JSString** stringp) { return updateEdge(stringp); } -bool MovingTracer::onScriptEdge(JSScript** scriptp) { +bool MovingTracer::onScriptEdge(js::BaseScript** scriptp) { return updateEdge(scriptp); } -bool MovingTracer::onLazyScriptEdge(LazyScript** lazyp) { - return updateEdge(lazyp); -} bool MovingTracer::onBaseShapeEdge(BaseShape** basep) { return updateEdge(basep); } @@ -8649,7 +8646,7 @@ bool js::gc::ClearEdgesTracer::onSymbolEdge(JS::Symbol** symp) { bool js::gc::ClearEdgesTracer::onBigIntEdge(JS::BigInt** bip) { return clearEdge(bip); } -bool js::gc::ClearEdgesTracer::onScriptEdge(JSScript** scriptp) { +bool js::gc::ClearEdgesTracer::onScriptEdge(js::BaseScript** scriptp) { return clearEdge(scriptp); } bool js::gc::ClearEdgesTracer::onShapeEdge(js::Shape** shapep) { @@ -8664,9 +8661,6 @@ bool js::gc::ClearEdgesTracer::onBaseShapeEdge(js::BaseShape** basep) { bool js::gc::ClearEdgesTracer::onJitCodeEdge(js::jit::JitCode** codep) { return clearEdge(codep); } -bool js::gc::ClearEdgesTracer::onLazyScriptEdge(js::LazyScript** lazyp) { - return clearEdge(lazyp); -} bool js::gc::ClearEdgesTracer::onScopeEdge(js::Scope** scopep) { return clearEdge(scopep); } diff --git a/js/src/gc/GC.h b/js/src/gc/GC.h index c6f14c06f22d..69f86378c97d 100644 --- a/js/src/gc/GC.h +++ b/js/src/gc/GC.h @@ -26,6 +26,7 @@ namespace js { class AccessorShape; class FatInlineAtom; class NormalAtom; +class LazyScript; class Nursery; diff --git a/js/src/gc/GCInternals.h b/js/src/gc/GCInternals.h index 756cc6b86bae..347f6a340aee 100644 --- a/js/src/gc/GCInternals.h +++ b/js/src/gc/GCInternals.h @@ -220,8 +220,7 @@ struct MovingTracer final : public JS::CallbackTracer { bool onObjectEdge(JSObject** objp) override; bool onShapeEdge(Shape** shapep) override; bool onStringEdge(JSString** stringp) override; - bool onScriptEdge(JSScript** scriptp) override; - bool onLazyScriptEdge(LazyScript** lazyp) override; + bool onScriptEdge(js::BaseScript** scriptp) override; bool onBaseShapeEdge(BaseShape** basep) override; bool onScopeEdge(Scope** scopep) override; bool onRegExpSharedEdge(RegExpShared** sharedp) override; @@ -247,8 +246,7 @@ struct SweepingTracer final : public JS::CallbackTracer { bool onObjectEdge(JSObject** objp) override; bool onShapeEdge(Shape** shapep) override; bool onStringEdge(JSString** stringp) override; - bool onScriptEdge(JSScript** scriptp) override; - bool onLazyScriptEdge(LazyScript** lazyp) override; + bool onScriptEdge(js::BaseScript** scriptp) override; bool onBaseShapeEdge(BaseShape** basep) override; bool onJitCodeEdge(jit::JitCode** jitp) override; bool onScopeEdge(Scope** scopep) override; diff --git a/js/src/gc/GCMarker.h b/js/src/gc/GCMarker.h index 99cada125aca..f87a83178ad8 100644 --- a/js/src/gc/GCMarker.h +++ b/js/src/gc/GCMarker.h @@ -382,7 +382,6 @@ class GCMarker : public JSTracer { void eagerlyMarkChildren(JSLinearString* str); void eagerlyMarkChildren(JSRope* rope); void eagerlyMarkChildren(JSString* str); - void eagerlyMarkChildren(LazyScript* thing); void eagerlyMarkChildren(Shape* shape); void eagerlyMarkChildren(Scope* scope); void lazilyMarkChildren(ObjectGroup* group); diff --git a/js/src/gc/Marking-inl.h b/js/src/gc/Marking-inl.h index d56e95fff59c..87c756fbd3a4 100644 --- a/js/src/gc/Marking-inl.h +++ b/js/src/gc/Marking-inl.h @@ -67,8 +67,7 @@ struct MightBeForwarded { std::is_base_of::value || std::is_base_of::value || std::is_base_of::value || - std::is_base_of::value || - std::is_base_of::value || + std::is_base_of::value || std::is_base_of::value || std::is_base_of::value; }; diff --git a/js/src/gc/Marking.cpp b/js/src/gc/Marking.cpp index 9c139fd92a01..cafce2769909 100644 --- a/js/src/gc/Marking.cpp +++ b/js/src/gc/Marking.cpp @@ -581,10 +581,8 @@ template void js::TraceManuallyBarrieredCrossCompartmentEdge( JSTracer*, JSObject*, Value*, const char*); template void js::TraceManuallyBarrieredCrossCompartmentEdge( JSTracer*, JSObject*, JSObject**, const char*); -template void js::TraceManuallyBarrieredCrossCompartmentEdge( - JSTracer*, JSObject*, JSScript**, const char*); -template void js::TraceManuallyBarrieredCrossCompartmentEdge( - JSTracer*, JSObject*, LazyScript**, const char*); +template void js::TraceManuallyBarrieredCrossCompartmentEdge( + JSTracer*, JSObject*, BaseScript**, const char*); template void js::TraceWeakMapKeyEdgeInternal(JSTracer* trc, Zone* weakMapZone, @@ -610,11 +608,8 @@ void js::TraceWeakMapKeyEdgeInternal(JSTracer* trc, Zone* weakMapZone, template void js::TraceWeakMapKeyEdgeInternal(JSTracer*, Zone*, JSObject**, const char*); -template void js::TraceWeakMapKeyEdgeInternal(JSTracer*, Zone*, - JSScript**, - const char*); -template void js::TraceWeakMapKeyEdgeInternal(JSTracer*, Zone*, - LazyScript**, +template void js::TraceWeakMapKeyEdgeInternal(JSTracer*, Zone*, + BaseScript**, const char*); template @@ -943,9 +938,9 @@ void GCMarker::traverse(RegExpShared* thing) { } } // namespace js -// Strings, LazyScripts, Shapes, and Scopes are extremely common, but have -// simple patterns of recursion. We traverse trees of these edges immediately, -// with aggressive, manual inlining, implemented by eagerlyTraceChildren. +// Strings, Shapes, and Scopes are extremely common, but have simple patterns of +// recursion. We traverse trees of these edges immediately, with aggressive, +// manual inlining, implemented by eagerlyTraceChildren. template void js::GCMarker::markAndScan(T* thing) { if (ThingIsPermanentAtomOrWellKnownSymbol(thing)) { @@ -961,10 +956,6 @@ void GCMarker::traverse(JSString* thing) { markAndScan(thing); } template <> -void GCMarker::traverse(LazyScript* thing) { - markAndScan(thing); -} -template <> void GCMarker::traverse(Shape* thing) { markAndScan(thing); } @@ -1000,7 +991,7 @@ void GCMarker::traverse(jit::JitCode* thing) { markAndPush(thing); } template <> -void GCMarker::traverse(JSScript* thing) { +void GCMarker::traverse(BaseScript* thing) { markAndPush(thing); } } // namespace js @@ -1147,33 +1138,6 @@ void BaseScript::traceChildren(JSTracer* trc) { } } -inline void js::GCMarker::eagerlyMarkChildren(LazyScript* thing) { - traverseEdge(thing, static_cast(thing->functionOrGlobal_)); - traverseEdge(thing, static_cast(thing->sourceObject_)); - - thing->warmUpData_.trace(this); - - if (thing->data_) { - // Traverse the PrivateScriptData::gcthings() array. - for (JS::GCCellPtr& elem : thing->data_->gcthings()) { - if (elem.is()) { - traverseEdge(thing, &elem.as()); - } else if (elem.is()) { - traverseEdge(thing, &elem.as()); - } else { - MOZ_ASSERT(!elem); - } - } - } - - MOZ_ASSERT(thing->sharedData_ == nullptr, - "LazyScript should not have shared data."); - - // script_ is weak so is not traced here. - - markImplicitEdges(thing); -} - void Shape::traceChildren(JSTracer* trc) { TraceEdge(trc, &base_, "base"); TraceEdge(trc, &propidRef(), "propid"); @@ -1928,7 +1892,7 @@ inline void GCMarker::processMarkStackTop(SliceBudget& budget) { } case MarkStack::ScriptTag: { - auto script = stack.popPtr().as(); + auto script = stack.popPtr().as(); AutoSetTracingSource asts(this, script); return script->traceChildren(this); } @@ -2212,7 +2176,7 @@ struct MapTypeToMarkStackTag { static const auto value = MarkStack::JitCodeTag; }; template <> -struct MapTypeToMarkStackTag { +struct MapTypeToMarkStackTag { static const auto value = MarkStack::ScriptTag; }; @@ -3060,7 +3024,7 @@ static inline void TraceWholeCell(TenuringTracer& mover, JS::BigInt* bi) { bi->traceChildren(&mover); } -static inline void TraceWholeCell(TenuringTracer& mover, JSScript* script) { +static inline void TraceWholeCell(TenuringTracer& mover, BaseScript* script) { script->traceChildren(&mover); } @@ -3105,7 +3069,7 @@ void js::gc::StoreBuffer::WholeCellBuffer::trace(TenuringTracer& mover) { TraceBufferedCells(mover, arena, cells); break; case JS::TraceKind::Script: - TraceBufferedCells(mover, arena, cells); + TraceBufferedCells(mover, arena, cells); break; case JS::TraceKind::JitCode: TraceBufferedCells(mover, arena, cells); @@ -3725,12 +3689,9 @@ bool SweepingTracer::onShapeEdge(Shape** shapep) { return sweepEdge(shapep); } bool SweepingTracer::onStringEdge(JSString** stringp) { return sweepEdge(stringp); } -bool SweepingTracer::onScriptEdge(JSScript** scriptp) { +bool SweepingTracer::onScriptEdge(js::BaseScript** scriptp) { return sweepEdge(scriptp); } -bool SweepingTracer::onLazyScriptEdge(LazyScript** lazyp) { - return sweepEdge(lazyp); -} bool SweepingTracer::onBaseShapeEdge(BaseShape** basep) { return sweepEdge(basep); } diff --git a/js/src/gc/RootMarking.cpp b/js/src/gc/RootMarking.cpp index 18e631325d09..8fa499e38d39 100644 --- a/js/src/gc/RootMarking.cpp +++ b/js/src/gc/RootMarking.cpp @@ -513,7 +513,7 @@ class BufferGrayRootsTracer final : public JS::CallbackTracer { bool onStringEdge(JSString** stringp) override { return bufferRoot(*stringp); } - bool onScriptEdge(JSScript** scriptp) override { + bool onScriptEdge(js::BaseScript** scriptp) override { return bufferRoot(*scriptp); } bool onSymbolEdge(JS::Symbol** symbolp) override { diff --git a/js/src/gc/Tracer.cpp b/js/src/gc/Tracer.cpp index 27c586d562ca..92bac9d5a916 100644 --- a/js/src/gc/Tracer.cpp +++ b/js/src/gc/Tracer.cpp @@ -237,10 +237,6 @@ JS_PUBLIC_API void JS_GetTraceThingInfo(char* buf, size_t bufsize, name = "jitcode"; break; - case JS::TraceKind::LazyScript: - name = "lazyscript"; - break; - case JS::TraceKind::Null: name = "null_pointer"; break; @@ -321,12 +317,6 @@ JS_PUBLIC_API void JS_GetTraceThingInfo(char* buf, size_t bufsize, break; } - case JS::TraceKind::LazyScript: { - LazyScript* script = static_cast(thing); - snprintf(buf, bufsize, " %s:%u", script->filename(), script->lineno()); - break; - } - case JS::TraceKind::String: { *buf++ = ' '; bufsize--; diff --git a/js/src/gdb/mozilla/GCCellPtr.py b/js/src/gdb/mozilla/GCCellPtr.py index b8b91ee1dbe1..06cc60b0ceab 100644 --- a/js/src/gdb/mozilla/GCCellPtr.py +++ b/js/src/gdb/mozilla/GCCellPtr.py @@ -28,12 +28,11 @@ class GCCellPtrTypeCache(object): kind('Object', 'JSObject') kind('String', 'JSString') kind('Symbol', 'JS::Symbol') - kind('Script', 'JSScript') + kind('Script', 'js::BaseScript') kind('Shape', 'js::Shape') kind('ObjectGroup', 'js::ObjectGroup') kind('BaseShape', 'js::BaseShape') kind('JitCode', 'js::jit::JitCode') - kind('LazyScript', 'js::LazyScript') self.kind_to_type = kind_to_type self.Null = e['JS::TraceKind::Null'] diff --git a/js/src/vm/JSFunction.cpp b/js/src/vm/JSFunction.cpp index 6c6a19871f65..54795116fade 100644 --- a/js/src/vm/JSFunction.cpp +++ b/js/src/vm/JSFunction.cpp @@ -803,20 +803,14 @@ inline void JSFunction::trace(JSTracer* trc) { // for self-hosted code. if (isIncomplete()) { MOZ_ASSERT(u.scripted.s.script_ == nullptr); - } else if (hasScript()) { - JSScript* script = static_cast(u.scripted.s.script_); + } else if (hasBaseScript()) { + BaseScript* script = u.scripted.s.script_; TraceManuallyBarrieredEdge(trc, &script, "script"); // Self-hosted scripts are shared with workers but are never // relocated. Skip unnecessary writes to prevent the possible data race. if (u.scripted.s.script_ != script) { u.scripted.s.script_ = script; } - } else if (hasLazyScript()) { - LazyScript* lazy = static_cast(u.scripted.s.script_); - TraceManuallyBarrieredEdge(trc, &lazy, "lazy"); - if (u.scripted.s.script_ != lazy) { - u.scripted.s.script_ = lazy; - } } // NOTE: The u.scripted.s.selfHostedLazy_ does not point to GC things. diff --git a/js/src/vm/JSScript.cpp b/js/src/vm/JSScript.cpp index 8f422cbc254d..69b99bce37be 100644 --- a/js/src/vm/JSScript.cpp +++ b/js/src/vm/JSScript.cpp @@ -5722,7 +5722,7 @@ void JSScript::AutoDelazify::dropScript() { script_ = nullptr; } -JS::ubi::Base::Size JS::ubi::Concrete::size( +JS::ubi::Base::Size JS::ubi::Concrete::size( mozilla::MallocSizeOf mallocSizeOf) const { BaseScript* base = &get(); @@ -5750,22 +5750,6 @@ JS::ubi::Base::Size JS::ubi::Concrete::size( return size; } -const char* JS::ubi::Concrete::scriptFilename() const { +const char* JS::ubi::Concrete::scriptFilename() const { return get().filename(); } - -JS::ubi::Node::Size JS::ubi::Concrete::size( - mozilla::MallocSizeOf mallocSizeOf) const { - Size size = gc::Arena::thingSize(get().asTenured().getAllocKind()); - size += get().sizeOfExcludingThis(mallocSizeOf); - return size; -} - -const char* JS::ubi::Concrete::scriptFilename() const { - auto source = get().scriptSource(); - if (!source) { - return nullptr; - } - - return source->filename(); -} diff --git a/js/src/vm/JSScript.h b/js/src/vm/JSScript.h index e0751c819c15..ce6cadec918e 100644 --- a/js/src/vm/JSScript.h +++ b/js/src/vm/JSScript.h @@ -2526,6 +2526,8 @@ setterLevel: \ friend class GCMarker; friend void js::gc::SweepLazyScripts(GCParallelTask* task); + static const JS::TraceKind TraceKind = JS::TraceKind::Script; + void traceChildren(JSTracer* trc); void finalize(JSFreeOp* fop); @@ -3202,8 +3204,6 @@ class JSScript : public js::BaseScript { // invariants of debuggee compartments, scripts, and frames. inline bool isDebuggee() const; - static const JS::TraceKind TraceKind = JS::TraceKind::Script; - // A helper class to prevent relazification of the given function's script // while it's holding on to it. This class automatically roots the script. class AutoDelazify; @@ -3394,8 +3394,6 @@ class LazyScript : public BaseScript { bool enclosingScriptHasEverBeenCompiled() const { return warmUpData_.isEnclosingScope(); } - - static const JS::TraceKind TraceKind = JS::TraceKind::LazyScript; }; /* If this fails, add/remove padding within LazyScript. */ @@ -3482,24 +3480,12 @@ JSScript* CloneGlobalScript(JSContext* cx, ScopeKind scopeKind, // with no associated compartment. namespace JS { namespace ubi { + template <> -class Concrete : TracerConcrete { - protected: - explicit Concrete(js::LazyScript* ptr) - : TracerConcrete(ptr) {} +class Concrete : public Concrete {}; +template <> +class Concrete : public Concrete {}; - public: - static void construct(void* storage, js::LazyScript* ptr) { - new (storage) Concrete(ptr); - } - - CoarseType coarseType() const final { return CoarseType::Script; } - Size size(mozilla::MallocSizeOf mallocSizeOf) const override; - const char* scriptFilename() const final; - - const char16_t* typeName() const override { return concreteTypeName; } - static const char16_t concreteTypeName[]; -}; } // namespace ubi } // namespace JS diff --git a/js/src/vm/MemoryMetrics.cpp b/js/src/vm/MemoryMetrics.cpp index 065dc19c0f45..76090309f72a 100644 --- a/js/src/vm/MemoryMetrics.cpp +++ b/js/src/vm/MemoryMetrics.cpp @@ -460,14 +460,6 @@ static void StatsCellCallback(JSRuntime* rt, void* data, JS::GCCellPtr cellptr, break; } - case JS::TraceKind::LazyScript: { - LazyScript* lazy = &cellptr.as(); - zStats->lazyScriptsGCHeap += thingSize; - zStats->lazyScriptsMallocHeap += - lazy->sizeOfExcludingThis(rtStats->mallocSizeOf_); - break; - } - case JS::TraceKind::Shape: { Shape* shape = &cellptr.as(); diff --git a/js/src/vm/UbiNode.cpp b/js/src/vm/UbiNode.cpp index c9185e8ea1ba..0c845d517837 100644 --- a/js/src/vm/UbiNode.cpp +++ b/js/src/vm/UbiNode.cpp @@ -256,8 +256,7 @@ JS::Zone* TracerConcrete::zone() const { return get().zoneFromAnyThread(); } -template JS::Zone* TracerConcrete::zone() const; -template JS::Zone* TracerConcrete::zone() const; +template JS::Zone* TracerConcrete::zone() const; template JS::Zone* TracerConcrete::zone() const; template JS::Zone* TracerConcrete::zone() const; template JS::Zone* TracerConcrete::zone() const; @@ -287,9 +286,7 @@ UniquePtr TracerConcrete::edges(JSContext* cx, return UniquePtr(range.release()); } -template UniquePtr TracerConcrete::edges( - JSContext* cx, bool wantNames) const; -template UniquePtr TracerConcrete::edges( +template UniquePtr TracerConcrete::edges( JSContext* cx, bool wantNames) const; template UniquePtr TracerConcrete::edges( JSContext* cx, bool wantNames) const; @@ -318,8 +315,8 @@ Realm* TracerConcreteWithRealm::realm() const { return TracerBase::get().realm(); } -template Realm* TracerConcreteWithRealm::realm() const; -template JS::Compartment* TracerConcreteWithRealm::compartment() +template Realm* TracerConcreteWithRealm::realm() const; +template JS::Compartment* TracerConcreteWithRealm::compartment() const; bool Concrete::hasAllocationStack() const { @@ -372,8 +369,7 @@ Realm* Concrete::realm() const { const char16_t Concrete::concreteTypeName[] = u"JS::Symbol"; const char16_t Concrete::concreteTypeName[] = u"JS::BigInt"; -const char16_t Concrete::concreteTypeName[] = u"JSScript"; -const char16_t Concrete::concreteTypeName[] = u"js::LazyScript"; +const char16_t Concrete::concreteTypeName[] = u"js::BaseScript"; const char16_t Concrete::concreteTypeName[] = u"js::jit::JitCode"; const char16_t Concrete::concreteTypeName[] = u"js::Shape"; diff --git a/js/xpconnect/src/XPCJSRuntime.cpp b/js/xpconnect/src/XPCJSRuntime.cpp index 0e121e69cd0e..f4dd28a198ab 100644 --- a/js/xpconnect/src/XPCJSRuntime.cpp +++ b/js/xpconnect/src/XPCJSRuntime.cpp @@ -1392,15 +1392,6 @@ static void ReportZoneStats(const JS::ZoneStats& zStats, "Extra data attached to each compartment by XPConnect, including " "its wrapped-js."); - ZRREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("lazy-scripts/gc-heap"), - zStats.lazyScriptsGCHeap, - "Scripts that haven't executed yet."); - - ZRREPORT_BYTES( - pathPrefix + NS_LITERAL_CSTRING("lazy-scripts/malloc-heap"), - zStats.lazyScriptsMallocHeap, - "Lazy script tables containing closed-over bindings or inner functions."); - ZRREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("jit-codes-gc-heap"), zStats.jitCodesGCHeap, "References to executable code pools used by the JITs."); @@ -2436,12 +2427,6 @@ void JSReporter::CollectReports(WindowPaths* windowPaths, KIND_OTHER, rtStats.zTotals.unusedGCThings.script, "Unused script cells within non-empty arenas."); - REPORT_BYTES( - NS_LITERAL_CSTRING( - "js-main-runtime-gc-heap-committed/unused/gc-things/lazy-scripts"), - KIND_OTHER, rtStats.zTotals.unusedGCThings.lazyScript, - "Unused lazy script cells within non-empty arenas."); - REPORT_BYTES( NS_LITERAL_CSTRING( "js-main-runtime-gc-heap-committed/unused/gc-things/jitcode"), @@ -2509,11 +2494,6 @@ void JSReporter::CollectReports(WindowPaths* windowPaths, KIND_OTHER, rtStats.realmTotals.scriptsGCHeap, "Used script cells."); - MREPORT_BYTES( - NS_LITERAL_CSTRING( - "js-main-runtime-gc-heap-committed/used/gc-things/lazy-scripts"), - KIND_OTHER, rtStats.zTotals.lazyScriptsGCHeap, "Used lazy script cells."); - MREPORT_BYTES(NS_LITERAL_CSTRING( "js-main-runtime-gc-heap-committed/used/gc-things/jitcode"), KIND_OTHER, rtStats.zTotals.jitCodesGCHeap,