Cache 'python_cext' functions directly.

fangerer · fangerer · commit 31bef62bca13 · 2018-10-30T13:20:25.000+01:00
diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.c b/graalpython/com.oracle.graal.python.cext/src/capi.c
@@ -461,9 +461,8 @@ PyObject* WriteULongMember(PyObject* object, Py_ssize_t offset, PyObject* value)
     return value;
 }
 
-UPCALL_ID(__bool__);
 PyObject* WriteBoolMember(PyObject* object, Py_ssize_t offset, PyObject* value) {
-    WriteMember(object, offset, UPCALL_O(native_to_java(value), _jls___bool__) == Py_True ? (char)1 : (char)0, char);
+    WriteMember(object, offset, UPCALL_O(native_to_java(value), polyglot_from_string("__bool__", SRC_CS)) == Py_True ? (char)1 : (char)0, char);
     return value;
 }
 
diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.h b/graalpython/com.oracle.graal.python.cext/src/capi.h
@@ -75,9 +75,13 @@ typedef struct {
 PyAPI_DATA(PyTypeObject) PyBuffer_Type;
 PyAPI_DATA(PyTypeObject) _PyExc_BaseException;
 
+typedef void (*init_upcall)();
+
 extern void *PY_TRUFFLE_CEXT;
 extern void *PY_BUILTIN;
 extern void *Py_NoValue;
+extern init_upcall upcalls[];
+extern unsigned init_upcall_n;
 
 /* upcall functions for calling into Python */
 extern PyObject*(*PY_TRUFFLE_LANDING)(void *rcv, void* name, ...);
@@ -89,13 +93,6 @@ extern uint64_t (*PY_TRUFFLE_CEXT_LANDING_L)(void* name, ...);
 extern double (*PY_TRUFFLE_CEXT_LANDING_D)(void* name, ...);
 extern void* (*PY_TRUFFLE_CEXT_LANDING_PTR)(void* name, ...);
 
-#define UPCALL_ID(name)                                                 \
-    static void* _jls_ ## name;                                         \
-    __attribute__((constructor))                                        \
-    static void init_jls_ ## name(void) {                               \
-        _jls_ ## name = polyglot_from_string(#name, SRC_CS);            \
-    }
-
 /* Call function with return type 'PyObject *'; does polyglot cast and error handling */
 #define UPCALL_O(__recv__, __name__, ...) PY_TRUFFLE_LANDING((__recv__), __name__, ##__VA_ARGS__)
 
@@ -138,6 +135,13 @@ extern void* (*PY_TRUFFLE_CEXT_LANDING_PTR)(void* name, ...);
 /* Call function of 'python_cext' module with return type 'double'; no polyglot cast but error handling */
 #define UPCALL_CEXT_D(__name__, ...) (PY_TRUFFLE_CEXT_LANDING_D(__name__, ##__VA_ARGS__))
 
+#define UPCALL_ID(name)                                                 \
+    static void* _jls_ ## name;                                         \
+    __attribute__((constructor))                                        \
+    static void init_upcall_ ## name(void) {                               \
+       _jls_ ## name = polyglot_get_member(PY_TRUFFLE_CEXT, polyglot_from_string(#name, SRC_CS)); \
+    }
+
 #define as_char_pointer(obj) ((const char*)UPCALL_CEXT_PTR(polyglot_from_string("to_char_pointer", "ascii"), native_to_java(obj)))
 #define as_long(obj) ((long)polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "to_long", to_java(obj))))
 #define as_long_long(obj) ((long long)polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "PyLong_AsPrimitive", to_java(obj), 1, sizeof(long long), polyglot_from_string("long long", "utf-8"))))
diff --git a/graalpython/com.oracle.graal.python.cext/src/dictobject.c b/graalpython/com.oracle.graal.python.cext/src/dictobject.c
@@ -114,9 +114,8 @@ int PyDict_DelItemString(PyObject *d, const char *key) {
     return UPCALL_CEXT_I(_jls_PyDict_DelItem, native_to_java(d), polyglot_from_string(key, SRC_CS));
 }
 
