Always pass exception state in IndirectCalleeContext

Author: msimacek

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ConversionNodeTests.java

@@ -101,7 +101,7 @@ public boolean isPythonInternal() {
             PArguments.setException(arguments, PException.NO_EXCEPTION);
             PArguments.setArgument(arguments, 0, arg);
             PythonThreadState threadState = pythonContext.getThreadState(language);
-            Object state = IndirectCalleeContext.enter(threadState, arguments, callTarget);
+            Object state = IndirectCalleeContext.enter(threadState, arguments);
             try {
                 return CallDispatchers.SimpleIndirectInvokeNode.executeUncached(callTarget, arguments);
             } finally {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/GraalPythonModuleBuiltins.java

@@ -391,7 +391,7 @@ private void runFile(PythonContext context, TruffleString inputFilePath) {
             PArguments.setSpecialArgument(arguments, mainDict);
             PArguments.setException(arguments, PException.NO_EXCEPTION);
             context.initializeMainModule(inputFilePath);
-            Object state = ExecutionContext.IndirectCalleeContext.enterIndirect(language, context, arguments, callTarget);
+            Object state = ExecutionContext.IndirectCalleeContext.enter(context.getThreadState(language), arguments);
             try {
                 callTarget.call(arguments);
             } finally {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/SortNodes.java

@@ -321,7 +321,7 @@ private void sortWithoutKey(VirtualFrame frame, Object[] array, int len, boolean
             final RootCallTarget callTarget = getComparatorCallTarget(language);
             if (frame == null) {
                 PythonThreadState threadState = PythonContext.get(this).getThreadState(language);
-                Object state = IndirectCalleeContext.enter(threadState, arguments, callTarget);
+                Object state = IndirectCalleeContext.enter(threadState, arguments);
                 try {
                     callSortWithoutKey(array, len, callTarget, arguments);
                 } finally {
@@ -422,7 +422,7 @@ private void sortWithKey(VirtualFrame frame, Object[] array, int len, Object key
                 final RootCallTarget callTarget = getComparatorCallTarget(language);
                 if (frame == null) {
                     PythonThreadState threadState = PythonContext.get(this).getThreadState(language);
-                    Object state = IndirectCalleeContext.enter(threadState, arguments, callTarget);
+                    Object state = IndirectCalleeContext.enter(threadState, arguments);
                     try {
                         callSortWithKey(pairArray, len, callTarget, arguments);
                     } finally {

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

@@ -121,7 +121,7 @@ static Object doDirect(VirtualFrame frame, Node inliningTarget, DirectCallNode c
             if (profileIsNullFrame.profile(inliningTarget, frame == null)) {
                 PythonContext context = PythonContext.get(inliningTarget);
                 PythonThreadState threadState = context.getThreadState(context.getLanguage(inliningTarget));
-                Object state = IndirectCalleeContext.enter(threadState, arguments, callTarget);
+                Object state = IndirectCalleeContext.enter(threadState, arguments);
                 try {
                     return callNode.call(arguments);
                 } finally {
@@ -160,7 +160,7 @@ static Object doDirect(VirtualFrame frame, Node inliningTarget, RootCallTarget c
             if (profileIsNullFrame.profile(inliningTarget, frame == null)) {
                 PythonContext context = PythonContext.get(inliningTarget);
                 PythonThreadState threadState = context.getThreadState(context.getLanguage(inliningTarget));
-                Object state = IndirectCalleeContext.enterIndirect(threadState, arguments, callTarget);
+                Object state = IndirectCalleeContext.enter(threadState, arguments);
                 try {
                     return callNode.call(callTarget, arguments);
                 } finally {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/exception/TopLevelExceptionHandler.java

@@ -318,7 +318,7 @@ private Object run(VirtualFrame frame) {
         }
         // At the top level we don't have a real Python frame at hand, so we go through
         // IndirectCalleeContext
-        Object state = IndirectCalleeContext.enterIndirect(language, pythonContext, arguments, innerCallTarget);
+        Object state = IndirectCalleeContext.enter(pythonContext.getThreadState(language), arguments);
         try {
             Object result = innerCallTarget.call(arguments);
             if (mainModule != null && result == PNone.NONE && !source.isInteractive()) {

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

@@ -722,44 +722,18 @@ private IndirectCalleeState(PFrame.Reference info, AbstractTruffleException curE
      * asks for it using {@link PRootNode#getCallerFlags()}.
      */
     public abstract static class IndirectCalleeContext {
-        /**
-         * Prepare an indirect call from code that doesn't have access to the current Python
-         * {@link VirtualFrame}, or doesn't have a frame, e.g., foreign code, to a Python function.
-         * <p>
-         * Unlike {@link #enter(PythonLanguage, PythonContext, Object[], RootCallTarget)}, this
-         * method does not assume that the call target argument is a constant.
-         */
-        public static Object enterIndirect(PythonLanguage language, PythonContext context, Object[] pArguments, RootCallTarget callTarget) {
-            return enter(context.getThreadState(language), pArguments, needsExceptionState(callTarget));
-        }
 
         /**
-         * @see #enterIndirect(PythonLanguage, PythonContext, Object[], RootCallTarget)
+         * @see #enter(PythonThreadState, Object[])
          */
-        public static Object enterIndirect(PythonThreadState threadState, Object[] pArguments, RootCallTarget callTarget) {
-            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), pArguments, needsExceptionState(callTarget));
+        public static Object enter(PythonLanguage language, PythonContext context, Object[] pArguments) {
+            return enter(context.getThreadState(language), pArguments);
         }
 
         /**
          * Prepare a call from a foreign frame to a Python function.
          */
-        public static Object enter(PythonThreadState threadState, Object[] pArguments, RootCallTarget callTarget) {
-            return enter(threadState, pArguments, needsExceptionState(callTarget));
-        }
-
-        private static boolean needsExceptionState(RootCallTarget callTarget) {
-            PRootNode calleeRootNode = (PRootNode) callTarget.getRootNode();
-            return CallerFlags.needsExceptionState(calleeRootNode.getCallerFlags());
-        }
-
-        private static Object enter(PythonThreadState threadState, Object[] pArguments, boolean needsExceptionState) {
+        public static Object enter(PythonThreadState threadState, Object[] pArguments) {
             // We decided on if and how to materialize PFrame.Reference/PFrame itself at the point
             // of transition from code with access to virtual frame to the code without access to it
             // (e.g., TruffleBoundary code) in IndirectCallContext
@@ -769,7 +743,7 @@ private static Object enter(PythonThreadState threadState, Object[] pArguments,
             // If someone set the exception in the arguments explicitly, we do not override it. This
             // is used in top level code, async handlers, etc., where we want to avoid pointless
             // stack-walking
-            if (needsExceptionState && PArguments.getException(pArguments) == null) {
+            if (PArguments.getException(pArguments) == null) {
                 AbstractTruffleException curExc = threadState.getCaughtException();
                 if (curExc != null) {
                     threadState.setCaughtException(null);