Don't always pass caller frame to indirect calls

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/CallDispatchers.java

@@ -167,7 +167,7 @@ static Object doDirect(VirtualFrame frame, Node inliningTarget, RootCallTarget c
                     IndirectCalleeContext.exit(threadState, state);
                 }
             } else {
-                callContext.prepareIndirectCall(frame, arguments);
+                callContext.prepareIndirectCall(frame, arguments, callTarget);
                 return callNode.call(callTarget, arguments);
             }
         }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/ExecutionContext.java

@@ -177,8 +177,15 @@ public abstract static class CallContext extends Node {
         /**
          * Prepare an indirect call from a Python frame to a Python function.
          */
-        public void prepareIndirectCall(VirtualFrame frame, Object[] callArguments) {
-            executePrepareCall(frame, getActualCallArguments(callArguments), true, true);
+        public void prepareIndirectCall(VirtualFrame frame, Object[] callArguments, RootCallTarget callTarget) {
+            PRootNode pRootNode;
+            RootNode rootNode = callTarget.getRootNode();
+            if (rootNode instanceof ContinuationRootNode continuationRoot) {
+                pRootNode = (PRootNode) continuationRoot.getSourceRootNode();
+            } else {
+                pRootNode = (PRootNode) rootNode;
+            }
+            executePrepareCall(frame, getActualCallArguments(callArguments), pRootNode.needsCallerFrame(), pRootNode.needsExceptionState());
         }
 
         private static Object[] getActualCallArguments(Object[] callArguments) {
@@ -216,6 +223,16 @@ public void prepareCall(VirtualFrame frame, Object[] callArguments, RootCallTarg
 
         protected abstract void executePrepareCall(VirtualFrame frame, Object[] callArguments, boolean needsCallerFrame, boolean needsExceptionState);
 
+        @Specialization
+        protected static void prepareCall(VirtualFrame frame, Object[] callArguments, boolean needsCallerFrame, boolean needsExceptionState,
+                        @Bind Node inliningTarget,
+                        @Cached PassCallerFrameNode passCallerFrame,
+                        @Cached PassExceptionStateNode passExceptionState) {
+            assert PArguments.isPythonFrame(frame) || inliningTarget.getRootNode() instanceof TopLevelExceptionHandler : "calling from non-Python or non-top-level frame";
+            passCallerFrame.execute(frame, inliningTarget, callArguments, needsCallerFrame);
+            passExceptionState.execute(frame, inliningTarget, callArguments, needsExceptionState);
+        }
+
         /**
          * Equivalent to PyPy's ExecutionContext.enter `frame.f_backref = self.topframeref` we here
          * pass the current top frame reference to the next frame. An optimization we do is to only
@@ -346,16 +363,6 @@ protected static void passNoExceptionState(VirtualFrame frame, Node inliningTarg
                 PArguments.setException(callArguments, PException.NO_EXCEPTION);
             }
         }
-
-        @Specialization
-        protected static void prepareCall(VirtualFrame frame, Object[] callArguments, boolean needsCallerFrame, boolean needsExceptionState,
-                        @Bind Node inliningTarget,
-                        @Cached PassCallerFrameNode passCallerFrame,
-                        @Cached PassExceptionStateNode passExceptionState) {
-            assert PArguments.isPythonFrame(frame) || inliningTarget.getRootNode() instanceof TopLevelExceptionHandler : "calling from non-Python or non-top-level frame";
-            passCallerFrame.execute(frame, inliningTarget, callArguments, needsCallerFrame);
-            passExceptionState.execute(frame, inliningTarget, callArguments, needsExceptionState);
-        }
     }
 
     /**
@@ -759,35 +766,28 @@ public abstract static class IndirectCalleeContext {
          * {@link PRootNode#needsExceptionState()}.
          */
         public static Object enterIndirect(PythonLanguage language, PythonContext context, Object[] pArguments, RootCallTarget callTarget) {
-            return enter(context.getThreadState(language), unwrapArgumentsArray(callTarget, pArguments), true);
+            return enter(context.getThreadState(language), pArguments, needsExceptionState(callTarget));
         }
 
         /**
          * @see #enterIndirect(PythonLanguage, PythonContext, Object[], RootCallTarget)
          */
         public static Object enterIndirect(PythonThreadState threadState, Object[] pArguments, RootCallTarget callTarget) {
-            return enter(threadState, unwrapArgumentsArray(callTarget, pArguments), true);
+            return enter(threadState, pArguments, needsExceptionState(callTarget));
         }
 
         /**
          * @see #enter(PythonThreadState, Object[], RootCallTarget)
          */
         public static Object enter(PythonLanguage language, PythonContext context, Object[] pArguments, RootCallTarget callTarget) {
-            return enter(context.getThreadState(language), unwrapArgumentsArray(callTarget, pArguments), needsExceptionState(callTarget));
+            return enter(context.getThreadState(language), pArguments, needsExceptionState(callTarget));
         }
 
         /**
          * Prepare a call from a foreign frame to a Python function.
          */
         public static Object enter(PythonThreadState threadState, Object[] pArguments, RootCallTarget callTarget) {
-            return enter(threadState, unwrapArgumentsArray(callTarget, pArguments), needsExceptionState(callTarget));
-        }
-
-        private static Object[] unwrapArgumentsArray(RootCallTarget callTarget, Object[] arguments) {
-            if (PGenerator.isDSLGeneratorTarget(callTarget)) {
-                return PGenerator.getDSLGeneratorFrame(arguments).getArguments();
-            }
-            return arguments;
+            return enter(threadState, pArguments, needsExceptionState(callTarget));
         }
 
         private static boolean needsExceptionState(RootCallTarget callTarget) {