[GR-16853] Remove PYPY_VERSION.

PullRequest: graalpython/1860

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/Python.h

@@ -41,15 +41,31 @@
 #ifndef Py_PYTHON_H
 #define Py_PYTHON_H
 
+#include "pyconfig.h"
+
 #define HAVE_UTIME_H
 #define HAVE_UNISTD_H
 #define HAVE_SIGNAL_H
 #define HAVE_FCNTL_H
 #define HAVE_SYS_WAIT_H
 
 #define GRAALVM_PYTHON 1
-#define PYPY_VERSION 0
-#define PYPY_VERSION_NUM 0x07030000
+
+/* If Cython is involved, avoid accesses to internal structures. While we are
+ * supporting this in many cases, it still involves overhead. */
+#define CYTHON_USE_TYPE_SLOTS 0
+#define CYTHON_USE_PYTYPE_LOOKUP 0
+#define CYTHON_FAST_PYCCALL 0
+#define CYTHON_USE_DICT_VERSIONS 0
+#define CYTHON_AVOID_BORROWED_REFS 1
+#define CYTHON_USE_TP_FINALIZE 0
+#define CYTHON_USE_PYLIST_INTERNALS 0
+#define CYTHON_USE_UNICODE_INTERNALS 0
+#define CYTHON_USE_PYLONG_INTERNALS 0
+#define CYTHON_USE_ASYNC_SLOTS 0
+#define CYTHON_USE_UNICODE_WRITER 0
+#define CYTHON_USE_EXC_INFO_STACK 0
+#define CYTHON_FAST_THREAD_STATE 0
 
 #include <stdio.h>
 #include <string.h>
@@ -129,4 +145,6 @@
 
 #include "abstract.h"
 
+#include "eval.h"
+
 #endif

graalpython/com.oracle.graal.python.cext/include/eval.h

@@ -0,0 +1,42 @@
+/* Copyright (c) 2021, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2020 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+
+/* Interface to execute compiled code */
+
+#ifndef Py_EVAL_H
+#define Py_EVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyObject *, PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co,
+                                         PyObject *globals,
+                                         PyObject *locals,
+                                         PyObject *const *args, int argc,
+                                         PyObject *const *kwds, int kwdc,
+                                         PyObject *const *defs, int defc,
+                                         PyObject *kwdefs, PyObject *closure);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PyEval_EvalCodeWithName(
+    PyObject *co,
+    PyObject *globals, PyObject *locals,
+    PyObject *const *args, Py_ssize_t argcount,
+    PyObject *const *kwnames, PyObject *const *kwargs,
+    Py_ssize_t kwcount, int kwstep,
+    PyObject *const *defs, Py_ssize_t defcount,
+    PyObject *kwdefs, PyObject *closure,
+    PyObject *name, PyObject *qualname);
+
+PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_EVAL_H */

graalpython/com.oracle.graal.python.cext/include/pyconfig.h

@@ -41,6 +41,11 @@
 #ifndef Py_PYCONFIG_H
 #define Py_PYCONFIG_H
 
+/* Enable GNU extensions on systems that have them. */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE 1
+#endif
+
 // required for __UINT32_MAX__ etc.
 #include <limits.h>
 

graalpython/com.oracle.graal.python.cext/posix/fork_exec.c

@@ -3,8 +3,8 @@
  *
  * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
  */
-#ifdef __gnu_linux__
-#define _GNU_SOURCE
+#if defined(__gnu_linux__) && !defined(_GNU_SOURCE)
+#define _GNU_SOURCE 1
 #endif
 
 #include <unistd.h>

graalpython/com.oracle.graal.python.cext/posix/posix.c

@@ -44,8 +44,8 @@
 
 // This file uses GNU extensions. Functions that require non-GNU versions (e.g. strerror_r)
 // need to go to posix_no_gnu.c
-#ifdef __gnu_linux__
-#define _GNU_SOURCE
+#if defined(__gnu_linux__) && !defined(_GNU_SOURCE)
+#define _GNU_SOURCE 1
 #endif
 
 #include <arpa/inet.h>

graalpython/com.oracle.graal.python.cext/setup.py

@@ -473,6 +473,9 @@ def build_nativelibsupport(capi_home, subdir, libname, deps=[], **kwargs):
 def build_libposix(capi_home):
     src_dir = os.path.join(__dir__, "posix")
     files = [os.path.abspath(os.path.join(src_dir, f)) for f in os.listdir(src_dir) if f.endswith(".c")]
+    no_gnu_source = get_config_var("USE_GNU_SOURCE")
+    if no_gnu_source:
+        get_config_vars()["CFLAGS"] = get_config_var("CFLAGS_DEFAULT")
     module = Extension(libposix_name,
                        sources=files,
                        libraries=['crypt'] if not darwin_native else [],
@@ -486,6 +489,8 @@ def build_libposix(capi_home):
         description="Graal Python's Native support for the POSIX library",
         ext_modules=[module],
     )
