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

js/src/jscompartment.cpp

@@ -721,23 +721,30 @@ CreateLazyScriptsForCompartment(JSContext* 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.
-            !lazy->hasUncompiledEnclosingScript())
+    for (gc::ZoneCellIter i(cx->zone(), JSFunction::FinalizeKind); !i.done(); i.next()) {
-        {
+        JSObject* obj = i.get<JSObject>();
-            MOZ_ASSERT(fun->isInterpretedLazy());
+        if (obj->compartment() == cx->compartment() && obj->is<JSFunction>()) {
-            MOZ_ASSERT(lazy == fun->lazyScriptOrNull());
+            JSFunction* fun = &obj->as<JSFunction>();
-            if (!lazyFunctions.append(fun))
+            if (fun->isInterpretedLazy()) {
-                return false;
+                LazyScript* lazy = fun->lazyScriptOrNull();
+                if (lazy && lazy->sourceObject() && !lazy->maybeScript() &&
+                    !lazy->hasUncompiledEnclosingScript())
+                {
+                    if (!lazyFunctions.append(fun))
+                        return false;
+                }
+            }
         }
     }
 
@@ -752,10 +759,13 @@ CreateLazyScriptsForCompartment(JSContext* cx)
         if (!fun->isInterpretedLazy())
             continue;
 
+        LazyScript* lazy = fun->lazyScript();
+        bool lazyScriptHadNoScript = !lazy->maybeScript();
+
         JSScript* script = fun->getOrCreateScript(cx);
         if (!script)
             return false;
-        if (!AddInnerLazyFunctionsFromScript(script, lazyFunctions))
+        if (lazyScriptHadNoScript && !AddInnerLazyFunctionsFromScript(script, lazyFunctions))
             return false;
     }