Move builtin input behind a boundary

Author: msimacek

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

@@ -2618,78 +2618,75 @@ abstract static class InputNode extends PythonUnaryBuiltinNode {
         static Object input(VirtualFrame frame, Object prompt,
                         @Bind Node inliningTarget,
                         @Bind PythonContext context,
-                        @Cached SysModuleBuiltins.AuditNode auditNode,
-                        @Cached PyObjectCallMethodObjArgs callMethod,
-                        @Cached PyObjectStrAsObjectNode strNode,
-                        @Cached PyObjectLookupAttr lookupAttr,
-                        @Cached PyBytesCheckNode bytesCheck,
-                        @Cached PyUnicodeCheckNode unicodeCheck,
-                        @Cached CastToTruffleStringNode castToTruffleStringNode,
-                        @Cached TruffleString.CodePointLengthNode codePointLengthNode,
-                        @Cached TruffleString.CodePointAtIndexNode codePointAtIndexNode,
-                        @Cached TruffleString.SubstringNode substringNode,
-                        @Cached BytesNodes.ToBytesNode toBytesNode,
-                        @Cached PRaiseNode raiseLostNode,
-                        @Cached PRaiseNode raiseEOFNode,
-                        @Cached PRaiseNode raiseWrongType) {
+                        @Cached("createFor($node)") IndirectCallData indirectCallData) {
+            Object savedState = IndirectCallContext.enter(frame, inliningTarget, indirectCallData);
+            try {
+                return doInput(prompt, inliningTarget, context);
+            } finally {
+                IndirectCallContext.exit(frame, inliningTarget, indirectCallData, savedState);
+            }
+        }
+
+        @TruffleBoundary
+        private static Object doInput(Object prompt, Node inliningTarget, PythonContext context) {
             PythonModule sysModule = context.getSysModule();
-            Object stdin = lookupAttr.execute(frame, inliningTarget, sysModule, T_STDIN);
-            Object stdout = lookupAttr.execute(frame, inliningTarget, sysModule, T_STDOUT);
-            Object stderr = lookupAttr.execute(frame, inliningTarget, sysModule, T_STDERR);
+            Object stdin = PyObjectLookupAttr.executeUncached(sysModule, T_STDIN);
+            Object stdout = PyObjectLookupAttr.executeUncached(sysModule, T_STDOUT);
+            Object stderr = PyObjectLookupAttr.executeUncached(sysModule, T_STDERR);
 
             if (stdin instanceof PNone) {
-                throw raiseLostNode.raise(inliningTarget, RuntimeError, ErrorMessages.INPUT_LOST_SYS_S, T_STDIN);
+                throw PRaiseNode.raiseStatic(inliningTarget, RuntimeError, ErrorMessages.INPUT_LOST_SYS_S, T_STDIN);
             }
             if (stdout instanceof PNone) {
-                throw raiseLostNode.raise(inliningTarget, RuntimeError, ErrorMessages.INPUT_LOST_SYS_S, T_STDOUT);
+                throw PRaiseNode.raiseStatic(inliningTarget, RuntimeError, ErrorMessages.INPUT_LOST_SYS_S, T_STDOUT);
             }
             if (stderr instanceof PNone) {
-                throw raiseLostNode.raise(inliningTarget, RuntimeError, ErrorMessages.INPUT_LOST_SYS_S, T_STDERR);
+                throw PRaiseNode.raiseStatic(inliningTarget, RuntimeError, ErrorMessages.INPUT_LOST_SYS_S, T_STDERR);
             }
 
-            auditNode.audit(inliningTarget, "builtins.input", prompt != NO_VALUE ? prompt : NONE);
+            SysModuleBuiltins.AuditNode.auditUncached("builtins.input", prompt != NO_VALUE ? prompt : NONE);
 
             try {
-                callMethod.execute(frame, inliningTarget, stderr, T_FLUSH);
+                PyObjectCallMethodObjArgs.executeUncached(stderr, T_FLUSH);
             } catch (AbstractTruffleException e) {
                 // Ignore
             }
 
             if (!(prompt instanceof PNone)) {
-                Object promptStr = strNode.execute(frame, inliningTarget, prompt);
-                callMethod.execute(frame, inliningTarget, stdout, T_WRITE, promptStr);
+                Object promptStr = PyObjectStrAsObjectNode.executeUncached(prompt);
+                PyObjectCallMethodObjArgs.executeUncached(stdout, T_WRITE, promptStr);
                 try {
-                    callMethod.execute(frame, inliningTarget, stdout, T_FLUSH);
+                    PyObjectCallMethodObjArgs.executeUncached(stdout, T_FLUSH);
                 } catch (AbstractTruffleException e) {
                     // Ignore
                 }
             }
 
-            Object line = callMethod.execute(frame, inliningTarget, stdin, T_READLINE);
-            if (unicodeCheck.execute(inliningTarget, line)) {
-                TruffleString strLine = castToTruffleStringNode.castKnownString(inliningTarget, line);
-                int len = codePointLengthNode.execute(strLine, TS_ENCODING);
+            Object line = PyObjectCallMethodObjArgs.executeUncached(stdin, T_READLINE);
+            if (PyUnicodeCheckNode.executeUncached(line)) {
+                TruffleString strLine = CastToTruffleStringNode.castKnownStringUncached(line);
+                int len = strLine.codePointLengthUncached(TS_ENCODING);
                 if (len == 0) {
-                    throw raiseEOFNode.raise(inliningTarget, EOFError, ErrorMessages.EOF_WHEN_READING_A_LINE);
+                    throw PRaiseNode.raiseStatic(inliningTarget, EOFError, ErrorMessages.EOF_WHEN_READING_A_LINE);
                 }
-                int lastChar = codePointAtIndexNode.execute(strLine, len - 1, TS_ENCODING);
+                int lastChar = strLine.codePointAtIndexUncached(len - 1, TS_ENCODING);
                 if (lastChar == '\n') {
-                    strLine = substringNode.execute(strLine, 0, len - 1, TS_ENCODING, false);
+                    strLine = strLine.substringUncached(0, len - 1, TS_ENCODING, false);
                 }
                 return strLine;
-            } else if (bytesCheck.execute(inliningTarget, line)) {
-                byte[] bytesLine = toBytesNode.execute(frame, line);
+            } else if (PyBytesCheckNode.executeUncached(line)) {
+                byte[] bytesLine = PythonBufferAccessLibrary.getUncached().getCopiedByteArray(BytesNodes.GetBytesStorage.executeUncached(line));
                 if (bytesLine.length == 0) {
-                    throw raiseEOFNode.raise(inliningTarget, EOFError, ErrorMessages.EOF_WHEN_READING_A_LINE);
+                    throw PRaiseNode.raiseStatic(inliningTarget, EOFError, ErrorMessages.EOF_WHEN_READING_A_LINE);
                 }
-                PythonLanguage language = context.getLanguage(inliningTarget);
+                PythonLanguage language = context.getLanguage();
                 if (bytesLine[bytesLine.length - 1] == '\n') {
                     return PFactory.createBytes(language, bytesLine, bytesLine.length - 1);
                 } else {
                     return PFactory.createBytes(language, bytesLine);
                 }
             } else {
-                throw raiseWrongType.raise(inliningTarget, TypeError, ErrorMessages.OBJECT_READLINE_RETURNED_NON_STRING);
+                throw PRaiseNode.raiseStatic(inliningTarget, TypeError, ErrorMessages.OBJECT_READLINE_RETURNED_NON_STRING);
             }
         }
     }

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

@@ -1050,6 +1050,10 @@ public void audit(Node inliningTarget, String event, Object... arguments) {
             executeInternal(inliningTarget, event, arguments);
         }
 
+        public static void auditUncached(String event, Object... arguments) {
+            SysModuleBuiltinsFactory.AuditNodeGen.getUncached().executeInternal(null, event, arguments);
+        }
+
         public void audit(Node inliningTarget, TruffleString event, Object... arguments) {
             executeInternal(inliningTarget, event, arguments);
         }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/BytesNodes.java

@@ -951,6 +951,10 @@ static byte[] nonAscii(TruffleString str,
     public abstract static class GetBytesStorage extends Node {
         public abstract SequenceStorage execute(Node inliningTarget, Object bytes);
 
+        public static SequenceStorage executeUncached(Object bytes) {
+            return BytesNodesFactory.GetBytesStorageNodeGen.getUncached().execute(null, bytes);
+        }
+
         @Specialization
         SequenceStorage getManaged(PBytesLike bytes) {
             return bytes.getSequenceStorage();

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/lib/PyObjectStrAsObjectNode.java

@@ -89,6 +89,10 @@ public final Object execute(Node inliningTarget, Object object) {
         return execute(null, inliningTarget, object);
     }
 
+    public static Object executeUncached(Object object) {
+        return getUncached().execute(null, null, object);
+    }
+
     @Specialization
     static Object str(TruffleString obj) {
         return obj;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/util/CastToTruffleStringNode.java

@@ -106,6 +106,14 @@ public final TruffleString castKnownString(Node inliningTarget, Object x) {
         }
     }
 
+    public static TruffleString castKnownStringUncached(Object x) {
+        try {
+            return executeUncached(x);
+        } catch (CannotCastException ex) {
+            throw CompilerDirectives.shouldNotReachHere(ex);
+        }
+    }
+
     @Specialization
     static TruffleString doTruffleString(TruffleString x) {
         return x;