Fix: Root node of current frame may also act as indirect call node.

Author: fangerer

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/CExtNodes.java

@@ -2302,11 +2302,11 @@ void doWithoutFrame(@SuppressWarnings("unused") Frame frame, PException e,
                 // the info on the next call
                 flag[0] = ConditionProfile.createBinaryProfile();
                 if (ref == null) {
-                    ref = PArguments.getCurrentFrameInfo(ReadCallerFrameNode.getCallerFrame(null, FrameInstance.FrameAccess.READ_ONLY, false, 0));
+                    ref = PArguments.getCurrentFrameInfo(ReadCallerFrameNode.getCurrentFrame(this, FrameInstance.FrameAccess.READ_ONLY));
                 }
             }
             if (flag[0].profile(ref == null)) {
-                ref = PArguments.getCurrentFrameInfo(ReadCallerFrameNode.getCallerFrame(null, FrameInstance.FrameAccess.READ_ONLY, false, 0));
+                ref = PArguments.getCurrentFrameInfo(ReadCallerFrameNode.getCurrentFrame(this, FrameInstance.FrameAccess.READ_ONLY));
             }
             transformToNative(context, ref, e);
         }
@@ -2318,7 +2318,7 @@ void doGeneric(Frame frame, PException e,
             if (frame == null) {
                 ref = context.peekTopFrameInfo();
                 if (ref == null) {
-                    ref = PArguments.getCurrentFrameInfo(ReadCallerFrameNode.getCallerFrame(ref, FrameInstance.FrameAccess.READ_ONLY, true, 0));
+                    ref = PArguments.getCurrentFrameInfo(ReadCallerFrameNode.getCurrentFrame(this, FrameInstance.FrameAccess.READ_ONLY));
                 }
             } else {
                 ref = PArguments.getCurrentFrameInfo(frame);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/ReadCallerFrameNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, 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
@@ -58,6 +58,8 @@
 import com.oracle.truffle.api.nodes.RootNode;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
+import java.util.Objects;
+
 @NodeInfo(shortName = "read_caller_fame")
 public final class ReadCallerFrameNode extends Node {
     @CompilationFinal private ConditionProfile cachedCallerFrameProfile;
@@ -137,19 +139,90 @@ private PFrame.Reference walkLevels(VirtualFrame frame, PFrame.Reference startFr
         return currentFrame;
     }
 
+    /**
+     * Walk up the stack to find the currently top Python frame. This method is mostly useful for
+     * code that cannot accept a {@code VirtualFrame} parameter (e.g. library code). It is necessary
+     * to provide the requesting node because it might be necessary to locate the last
+     * {@link IndirectCallNode} that effectively executes the requesting node such that the
+     * necessary assumptions can be invalidated to avoid deopt loops.<br/>
+     * Consider following situation:<br/>
+     * 
+     * <pre>
+     *     public class SomeCaller extends PRootNode implements IndirectCallNode {
+     *         &#64;Child private InteropLibrary lib = ...;
+     *         public Object execute(VirtualFrame frame, Object callee, Object[] args) {
+     *             Object state = IndirectCallContext.enter(frame, ctx, this);
+     *             try {
+     *                 return lib.execute(callee, args);
+     *             } finally {
+     *                 IndirectCallContext.exit(frame, ctx, state);
+     *             }
+     *         }
+     *     }
+     *
+     *     &#64;ExportLibrary(InteropLibrary.class)
+     *     public class ExecObject {
+     *         &#64;ExportMessage
+     *         boolean isExecutable() {
+     *             return true;
+     *         }
+     *
+     *         &#64;ExportMessage
+     *         Object execute(Object[] args,
+     *                            &#64;Cached SomeNode someNode) {
+     *             return someNode.execute(args);
+     *         }
+     *     }
+     *
+     *     public class SomeNode extends Node {
+     *         public Object execute(Object[] args) {
+     *             try {
+     *                 // do some stuff that might throw a PException
+     *             } catch (PException e) {
+     *                 // read currently top Python frame because it's required for exception reification
+     *                 Frame topPyFrame = ReadCallerFrameNode.getCurrentFrame(this
+     *                 // ...
+     *             }
+     *             return PNone.NONE;
+     *         }
+     *     }
+     * </pre>
+     * 
+     * Assume that we run
+     * {@code SomeCaller.create().execute(frame, new ExecObject(), new Object[0])}. It will in the
+     * end run {@code SomeNode.execute} and if that tries to get the current frame, we need to do a
+     * stack walk in the first run. However, on the second run, node {@code SomeCaller} should
+     * already put the current frame reference into the context to avoid subsequent stack walks.
+     * Since there is no Truffle call happening, this can only be achieved if we walk the node's
+     * parent chain.
+     *
+     * @param requestingNode - the frame to start counting from or {@code null} to return the top
+     *            frame
+     * @param frameAccess - the desired {@link FrameInstance} access kind
+     */
+    public static Frame getCurrentFrame(Node requestingNode, FrameInstance.FrameAccess frameAccess) {
+        CompilerDirectives.transferToInterpreterAndInvalidate();
+        return getFrame(Objects.requireNonNull(requestingNode), null, frameAccess, false, 0);
+    }
+
     /**
      * Walk up the stack to find the {@code startFrame} and from then ({@code
      * level} + 1)-times (counting only non-internal Python frames if {@code
      * skipInternal} is true). If {@code startFrame} is {@code null}, return the currently top
      * Python frame.
      *
-     * @param startFrame - the frame to start counting from or {@code null} to return the top frame
+     * @param startFrame - the frame to start counting from (must not be {@code null})
      * @param frameAccess - the desired {@link FrameInstance} access kind
      * @param skipInternal - declares if Python internal frames should be skipped or counted
      * @param level - the stack depth to go to. Ignored if {@code startFrame} is {@code null}
      */
     public static Frame getCallerFrame(PFrame.Reference startFrame, FrameInstance.FrameAccess frameAccess, boolean skipInternal, int level) {
         CompilerDirectives.transferToInterpreterAndInvalidate();
+        return getFrame(null, Objects.requireNonNull(startFrame), frameAccess, skipInternal, level);
+    }
+
+    private static Frame getFrame(Node requestingNode, PFrame.Reference startFrame, FrameInstance.FrameAccess frameAccess, boolean skipInternal, int level) {
+        assert CompilerDirectives.inInterpreter();
         final Frame[] outputFrame = new Frame[1];
         Truffle.getRuntime().iterateFrames(new FrameInstanceVisitor<Frame>() {
             int i = -1;
@@ -187,7 +260,7 @@ public Frame visitFrame(FrameInstance frameInstance) {
                 RootCallTarget target = (RootCallTarget) frameInstance.getCallTarget();
                 RootNode rootNode = target.getRootNode();
                 Node callNode = frameInstance.getCallNode();
-                boolean didMark = IndirectCallNode.setEncapsulatingNeedsToPassCallerFrame(callNode);
+                boolean didMark = IndirectCallNode.setEncapsulatingNeedsToPassCallerFrame(callNode != null ? callNode : requestingNode);
                 if (rootNode instanceof PRootNode && outputFrame[0] == null) {
                     PRootNode pRootNode = (PRootNode) rootNode;
                     pRootNode.setNeedsCallerFrame();