-UPCALL_ID(update);
 int PyDict_Update(PyObject *a, PyObject *b) {
-    PyObject* result = UPCALL_O(native_to_java(a), _jls_update, native_to_java(b));
+    PyObject* result = UPCALL_O(native_to_java(a), polyglot_from_string("update", SRC_CS), native_to_java(b));
     if (PyErr_Occurred()) {
         return -1;
     } else {
diff --git a/graalpython/com.oracle.graal.python.cext/src/errors.c b/graalpython/com.oracle.graal.python.cext/src/errors.c
@@ -45,11 +45,11 @@ void _PyErr_BadInternalCall(const char *filename, int lineno) {
     UPCALL_CEXT_VOID(_jls__PyErr_BadInternalCall, polyglot_from_string(filename, SRC_CS), lineno, native_to_java(NULL));
 }
 
+UPCALL_ID(PyErr_CreateAndSetException);
 #undef PyErr_BadInternalCall
-UPCALL_ID(PyTruffle_Err_Format);
 void PyErr_BadInternalCall(void) {
     assert(0 && "bad argument to internal function");
-    UPCALL_CEXT_VOID(_jls_PyTruffle_Err_Format, native_to_java(PyExc_SystemError), polyglot_from_string("bad argument to internal function", SRC_CS));
+    UPCALL_CEXT_VOID(_jls_PyErr_CreateAndSetException, native_to_java(PyExc_SystemError), polyglot_from_string("bad argument to internal function", SRC_CS));
 }
 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 
@@ -64,7 +64,6 @@ void PyErr_SetString(PyObject *exception, const char *string) {
     PyErr_SetObject(exception, value);
 }
 
-UPCALL_ID(PyErr_CreateAndSetException);
 void PyErr_SetObject(PyObject *exception, PyObject *value) {
     UPCALL_CEXT_VOID(_jls_PyErr_CreateAndSetException, native_to_java(exception), native_to_java(value));
 }
diff --git a/graalpython/com.oracle.graal.python.cext/src/exceptions.c b/graalpython/com.oracle.graal.python.cext/src/exceptions.c
@@ -121,9 +121,8 @@ void initialize_exceptions() {
 }
 
 
-UPCALL_ID(with_traceback);
 int PyException_SetTraceback(PyObject *self, PyObject *tb) {
-    PyObject* result = UPCALL_O(native_to_java(self), _jls_with_traceback, native_to_java(tb));
+    PyObject* result = UPCALL_O(native_to_java(self), polyglot_from_string("with_traceback", SRC_CS), native_to_java(tb));
     if (result == NULL) {
         return -1;
     } else {
diff --git a/graalpython/com.oracle.graal.python.cext/src/functionobject.c b/graalpython/com.oracle.graal.python.cext/src/functionobject.c
@@ -42,7 +42,6 @@
 
 PyTypeObject PyFunction_Type = PY_TRUFFLE_TYPE("function", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(PyFunctionObject));
 
-UPCALL_ID(classmethod);
 PyObject* PyClassMethod_New(PyObject* method) {
-    return UPCALL_O(PY_BUILTIN, _jls_classmethod, native_to_java(method));
+    return UPCALL_O(PY_BUILTIN, polyglot_from_string("classmethod", SRC_CS), native_to_java(method));
 }
diff --git a/graalpython/com.oracle.graal.python.cext/src/import.c b/graalpython/com.oracle.graal.python.cext/src/import.c
@@ -49,10 +49,9 @@ PyObject* PyImport_Import(PyObject *name) {
     return UPCALL_CEXT_O(_jls_PyImport_ImportModule, native_to_java(name));
 }
 
-UPCALL_ID(__import__);
 PyObject* PyImport_ImportModuleLevelObject(PyObject* name, PyObject* globals, PyObject* locals,
                                            PyObject* fromlist, int level) {
-    return UPCALL_O(PY_BUILTIN, _jls___import__, native_to_java(name), native_to_java(globals),
+    return UPCALL_O(PY_BUILTIN, polyglot_from_string("__import__", SRC_CS), native_to_java(name), native_to_java(globals),
                     native_to_java(locals), native_to_java(fromlist), level);
 }
 
diff --git a/graalpython/com.oracle.graal.python.cext/src/modsupport.c b/graalpython/com.oracle.graal.python.cext/src/modsupport.c
@@ -332,7 +332,7 @@ int PyTruffle_Arg_ParseTupleAndKeywords(PyObject *argv, PyObject *kwds, const ch
         case 'p':
             arg = PyTruffle_GetArg(v, kwds, kwdnames, rest_keywords_only);
             PyTruffle_SkipOptionalArg(output_idx, arg, rest_optional);
-            PyTruffle_WriteOut(output_idx, int, (UPCALL_I(native_to_java(arg), _jls___bool__)));
+            PyTruffle_WriteOut(output_idx, int, (UPCALL_I(native_to_java(arg), polyglot_from_string("__bool__", SRC_CS))));
             break;
         case '(':
             arg = PyTruffle_GetArg(v, kwds, kwdnames, rest_keywords_only);
diff --git a/graalpython/com.oracle.graal.python.cext/src/object.c b/graalpython/com.oracle.graal.python.cext/src/object.c
@@ -249,29 +249,25 @@ PyObject* _PyObject_CallMethod_SizeT(PyObject* object, const char* method, const
     return UPCALL_CEXT_O(_jls_PyObject_CallMethod, native_to_java(object), polyglot_from_string(method, SRC_CS), native_to_java(args));
 }
 
-UPCALL_ID(type);
 PyObject* PyObject_Type(PyObject* obj) {
-    return UPCALL_O(PY_BUILTIN, _jls_type, native_to_java(obj));
+    return UPCALL_O(PY_BUILTIN, polyglot_from_string("type", SRC_CS), native_to_java(obj));
 }
 
-UPCALL_ID(__getitem__);
 PyObject* PyObject_GetItem(PyObject* obj, PyObject* key) {
-    return UPCALL_O(native_to_java(obj), _jls___getitem__, native_to_java(key));
+    return UPCALL_O(native_to_java(obj), polyglot_from_string("__getitem__", SRC_CS), native_to_java(key));
 }
 
 UPCALL_ID(PyObject_SetItem);
 int PyObject_SetItem(PyObject* obj, PyObject* key, PyObject* value) {
     return UPCALL_CEXT_I(_jls_PyObject_SetItem, native_to_java(obj), native_to_java(key), native_to_java(value));
 }
 
-UPCALL_ID(__format__);
 PyObject* PyObject_Format(PyObject* obj, PyObject* spec) {
-    return UPCALL_O(native_to_java(obj), _jls___format__, native_to_java(spec));
+    return UPCALL_O(native_to_java(obj), polyglot_from_string("__format__", SRC_CS), native_to_java(spec));
 }
 
-UPCALL_ID(iter);
 PyObject* PyObject_GetIter(PyObject* obj) {
-    return UPCALL_O(PY_BUILTIN, _jls_iter, native_to_java(obj));
+    return UPCALL_O(PY_BUILTIN, polyglot_from_string("iter", SRC_CS), native_to_java(obj));
 }
 
 UPCALL_ID(PyObject_IsInstance);
@@ -344,9 +340,8 @@ int PyObject_GenericSetAttr(PyObject* obj, PyObject* attr, PyObject* value) {
     return PyObject_SetAttr(obj, attr, value);
 }
 
-UPCALL_ID(hash);
 Py_hash_t PyObject_Hash(PyObject* obj) {
-    return UPCALL_I(PY_BUILTIN, _jls_hash, native_to_java(obj));
+    return UPCALL_I(PY_BUILTIN, polyglot_from_string("hash", SRC_CS), native_to_java(obj));
 }
 
 UPCALL_ID(PyObject_HashNotImplemented);
diff --git a/graalpython/com.oracle.graal.python.cext/src/pyhash.c b/graalpython/com.oracle.graal.python.cext/src/pyhash.c
@@ -40,9 +40,8 @@
  */
 #include "capi.h"
 
-UPCALL_ID(hash);
 Py_hash_t _Py_HashDouble(double value) {
-    return UPCALL_L(PY_BUILTIN, _jls_hash, value);
+    return UPCALL_L(PY_BUILTIN, polyglot_from_string("hash", SRC_CS), value);
 }
 
 long _PyHASH_INF;
@@ -56,5 +55,5 @@ void initialize_hashes() {
 }
 
 Py_hash_t _Py_HashBytes(const void *src, Py_ssize_t len) {
-    return UPCALL_L(PY_BUILTIN, _jls_hash, polyglot_from_string(src, "ascii"));
+    return UPCALL_L(PY_BUILTIN, polyglot_from_string("hash", SRC_CS), polyglot_from_string(src, "ascii"));
 }
diff --git a/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c b/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c
@@ -112,7 +112,6 @@ PyObject * PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size) {
     return to_sulong(polyglot_from_string_n(u, size, SRC_CS));
 }
 
-UPCALL_ID(builtin_ascii);
 PyObject* PyTruffle_Unicode_FromFormat(const char* fmt, int s, void* v0, void* v1, void* v2, void* v3, void* v4, void* v5, void* v6, void* v7, void* v8, void* v9, void* v10, void* v11, void* v12, void* v13, void* v14, void* v15, void* v16, void* v17, void* v18, void* v19) {
     char** allocated_strings = calloc(sizeof(char*), s);
 #   define ASSIGN(n, value)                     \
@@ -153,7 +152,7 @@ PyObject* PyTruffle_Unicode_FromFormat(const char* fmt, int s, void* v0, void* v
             case 'A':
                 c[1] = 's';
                 ;
-                allocated_strings[cnt] = allocated = as_char_pointer(UPCALL_CEXT_NOCAST(_jls_builtin_ascii, native_to_java(polyglot_get_arg(cnt + 2))));
+                allocated_strings[cnt] = allocated = as_char_pointer(UPCALL_O(PY_BUILTIN, polyglot_from_string("ascii", SRC_CS), native_to_java(polyglot_get_arg(cnt + 2))));
                 ASSIGN(cnt, allocated);
                 break;
             case 'U':
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TruffleCextBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TruffleCextBuiltins.java
@@ -1774,8 +1774,8 @@ abstract static class UpcallDNode extends PythonBuiltinNode {
     @Builtin(name = "PyTruffle_Upcall_ptr", minNumOfPositionalArgs = 2, takesVarArgs = true)
     @GenerateNodeFactory
     abstract static class UpcallPtrNode extends PythonBuiltinNode {
-        @Child CExtNodes.AsPythonObjectNode toJavaNode = CExtNodes.AsPythonObjectNode.create();
-        @Child CExtNodes.ObjectUpcallNode upcallNode = CExtNodes.ObjectUpcallNode.create();
+        @Child private CExtNodes.AsPythonObjectNode toJavaNode = CExtNodes.AsPythonObjectNode.create();
+        @Child private CExtNodes.ObjectUpcallNode upcallNode = CExtNodes.ObjectUpcallNode.create();
 
         @Specialization
         Object upcall(VirtualFrame frame, Object receiver, String name, Object[] args,
@@ -1793,48 +1793,72 @@ Object upcall(VirtualFrame frame, Object receiver, String name, Object[] args,
     @Builtin(name = "PyTruffle_Cext_Upcall", minNumOfPositionalArgs = 2, takesVarArgs = true, declaresExplicitSelf = true)
     @GenerateNodeFactory
     abstract static class UpcallCextNode extends PythonBuiltinNode {
-        @Child CExtNodes.ToSulongNode toSulongNode = CExtNodes.ToSulongNode.create();
-        @Child CExtNodes.CextUpcallNode upcallNode = CExtNodes.CextUpcallNode.create();
+        @Child private CExtNodes.ToSulongNode toSulongNode = CExtNodes.ToSulongNode.create();
 
         @Specialization
-        Object upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args) {
+        Object upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args,
+                        @Cached("create()") CExtNodes.CextUpcallNode upcallNode) {
             return toSulongNode.execute(upcallNode.execute(frame, cextModule, name, args));
         }
+
+        @Specialization(guards = "!isString(callable)")
+        Object doDirect(VirtualFrame frame, @SuppressWarnings("unused") PythonModule cextModule, Object callable, Object[] args,
+                        @Cached("create()") CExtNodes.DirectUpcallNode upcallNode) {
+            return toSulongNode.execute(upcallNode.execute(frame, callable, args));
+        }
     }
 
     @Builtin(name = "PyTruffle_Cext_Upcall_d", minNumOfPositionalArgs = 2, takesVarArgs = true, declaresExplicitSelf = true)
     @GenerateNodeFactory
     abstract static class UpcallCextDNode extends PythonBuiltinNode {
-        @Child CExtNodes.AsDouble asDoubleNode = CExtNodes.AsDouble.create();
-        @Child CExtNodes.CextUpcallNode upcallNode = CExtNodes.CextUpcallNode.create();
+        @Child private CExtNodes.AsDouble asDoubleNode = CExtNodes.AsDouble.create();
 
         @Specialization
-        double upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args) {
+        double upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args,
+                        @Cached("create()") CExtNodes.CextUpcallNode upcallNode) {
             return asDoubleNode.execute(upcallNode.execute(frame, cextModule, name, args));
         }
+
+        @Specialization(guards = "!isString(callable)")
+        double doDirect(VirtualFrame frame, @SuppressWarnings("unused") PythonModule cextModule, Object callable, Object[] args,
+                        @Cached("create()") CExtNodes.DirectUpcallNode upcallNode) {
+            return asDoubleNode.execute(upcallNode.execute(frame, callable, args));
+        }
     }
 
     @Builtin(name = "PyTruffle_Cext_Upcall_l", minNumOfPositionalArgs = 2, takesVarArgs = true, declaresExplicitSelf = true)
     @GenerateNodeFactory
     abstract static class UpcallCextLNode extends PythonBuiltinNode {
-        @Child CExtNodes.AsLong asLongNode = CExtNodes.AsLong.create();
-        @Child CExtNodes.CextUpcallNode upcallNode = CExtNodes.CextUpcallNode.create();
+        @Child private CExtNodes.AsLong asLongNode = CExtNodes.AsLong.create();
 
         @Specialization
-        long upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args) {
+        long upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args,
+                        @Cached("create()") CExtNodes.CextUpcallNode upcallNode) {
             return asLongNode.execute(upcallNode.execute(frame, cextModule, name, args));
         }
+
+        @Specialization(guards = "!isString(callable)")
+        long doDirect(VirtualFrame frame, @SuppressWarnings("unused") PythonModule cextModule, Object callable, Object[] args,
+                        @Cached("create()") CExtNodes.DirectUpcallNode upcallNode) {
+            return asLongNode.execute(upcallNode.execute(frame, callable, args));
+        }
     }
 
     @Builtin(name = "PyTruffle_Cext_Upcall_ptr", minNumOfPositionalArgs = 2, takesVarArgs = true, declaresExplicitSelf = true)
     @GenerateNodeFactory
     abstract static class UpcallCextPtrNode extends PythonBuiltinNode {
-        @Child CExtNodes.CextUpcallNode upcallNode = CExtNodes.CextUpcallNode.create();
 
         @Specialization
-        Object upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args) {
+        Object upcall(VirtualFrame frame, PythonModule cextModule, String name, Object[] args,
+                        @Cached("create()") CExtNodes.CextUpcallNode upcallNode) {
             return upcallNode.execute(frame, cextModule, name, args);
         }
+
+        @Specialization(guards = "!isString(callable)")
+        Object doDirect(VirtualFrame frame, @SuppressWarnings("unused") PythonModule cextModule, Object callable, Object[] args,
+                        @Cached("create()") CExtNodes.DirectUpcallNode upcallNode) {
+            return upcallNode.execute(frame, callable, args);
+        }
     }
 
     @Builtin(name = "make_may_raise_wrapper", minNumOfPositionalArgs = 1, maxNumOfPositionalArgs = 2)
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/CExtNodes.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/CExtNodes.java
@@ -54,6 +54,7 @@
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.AsLongNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.AsPythonObjectNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.CextUpcallNodeGen;
+import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.DirectUpcallNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.GetNativeClassNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.MaterializeDelegateNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.ObjectUpcallNodeGen;
@@ -940,8 +941,60 @@ public static AllToSulongNode create() {
         }
     }
 
+    public abstract static class DirectUpcallNode extends PNodeWithContext {
+        @Child private AllToJavaNode allToJava;
+
+        protected AllToJavaNode getAllToJavaNode() {
+            if (allToJava == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                allToJava = insert(AllToJavaNode.create());
+            }
+            return allToJava;
+        }
+
+        public abstract Object execute(VirtualFrame frame, Object callable, Object[] args);
+
+        @Specialization(guards = "args.length == 0")
+        Object upcall0(VirtualFrame frame, Object callable, @SuppressWarnings("unused") Object[] args,
+                        @Cached("create()") CallNode callNode) {
+            return callNode.execute(frame, callable, new Object[0], new PKeyword[0]);
+        }
+
+        @Specialization(guards = "args.length == 1")
+        Object upcall1(Object callable, Object[] args,
+                        @Cached("create()") CallUnaryMethodNode callNode,
+                        @Cached("create()") CExtNodes.AsPythonObjectNode toJavaNode) {
+            return callNode.executeObject(callable, toJavaNode.execute(args[0]));
+        }
+
+        @Specialization(guards = "args.length == 2")
+        Object upcall2(Object callable, Object[] args,
+                        @Cached("create()") CallBinaryMethodNode callNode) {
+            Object[] converted = getAllToJavaNode().execute(args);
+            return callNode.executeObject(callable, converted[0], converted[1]);
+        }
+
+        @Specialization(guards = "args.length == 3")
+        Object upcall3(Object callable, Object[] args,
+                        @Cached("create()") CallTernaryMethodNode callNode) {
+            Object[] converted = getAllToJavaNode().execute(args);
+            return callNode.execute(callable, converted[0], converted[1], converted[2]);
+        }
+
+        @Specialization(replaces = {"upcall0", "upcall1", "upcall2", "upcall3"})
+        Object upcall(VirtualFrame frame, Object callable, Object[] args,
+                        @Cached("create()") CallNode callNode) {
+            Object[] converted = getAllToJavaNode().execute(args);
+            return callNode.execute(frame, callable, converted, new PKeyword[0]);
+        }
+
+        public static DirectUpcallNode create() {
+            return DirectUpcallNodeGen.create();
+        }
+    }
+
     protected abstract static class UpcallNode extends PNodeWithContext {
-        @Child AllToJavaNode allToJava = null;
+        @Child private AllToJavaNode allToJava;
 
         protected AllToJavaNode getAllToJavaNode() {
             if (allToJava == null) {

Original file line number	Diff line number	Diff line change
`@@ -461,9 +461,8 @@ PyObject* WriteULongMember(PyObject* object, Py_ssize_t offset, PyObject* value)`
`461`	`461`	`return value;`
`462`	`462`	`}`
`463`	`463`
`464`		`-UPCALL_ID(__bool__);`
`465`	`464`	`PyObject* WriteBoolMember(PyObject* object, Py_ssize_t offset, PyObject* value) {`
`466`		`- WriteMember(object, offset, UPCALL_O(native_to_java(value), _jls___bool__) == Py_True ? (char)1 : (char)0, char);`
	`465`	`+ WriteMember(object, offset, UPCALL_O(native_to_java(value), polyglot_from_string("__bool__", SRC_CS)) == Py_True ? (char)1 : (char)0, char);`
`467`	`466`	`return value;`
`468`	`467`	`}`
`469`	`468`
Original file line number	Diff line number	Diff line change
`@@ -45,11 +45,11 @@ void _PyErr_BadInternalCall(const char *filename, int lineno) {`
`45`	`45`	`UPCALL_CEXT_VOID(_jls__PyErr_BadInternalCall, polyglot_from_string(filename, SRC_CS), lineno, native_to_java(NULL));`
`46`	`46`	`}`
`47`	`47`
	`48`	`+UPCALL_ID(PyErr_CreateAndSetException);`
`48`	`49`	`#undef PyErr_BadInternalCall`
`49`		`-UPCALL_ID(PyTruffle_Err_Format);`
`50`	`50`	`void PyErr_BadInternalCall(void) {`
`51`	`51`	`assert(0 && "bad argument to internal function");`
`52`		`- UPCALL_CEXT_VOID(_jls_PyTruffle_Err_Format, native_to_java(PyExc_SystemError), polyglot_from_string("bad argument to internal function", SRC_CS));`
	`52`	`+ UPCALL_CEXT_VOID(_jls_PyErr_CreateAndSetException, native_to_java(PyExc_SystemError), polyglot_from_string("bad argument to internal function", SRC_CS));`
`53`	`53`	`}`
`54`	`54`	`#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)`
`55`	`55`
`@@ -64,7 +64,6 @@ void PyErr_SetString(PyObject exception, const char string) {`
`64`	`64`	`PyErr_SetObject(exception, value);`
`65`	`65`	`}`
`66`	`66`
`67`		`-UPCALL_ID(PyErr_CreateAndSetException);`
`68`	`67`	`void PyErr_SetObject(PyObject exception, PyObject value) {`
`69`	`68`	`UPCALL_CEXT_VOID(_jls_PyErr_CreateAndSetException, native_to_java(exception), native_to_java(value));`
`70`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,9 +121,8 @@ void initialize_exceptions() {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`
`124`		`-UPCALL_ID(with_traceback);`
`125`	`124`	`int PyException_SetTraceback(PyObject self, PyObject tb) {`
`126`		`- PyObject* result = UPCALL_O(native_to_java(self), _jls_with_traceback, native_to_java(tb));`
	`125`	`+ PyObject* result = UPCALL_O(native_to_java(self), polyglot_from_string("with_traceback", SRC_CS), native_to_java(tb));`
`127`	`126`	`if (result == NULL) {`
`128`	`127`	`return -1;`
`129`	`128`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,6 @@`
`42`	`42`
`43`	`43`	`PyTypeObject PyFunction_Type = PY_TRUFFLE_TYPE("function", &PyType_Type, Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC, sizeof(PyFunctionObject));`
`44`	`44`
`45`		`-UPCALL_ID(classmethod);`
`46`	`45`	`PyObject* PyClassMethod_New(PyObject* method) {`
`47`		`- return UPCALL_O(PY_BUILTIN, _jls_classmethod, native_to_java(method));`
	`46`	`+ return UPCALL_O(PY_BUILTIN, polyglot_from_string("classmethod", SRC_CS), native_to_java(method));`
`48`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,10 +49,9 @@ PyObject* PyImport_Import(PyObject *name) {`
`49`	`49`	`return UPCALL_CEXT_O(_jls_PyImport_ImportModule, native_to_java(name));`
`50`	`50`	`}`
`51`	`51`
`52`		`-UPCALL_ID(__import__);`
`53`	`52`	`PyObject* PyImport_ImportModuleLevelObject(PyObject* name, PyObject* globals, PyObject* locals,`
`54`	`53`	`PyObject* fromlist, int level) {`
`55`		`- return UPCALL_O(PY_BUILTIN, _jls___import__, native_to_java(name), native_to_java(globals),`
	`54`	`+ return UPCALL_O(PY_BUILTIN, polyglot_from_string("__import__", SRC_CS), native_to_java(name), native_to_java(globals),`
`56`	`55`	`native_to_java(locals), native_to_java(fromlist), level);`
`57`	`56`	`}`
`58`	`57`
Original file line number	Diff line number	Diff line change
`@@ -249,29 +249,25 @@ PyObject* _PyObject_CallMethod_SizeT(PyObject* object, const char* method, const`
`249`	`249`	`return UPCALL_CEXT_O(_jls_PyObject_CallMethod, native_to_java(object), polyglot_from_string(method, SRC_CS), native_to_java(args));`
`250`	`250`	`}`
`251`	`251`
`252`		`-UPCALL_ID(type);`
`253`	`252`	`PyObject* PyObject_Type(PyObject* obj) {`
`254`		`- return UPCALL_O(PY_BUILTIN, _jls_type, native_to_java(obj));`
	`253`	`+ return UPCALL_O(PY_BUILTIN, polyglot_from_string("type", SRC_CS), native_to_java(obj));`
`255`	`254`	`}`
`256`	`255`
`257`		`-UPCALL_ID(__getitem__);`
`258`	`256`	`PyObject* PyObject_GetItem(PyObject* obj, PyObject* key) {`
`259`		`- return UPCALL_O(native_to_java(obj), _jls___getitem__, native_to_java(key));`
	`257`	`+ return UPCALL_O(native_to_java(obj), polyglot_from_string("__getitem__", SRC_CS), native_to_java(key));`
`260`	`258`	`}`
`261`	`259`
`262`	`260`	`UPCALL_ID(PyObject_SetItem);`
`263`	`261`	`int PyObject_SetItem(PyObject* obj, PyObject* key, PyObject* value) {`
`264`	`262`	`return UPCALL_CEXT_I(_jls_PyObject_SetItem, native_to_java(obj), native_to_java(key), native_to_java(value));`
`265`	`263`	`}`
`266`	`264`
`267`		`-UPCALL_ID(__format__);`
`268`	`265`	`PyObject* PyObject_Format(PyObject* obj, PyObject* spec) {`
`269`		`- return UPCALL_O(native_to_java(obj), _jls___format__, native_to_java(spec));`
	`266`	`+ return UPCALL_O(native_to_java(obj), polyglot_from_string("__format__", SRC_CS), native_to_java(spec));`
`270`	`267`	`}`
`271`	`268`
`272`		`-UPCALL_ID(iter);`
`273`	`269`	`PyObject* PyObject_GetIter(PyObject* obj) {`
`274`		`- return UPCALL_O(PY_BUILTIN, _jls_iter, native_to_java(obj));`
	`270`	`+ return UPCALL_O(PY_BUILTIN, polyglot_from_string("iter", SRC_CS), native_to_java(obj));`
`275`	`271`	`}`
`276`	`272`
`277`	`273`	`UPCALL_ID(PyObject_IsInstance);`
`@@ -344,9 +340,8 @@ int PyObject_GenericSetAttr(PyObject* obj, PyObject* attr, PyObject* value) {`
`344`	`340`	`return PyObject_SetAttr(obj, attr, value);`
`345`	`341`	`}`
`346`	`342`
`347`		`-UPCALL_ID(hash);`
`348`	`343`	`Py_hash_t PyObject_Hash(PyObject* obj) {`
`349`		`- return UPCALL_I(PY_BUILTIN, _jls_hash, native_to_java(obj));`
	`344`	`+ return UPCALL_I(PY_BUILTIN, polyglot_from_string("hash", SRC_CS), native_to_java(obj));`
`350`	`345`	`}`
`351`	`346`
`352`	`347`	`UPCALL_ID(PyObject_HashNotImplemented);`
Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,8 @@`
`40`	`40`	`*/`
`41`	`41`	`#include "capi.h"`
`42`	`42`
`43`		`-UPCALL_ID(hash);`
`44`	`43`	`Py_hash_t _Py_HashDouble(double value) {`
`45`		`- return UPCALL_L(PY_BUILTIN, _jls_hash, value);`
	`44`	`+ return UPCALL_L(PY_BUILTIN, polyglot_from_string("hash", SRC_CS), value);`
`46`	`45`	`}`
`47`	`46`
`48`	`47`	`long _PyHASH_INF;`
`@@ -56,5 +55,5 @@ void initialize_hashes() {`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`Py_hash_t _Py_HashBytes(const void *src, Py_ssize_t len) {`
`59`		`- return UPCALL_L(PY_BUILTIN, _jls_hash, polyglot_from_string(src, "ascii"));`
	`58`	`+ return UPCALL_L(PY_BUILTIN, polyglot_from_string("hash", SRC_CS), polyglot_from_string(src, "ascii"));`
`60`	`59`	`}`