+    if no_gnu_source:
+        get_config_vars()["CFLAGS"] = get_config_var("CFLAGS_DEFAULT") + " " + get_config_var("USE_GNU_SOURCE")
 
 
 def build_builtin_exts(capi_home):

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

@@ -179,7 +179,7 @@ declare_type(PyFloat_Type, float, PyFloatObject);
 declare_type(PySlice_Type, slice, PySliceObject);
 declare_type(PyByteArray_Type, bytearray, PyByteArrayObject);
 declare_type(PyCFunction_Type, builtin_function_or_method, PyCFunctionObject);
-declare_type(PyWrapperDescr_Type, method_descriptor, PyWrapperDescrObject); // LS: previously wrapper_descriptor
+declare_type(PyWrapperDescr_Type, wrapper_descriptor, PyWrapperDescrObject);
 // tfel: Both method_descriptor maps to both PyWrapperDescr_Type and
 // PyMethodDescr_Type. This reflects our interpreter, but we need to make sure
 // that the dynamic type for method_descriptor is always going to be
@@ -210,10 +210,79 @@ initialize_type(PyEllipsis_Type, ellipsis, _object);
 initialize_type(_PyWeakref_ProxyType, ProxyType, PyWeakReference);
 initialize_type(_PyWeakref_CallableProxyType, CallableProxyType, PyWeakReference);
 
-POLYGLOT_DECLARE_TYPE(PyThreadState);
 POLYGLOT_DECLARE_TYPE(newfunc);
 POLYGLOT_DECLARE_TYPE(Py_buffer);
 
