corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 996982 - Fix Debugger script delazification logic to account for relazified clones. r=bz, a=sledru

Browse Source
This commit is contained in:
Shu-yu Guo
2015-04-07 16:40:34 -07:00
parent 04ab78647c
commit 8d0e3f217e
1 changed files with 28 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
js/src/jscompartment.cpp
View File

@@ -721,25 +721,32 @@ CreateLazyScriptsForCompartment(JSContext* cx)
{ {
AutoObjectVector lazyFunctions(cx); AutoObjectVector lazyFunctions(cx);
// Find all live lazy scripts in the compartment, and via them all root // Find all live root lazy functions in the compartment: those which
// lazy functions in the compartment: those which have not been compiled, // have not been compiled, which have a source object, indicating that
// which have a source object, indicating that they have a parent, and // they have a parent, and which do not have an uncompiled enclosing
// which do not have an uncompiled enclosing script. The last condition is // script. The last condition is so that we don't compile lazy scripts
// so that we don't compile lazy scripts whose enclosing scripts failed to // whose enclosing scripts failed to compile, indicating that the lazy
// compile, indicating that the lazy script did not escape the script. // script did not escape the script.
for (gc::ZoneCellIter i(cx->zone(), gc::FINALIZE_LAZY_SCRIPT); !i.done(); i.next()) { //
LazyScript* lazy = i.get<LazyScript>(); // Note that while we ideally iterate over LazyScripts, LazyScripts do not
JSFunction* fun = lazy->functionNonDelazifying(); // currently stand in 1-1 relation with JSScripts; JSFunctions with the
if (fun->compartment() == cx->compartment() && // same LazyScript may create different JSScripts due to relazification of
lazy->sourceObject() && !lazy->maybeScript() && // clones. See bug 1105306.
for (gc::ZoneCellIter i(cx->zone(), JSFunction::FinalizeKind); !i.done(); i.next()) {
JSObject* obj = i.get<JSObject>();
if (obj->compartment() == cx->compartment() && obj->is<JSFunction>()) {
JSFunction* fun = &obj->as<JSFunction>();
if (fun->isInterpretedLazy()) {
LazyScript* lazy = fun->lazyScriptOrNull();
if (lazy && lazy->sourceObject() && !lazy->maybeScript() &&
!lazy->hasUncompiledEnclosingScript()) !lazy->hasUncompiledEnclosingScript())
{ {
MOZ_ASSERT(fun->isInterpretedLazy());
MOZ_ASSERT(lazy == fun->lazyScriptOrNull());
if (!lazyFunctions.append(fun)) if (!lazyFunctions.append(fun))
return false; return false;
} }
} }
}
}
// Create scripts for each lazy function, updating the list of functions to // Create scripts for each lazy function, updating the list of functions to
// process with any newly exposed inner functions in created scripts. // process with any newly exposed inner functions in created scripts.
@@ -752,10 +759,13 @@ CreateLazyScriptsForCompartment(JSContext* cx)
if (!fun->isInterpretedLazy()) if (!fun->isInterpretedLazy())
continue; continue;
LazyScript* lazy = fun->lazyScript();
bool lazyScriptHadNoScript = !lazy->maybeScript();
JSScript* script = fun->getOrCreateScript(cx); JSScript* script = fun->getOrCreateScript(cx);
if (!script) if (!script)
return false; return false;
if (!AddInnerLazyFunctionsFromScript(script, lazyFunctions)) if (lazyScriptHadNoScript && !AddInnerLazyFunctionsFromScript(script, lazyFunctions))
return false; return false;
} }