Materialize backref frame if still on stack.

Author: fangerer

graalpython/com.oracle.graal.python.test/src/tests/test_backref_chain.py

@@ -0,0 +1,65 @@
+# Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# The Universal Permissive License (UPL), Version 1.0
+#
+# Subject to the condition set forth below, permission is hereby granted to any
+# person obtaining a copy of this software, associated documentation and/or
+# data (collectively the "Software"), free of charge and under any and all
+# copyright rights in the Software, and any and all patent rights owned or
+# freely licensable by each licensor hereunder covering either (i) the
+# unmodified Software as contributed to or provided by such licensor, or (ii)
+# the Larger Works (as defined below), to deal in both
+#
+# (a) the Software, and
+#
+# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+# one is included with the Software each a "Larger Work" to which the Software
+# is contributed by such licensors),
+#
+# without restriction, including without limitation the rights to copy, create
+# derivative works of, display, perform, and distribute the Software and make,
+# use, sell, offer for sale, import, export, have made, and have sold the
+# Software and the Larger Work(s), and to sublicense the foregoing rights on
+# either these or other terms.
+#
+# This license is subject to the following condition:
+#
+# The above copyright notice and either this complete permission notice or at a
+# minimum a reference to the UPL must be included in all copies or substantial
+# portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import sys
+
+def get_frame():
+    return sys._getframe(0)
+
+def foo():
+    f = get_frame()
+    stack = []
+    while f:
+        stack.append(f)
+        f = f.f_back
+    return stack
+
+def bar():
+    return foo()
+
+# NOTE: we need to call it in the module because the test framework will already provide the materialized caller frame
+# and then the test will succeed in any case.
+stack = bar()
+
+def test_backref_chain():
+    actual_fnames = [n.f_code.co_name for n in stack]
+    expected_prefix = ['get_frame', 'foo', 'bar']
+    assert len(stack) >= len(expected_prefix)
+    assert expected_prefix == actual_fnames[:len(expected_prefix)]
+

graalpython/com.oracle.graal.python.test/src/tests/test_frame_tests.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 #
 # The Universal Permissive License (UPL), Version 1.0
@@ -64,6 +64,25 @@ def foo():
         return sys._getframe(0).f_back
     assert foo().f_locals['a'] == 'test_backref'
 
+    def get_frame():
+        return sys._getframe(0)
+
+    def get_frame_caller():
+        return get_frame()
+
+    def do_stackwalk(f):
+        stack = []
+        while f:
+            stack.append(f)
+            f = f.f_back
+        return stack
+
+    stack = do_stackwalk(get_frame_caller())
+    actual_fnames = [n.f_code.co_name for n in stack]
+    expected_prefix = ['get_frame', 'get_frame_caller', 'test_backref']
+    assert len(stack) >= len(expected_prefix)
+    assert expected_prefix == actual_fnames[:len(expected_prefix)]
+
 
 def test_code():
     code = sys._getframe().f_code

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/frame/FrameBuiltins.java

@@ -33,6 +33,7 @@
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.code.CodeNodes;
+import com.oracle.graal.python.builtins.objects.frame.PFrame.Reference;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.builtins.objects.module.PythonModule;
 import com.oracle.graal.python.builtins.objects.object.ObjectBuiltins.DictNode;
@@ -172,6 +173,7 @@ public abstract static class GetBackrefNode extends PythonBuiltinNode {
         Object getBackref(VirtualFrame frame, PFrame self,
                         @Cached BranchProfile noBackref,
                         @Cached BranchProfile topRef,
+                        @Cached("createBinaryProfile()") ConditionProfile notMaterialized,
                         @Cached ReadCallerFrameNode readCallerFrame) {
             PFrame.Reference backref;
             for (PFrame cur = self;; cur = backref.getPyFrame()) {
@@ -199,15 +201,37 @@ Object getBackref(VirtualFrame frame, PFrame self,
                     }
                 }
 
-                if (backref.getPyFrame() == null) {
+                if (backref == Reference.EMPTY) {
                     return PNone.NONE;
                 } else if (!PRootNode.isPythonInternal(backref.getCallNode().getRootNode())) {
-                    return backref.getPyFrame();
+                    PFrame fback = materialize(frame, readCallerFrame, backref, notMaterialized);
+                    assert fback.getRef() == backref;
+                    return fback;
                 }
 
                 assert backref.getPyFrame() != null;
             }
         }
+
+        private static PFrame materialize(VirtualFrame frame, ReadCallerFrameNode readCallerFrameNode, PFrame.Reference backref, ConditionProfile notMaterialized) {
+            if (notMaterialized.profile(backref.getPyFrame() == null)) {
+                // Special case: the backref's PFrame object is not yet available; this is because
+                // the frame is still on the stack. So we need to find and materialize it.
+                for (int i = 0;; i++) {
+                    PFrame caller = readCallerFrameNode.executeWith(frame, i);
+                    if (caller == null) {
+                        break;
+                    } else if (caller.getRef() == backref) {
+                        // now, the PFrame object is available since the readCallerFrameNode
+                        // materialized it
+                        assert backref.getPyFrame() != null;
+                        return caller;
+                    }
+                }
+                assert false : "could not find frame of backref on the stack";
+            }
+            return backref.getPyFrame();
+        }
     }
 
     @Builtin(name = "clear", minNumOfPositionalArgs = 1)