+/* primitive and pointer type declarations */
+
+#define REGISTER_BASIC_TYPE(typename)                                     \
+    POLYGLOT_DECLARE_TYPE(typename);                                      \
+    NO_INLINE polyglot_typeid get_ ## typename ## _typeid(void)  {        \
+		return polyglot_ ## typename ## _typeid();                        \
+    }
+
+/* just a renaming to avoid name clash with Java types */
+typedef void*              void_ptr_t;
+typedef char               char_t;
+typedef float              float_t;
+typedef double             double_t;
+typedef int                int_t;
+typedef unsigned int       uint_t;
+typedef long               long_t;
+typedef unsigned long      ulong_t;
+typedef long long          longlong_t;
+typedef unsigned long long ulonglong_t;
+
+REGISTER_BASIC_TYPE(void_ptr_t);
+REGISTER_BASIC_TYPE(int_t);
+REGISTER_BASIC_TYPE(uint_t);
+REGISTER_BASIC_TYPE(long_t);
+REGISTER_BASIC_TYPE(ulong_t);
+REGISTER_BASIC_TYPE(longlong_t);
+REGISTER_BASIC_TYPE(ulonglong_t);
+REGISTER_BASIC_TYPE(int64_t);
+REGISTER_BASIC_TYPE(int32_t);
+REGISTER_BASIC_TYPE(int16_t);
+REGISTER_BASIC_TYPE(int8_t);
+REGISTER_BASIC_TYPE(uint64_t);
+REGISTER_BASIC_TYPE(uint32_t);
+REGISTER_BASIC_TYPE(uint16_t);
+REGISTER_BASIC_TYPE(uint8_t);
+REGISTER_BASIC_TYPE(Py_complex);
+REGISTER_BASIC_TYPE(char_t);
+REGISTER_BASIC_TYPE(PyObject);
+REGISTER_BASIC_TYPE(PyTypeObject);
+REGISTER_BASIC_TYPE(float_t);
+REGISTER_BASIC_TYPE(double_t);
+REGISTER_BASIC_TYPE(Py_ssize_t);
+REGISTER_BASIC_TYPE(size_t);
+REGISTER_BASIC_TYPE(PyThreadState);
+
+/* For pointers, make them look like an array of size 1 such that it is
+   possible to dereference the pointer by accessing element 0. */
+#define REGISTER_POINTER_TYPE(basetype, ptrtype)                                  \
+    typedef basetype* ptrtype;                                                    \
+    POLYGLOT_DECLARE_TYPE(ptrtype);                                               \
+    NO_INLINE polyglot_typeid get_ ## ptrtype ## _typeid(void)  {                \
+		return polyglot_array_typeid(polyglot_ ## basetype ## _typeid(), 1);      \
+    }
+
+REGISTER_POINTER_TYPE(int64_t, int64_ptr_t);
+REGISTER_POINTER_TYPE(int32_t, int32_ptr_t);
+REGISTER_POINTER_TYPE(int16_t, int16_ptr_t);
+REGISTER_POINTER_TYPE(int8_t, int8_ptr_t);
+REGISTER_POINTER_TYPE(char_t, char_ptr_t);
+REGISTER_POINTER_TYPE(uint64_t, uint64_ptr_t);
+REGISTER_POINTER_TYPE(uint32_t, uint32_ptr_t);
+REGISTER_POINTER_TYPE(uint16_t, uint16_ptr_t);
+REGISTER_POINTER_TYPE(uint8_t, uint8_ptr_t);
+REGISTER_POINTER_TYPE(Py_complex, Py_complex_ptr_t);
+REGISTER_POINTER_TYPE(PyObject, PyObject_ptr_t);
+REGISTER_POINTER_TYPE(PyObject_ptr_t, PyObject_ptr_ptr_t);
+REGISTER_POINTER_TYPE(float_t, float_ptr_t);
+REGISTER_POINTER_TYPE(double_t, double_ptr_t);
+REGISTER_POINTER_TYPE(Py_ssize_t, Py_ssize_ptr_t);
+
 
 static void initialize_globals() {
     // register native NULL
@@ -413,7 +482,6 @@ polyglot_typeid get_byte_array_typeid(uint64_t len) {
     return polyglot_array_typeid(polyglot_i8_typeid(), len);
 }
 
-POLYGLOT_DECLARE_TYPE(uint32_t);
 /** to be used from Java code only; returns the type ID for a uint32_t array */
 polyglot_typeid get_uint32_t_array_typeid(uint64_t len) {
     return polyglot_array_typeid(polyglot_uint32_t_typeid(), len);

graalpython/com.oracle.graal.python.cext/src/capi.h

@@ -82,7 +82,7 @@ typedef struct {
 } PyBufferDecorator;
 
 /* Taken from CPython "Objects/descrobject.c".
- * This struct is actually private to 'descrobject.c' but we need to register 
+ * This struct is actually private to 'descrobject.c' but we need to register
  * it to the managed property type. */
 typedef struct {
     PyObject_HEAD
@@ -312,20 +312,34 @@ void initialize_hashes();
 #define JWRAPPER_SETATTR                     11
 #define JWRAPPER_RICHCMP                     12
 #define JWRAPPER_SETITEM                     13
-#define JWRAPPER_REVERSE                     14
-#define JWRAPPER_POW                         15
-#define JWRAPPER_REVERSE_POW                 16
-#define JWRAPPER_LT                          17
-#define JWRAPPER_LE                          18
-#define JWRAPPER_EQ                          19
-#define JWRAPPER_NE                          20
-#define JWRAPPER_GT                          21
-#define JWRAPPER_GE                          22
-#define JWRAPPER_ITERNEXT                    23
-#define JWRAPPER_INQUIRY                     24
-#define JWRAPPER_DELITEM                     25
-#define JWRAPPER_GETITEM                     26
-#define JWRAPPER_INITPROC                    29
+#define JWRAPPER_UNARYFUNC                   14
+#define JWRAPPER_BINARYFUNC                  15
+#define JWRAPPER_BINARYFUNC_L                16
+#define JWRAPPER_BINARYFUNC_R                17
+#define JWRAPPER_TERNARYFUNC                 18
+#define JWRAPPER_TERNARYFUNC_R               19
+#define JWRAPPER_LT                          20
+#define JWRAPPER_LE                          21
+#define JWRAPPER_EQ                          22
+#define JWRAPPER_NE                          23
+#define JWRAPPER_GT                          24
+#define JWRAPPER_GE                          25
+#define JWRAPPER_ITERNEXT                    26
+#define JWRAPPER_INQUIRY                     27
+#define JWRAPPER_DELITEM                     28
+#define JWRAPPER_GETITEM                     29
+#define JWRAPPER_GETTER                      30
+#define JWRAPPER_SETTER                      31
+#define JWRAPPER_INITPROC                    32
+#define JWRAPPER_HASHFUNC                    33
+#define JWRAPPER_CALL                        34
+#define JWRAPPER_SETATTRO                    35
+#define JWRAPPER_DESCR_GET                   36
+#define JWRAPPER_DESCR_SET                   37
+#define JWRAPPER_LENFUNC                     38
+#define JWRAPPER_OBJOBJPROC                  39
+#define JWRAPPER_OBJOBJARGPROC               40
+#define JWRAPPER_NEW                         41
 
 #define TDEBUG __builtin_debugtrap()
 #define get_method_flags_wrapper(flags)                                                  \

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

@@ -95,6 +95,60 @@ void PyThread_release_lock(PyThread_type_lock aLock) {
 }
 
 
-void PyThread_free_lock(PyThread_type_lock lock)
+void PyThread_free_lock(PyThread_type_lock lock) {
+}
+
+PyObject *
+PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
+{
+    return PyEval_EvalCodeEx(co,
+                      globals, locals,
+                      (PyObject **)NULL, 0,
+                      (PyObject **)NULL, 0,
+                      (PyObject **)NULL, 0,
+                      NULL, NULL);
+}
+
+PyObject *
+PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
+                  PyObject *const *args, int argcount,
+                  PyObject *const *kws, int kwcount,
+                  PyObject *const *defs, int defcount,
+                  PyObject *kwdefs, PyObject *closure)
+{
+    return _PyEval_EvalCodeWithName(_co, globals, locals,
+                                    args, argcount,
+                                    kws, kws != NULL ? kws + 1 : NULL,
+                                    kwcount, 2,
+                                    defs, defcount,
+                                    kwdefs, closure,
+                                    NULL, NULL);
+}
+
+typedef PyObject *(*eval_code_ex_fun_t)(PyObject *_co, PyObject *globals, PyObject *locals,
+                  PyObject *const *args,
+                  PyObject *const *kwnames,
+                  PyObject *const *kwargs,
+                  PyObject *const *defs,
+                  PyObject *kwdefs, PyObject *closure);
+UPCALL_TYPED_ID(PyEval_EvalCodeEx, eval_code_ex_fun_t);
+PyObject *
+_PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals,
+           PyObject *const *args, Py_ssize_t argcount,
+           PyObject *const *kwnames, PyObject *const *kwargs,
+           Py_ssize_t kwcount, int kwstep,
+           PyObject *const *defs, Py_ssize_t defcount,
+           PyObject *kwdefs, PyObject *closure,
+           PyObject *name, PyObject *qualname)
 {
+    if (globals == NULL) {
+        PyErr_SetString(PyExc_SystemError, "PyEval_EvalCodeEx: NULL globals");
+        return NULL;
+    }
+    /* TODO(fa): do not ignore 'name' and 'qualname' */
+    return _jls_PyEval_EvalCodeEx(native_to_java(_co), native_to_java(globals), native_to_java(locals != NULL ? locals : Py_None),
+                                  polyglot_from_PyObjectPtr_array(args, argcount),
+                                  polyglot_from_PyObjectPtr_array(kwnames, kwcount), polyglot_from_PyObjectPtr_array(kwargs, kwcount),
+                                  polyglot_from_PyObjectPtr_array(defs, defcount),
+                                  native_to_java(kwdefs), native_to_java(closure));
 }

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

@@ -48,7 +48,7 @@ typedef struct {
 
 PyTypeObject PyGetSetDescr_Type = PY_TRUFFLE_TYPE("getset_descriptor", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(PyGetSetDescrObject));
 /* NOTE: we use the same Python type (namely 'PBuiltinFunction') for 'wrapper_descriptor' as for 'method_descriptor'; so the flags must be the same! */
-PyTypeObject PyWrapperDescr_Type = PY_TRUFFLE_TYPE("wrapper_descriptor", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_METHOD_DESCRIPTOR| _Py_TPFLAGS_HAVE_VECTORCALL, sizeof(PyWrapperDescrObject));
+PyTypeObject PyWrapperDescr_Type = PY_TRUFFLE_TYPE("wrapper_descriptor", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_METHOD_DESCRIPTOR, sizeof(PyWrapperDescrObject));
 PyTypeObject PyMemberDescr_Type = PY_TRUFFLE_TYPE("member_descriptor", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(PyMemberDescrObject));
 PyTypeObject PyMethodDescr_Type = PY_TRUFFLE_TYPE_WITH_VECTORCALL("method_descriptor", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_METHOD_DESCRIPTOR| _Py_TPFLAGS_HAVE_VECTORCALL, sizeof(PyMethodDescrObject), offsetof(PyMethodDescrObject, vectorcall));
 PyTypeObject PyDictProxy_Type = PY_TRUFFLE_TYPE("mappingproxy", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(mappingproxyobject));
@@ -67,11 +67,11 @@ int PyMethodDescr_Check(PyObject* method) {
     return UPCALL_CEXT_I(_jls_PyMethodDescr_Check, native_to_java(method));
 }
 
-typedef PyObject* (*PyDescr_NewClassMethod_fun_t)(void* name, 
+typedef PyObject* (*PyDescr_NewClassMethod_fun_t)(void* name,
                                                     const char* doc,
-                                                    int flags, 
-                                                    int wrapper, 
-                                                    void* methObj, 
+                                                    int flags,
+                                                    int wrapper,
+                                                    void* methObj,
                                                     void* primary);
 UPCALL_TYPED_ID(PyDescr_NewClassMethod, PyDescr_NewClassMethod_fun_t);
 PyObject* PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method) {
@@ -84,7 +84,7 @@ PyObject* PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method) {
                     type);
 }
 
-typedef PyObject* (*PyDescr_NewGetSet_fun_t)(void* name, 
+typedef PyObject* (*PyDescr_NewGetSet_fun_t)(void* name,
                                                     PyTypeObject *type,
                                                     void *get,
                                                     void *set,