Intrinsify PyNumber_UnaryOp

Author: fangerer

graalpython/com.oracle.graal.python.cext/src/abstract.c

@@ -65,9 +65,10 @@ int PyNumber_Check(PyObject *o) {
     return 0;
 }
 
-UPCALL_ID(PyNumber_UnaryOp);
+typedef PyObject *(*unaryop_fun_t)(PyObject *, int32_t);
+UPCALL_TYPED_ID(PyNumber_UnaryOp, unaryop_fun_t);
 static PyObject * do_unaryop(PyObject *v, UnaryOp unaryop) {
-    return UPCALL_CEXT_O(_jls_PyNumber_UnaryOp, native_to_java(v), unaryop);
+    return _jls_PyNumber_UnaryOp(native_to_java(v), (int32_t)unaryop);
 }
 
 typedef PyObject *(*binop_fun_t)(PyObject *, PyObject *, int32_t);

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

@@ -230,6 +230,7 @@
 import com.oracle.graal.python.nodes.expression.BinaryComparisonNode;
 import com.oracle.graal.python.nodes.expression.InplaceArithmetic;
 import com.oracle.graal.python.nodes.expression.LookupAndCallInplaceNode;
+import com.oracle.graal.python.nodes.expression.UnaryArithmetic;
 import com.oracle.graal.python.nodes.frame.GetCurrentFrameRef;
 import com.oracle.graal.python.nodes.function.FunctionRootNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
@@ -4077,6 +4078,75 @@ static int doBytes(PBytes bytes,
         }
     }
 
+    // directly called without landing function
+    @Builtin(name = "PyNumber_UnaryOp", minNumOfPositionalArgs = 2)
+    @GenerateNodeFactory
+    abstract static class PyNumberUnaryOp extends PythonBinaryBuiltinNode {
+        static int MAX_CACHE_SIZE = UnaryArithmetic.values().length;
+
+        @Specialization(guards = {"cachedOp == op", "left.isIntLike()"}, limit = "MAX_CACHE_SIZE")
+        static Object doIntLikePrimitiveWrapper(VirtualFrame frame, PrimitiveNativeWrapper left, @SuppressWarnings("unused") int op,
+                        @Cached("op") @SuppressWarnings("unused") int cachedOp,
+                        @Cached("createCallNode(op)") LookupAndCallUnaryNode callNode,
+                        @Cached ToNewRefNode toSulongNode,
+                        @Cached TransformExceptionToNativeNode transformExceptionToNativeNode,
+                        @Cached GetNativeNullNode getNativeNullNode) {
+            try {
+                return toSulongNode.execute(callNode.executeObject(frame, left.getLong()));
+            } catch (PException e) {
+                transformExceptionToNativeNode.execute(e);
+                return toSulongNode.execute(getNativeNullNode.execute());
+            }
+        }
+
+        @Specialization(guards = "cachedOp == op", limit = "MAX_CACHE_SIZE", replaces = "doIntLikePrimitiveWrapper")
+        static Object doObject(VirtualFrame frame, Object left, @SuppressWarnings("unused") int op,
+                        @Cached AsPythonObjectNode leftToJava,
+                        @Cached("op") @SuppressWarnings("unused") int cachedOp,
+                        @Cached("createCallNode(op)") LookupAndCallUnaryNode callNode,
+                        @Cached ToNewRefNode toSulongNode,
+                        @Cached TransformExceptionToNativeNode transformExceptionToNativeNode,
+                        @Cached GetNativeNullNode getNativeNullNode) {
+            // still try to avoid expensive materialization of primitives
+            Object result;
+            try {
+                Object leftValue;
+                if (left instanceof PrimitiveNativeWrapper) {
+                    leftValue = PyNumberBinOp.extract((PrimitiveNativeWrapper) left);
+                } else {
+                    leftValue = leftToJava.execute(left);
+                }
+                result = callNode.executeObject(frame, leftValue);
+            } catch (PException e) {
+                transformExceptionToNativeNode.execute(e);
+                result = getNativeNullNode.execute();
+            }
+            return toSulongNode.execute(result);
+        }
+
+        /**
+         * This needs to stay in sync with {@code abstract.c: enum e_unaryop}.
+         */
+        static LookupAndCallUnaryNode createCallNode(int op) {
+            UnaryArithmetic unaryArithmetic;
+            switch (op) {
+                case 0:
+                    unaryArithmetic = UnaryArithmetic.Pos;
+                    break;
+                case 1:
+                    unaryArithmetic = UnaryArithmetic.Neg;
+                    break;
+                case 2:
+                    unaryArithmetic = UnaryArithmetic.Invert;
+                    break;
+                default:
+                    throw CompilerDirectives.shouldNotReachHere("invalid unary operator");
+            }
+            return unaryArithmetic.create();
+        }
+    }
+
+    // directly called without landing function
     @Builtin(name = "PyNumber_BinOp", minNumOfPositionalArgs = 3)
     @GenerateNodeFactory
     abstract static class PyNumberBinOp extends PythonTernaryBuiltinNode {
@@ -4186,6 +4256,7 @@ private static BinaryArithmetic getBinaryArithmetic(int op) {
 
     }
 
+    // directly called without landing function
     @Builtin(name = "PyNumber_InPlaceBinOp", minNumOfPositionalArgs = 3)
     @GenerateNodeFactory
     abstract static class PyNumberInPlaceBinOp extends PythonTernaryBuiltinNode {

graalpython/lib-graalpython/python_cext.py

@@ -459,18 +459,6 @@ def PyNumber_Check(v):
     return _safe_check(v, lambda x: isinstance(int(x), int)) or _safe_check(v, lambda x: isinstance(float(x), float))
 
 
-@may_raise
-def PyNumber_UnaryOp(v, unaryop):
-    if unaryop == 0:
-        return +v
-    elif unaryop == 1:
-        return -v
-    elif unaryop == 2:
-        return ~v
-    else:
-        raise SystemError("unknown unary operator (code=%s)" % unaryop)
-
-
 @may_raise
 def PyNumber_Index(v):
     if not hasattr(v, "__index__"):