[GR-51613] Avoid generic PyObject_RichCompare.

PullRequest: graalpython/3172

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/graalpy/handles.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef SRC_HANDLES_H_
+#define SRC_HANDLES_H_
+
+#include <object.h>
+
+#define MANAGED_REFCNT 10
+#define HANDLE_BASE 0x8000000000000000ULL
+#define IMMORTAL_REFCNT (INT64_MAX >> 1)
+
+#ifdef GRAALVM_PYTHON_LLVM_MANAGED
+#include <graalvm/llvm/polyglot.h>
+#define points_to_py_handle_space(PTR) polyglot_is_value((PTR))
+#define stub_to_pointer(STUB_PTR) (STUB_PTR)
+#define pointer_to_stub(O) (O)
+#else /* GRAALVM_PYTHON_LLVM_MANAGED */
+
+#define points_to_py_handle_space(PTR) ((((uintptr_t) (PTR)) & HANDLE_BASE) != 0)
+#define stub_to_pointer(STUB_PTR) (((uintptr_t) (STUB_PTR)) | HANDLE_BASE)
+#define pointer_to_stub(PTR) ((PyObject *)(((uintptr_t) (PTR)) & ~HANDLE_BASE))
+
+#endif /* GRAALVM_PYTHON_LLVM_MANAGED */
+
+#endif /* SRC_HANDLES_H_ */

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, 2023, Oracle and/or its affiliates.
+/* Copyright (c) 2018, 2024, Oracle and/or its affiliates.
  * Copyright (C) 1996-2020 Python Software Foundation
  *
  * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -57,6 +57,8 @@ A standard interface exists for objects that contain an array of items
 whose size is determined when the object is allocated.
 */
 
+#include "graalpy/handles.h"
+
 /* Py_DEBUG implies Py_REF_DEBUG. */
 #if defined(Py_DEBUG) && !defined(Py_REF_DEBUG)
 #  define Py_REF_DEBUG
@@ -135,10 +137,15 @@ PyAPI_FUNC(int) Py_Is(PyObject *x, PyObject *y);
 PyAPI_FUNC(Py_ssize_t) _Py_REFCNT(const PyObject *ob);
 #define Py_REFCNT(ob) _Py_REFCNT(_PyObject_CAST_CONST(ob))
 
-
 PyAPI_FUNC(PyTypeObject*) _Py_TYPE(const PyObject *ob);
+
 // bpo-39573: The Py_SET_TYPE() function must be used to set an object type.
+
+#if defined(GRAALVM_PYTHON) && !defined(GRAALVM_PYTHON_LLVM_MANAGED) && defined(NDEBUG)
+#define Py_TYPE(ob)             (pointer_to_stub(ob)->ob_type)
+#else
 #define Py_TYPE(ob)             _Py_TYPE(_PyObject_CAST_CONST(ob))
+#endif
 
 PyAPI_FUNC(Py_ssize_t) _Py_SIZE(const PyVarObject *ob);
 // bpo-39573: The Py_SET_SIZE() function must be used to set an object size.

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

@@ -2296,10 +2296,6 @@ PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject* a, Py_ssize_t b) {
 PyAPI_FUNC(PyObject*) PyObject_Repr(PyObject* a) {
     return GraalPyObject_Repr(a);
 }
-#undef PyObject_RichCompare
-PyAPI_FUNC(PyObject*) PyObject_RichCompare(PyObject* a, PyObject* b, int c) {
-    return GraalPyObject_RichCompare(a, b, c);
-}
 #undef PyObject_SetArenaAllocator
 PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator* a) {
     FUNC_NOT_IMPLEMENTED
@@ -3288,10 +3284,6 @@ PyAPI_FUNC(char*) Py_EncodeLocale(const wchar_t* a, size_t* b) {
 PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState* a) {
     FUNC_NOT_IMPLEMENTED
 }
-#undef Py_EnterRecursiveCall
-PyAPI_FUNC(int) Py_EnterRecursiveCall(const char* a) {
-    return GraalPy_EnterRecursiveCall(a);
-}
 #undef Py_Exit
 PyAPI_FUNC(void) Py_Exit(int a) {
     FUNC_NOT_IMPLEMENTED
@@ -3376,10 +3368,6 @@ PyAPI_FUNC(void) Py_InitializeEx(int a) {
 PyAPI_FUNC(PyStatus) Py_InitializeFromConfig(const PyConfig* a) {
     FUNC_NOT_IMPLEMENTED
 }
-#undef Py_LeaveRecursiveCall
-PyAPI_FUNC(void) Py_LeaveRecursiveCall() {
-    GraalPy_LeaveRecursiveCall();
-}
 #undef Py_Main
 PyAPI_FUNC(int) Py_Main(int a, wchar_t** b) {
     FUNC_NOT_IMPLEMENTED

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

@@ -251,7 +251,6 @@ typedef struct {
     BUILTIN(PyObject_IsTrue, int, PyObject*) \
     BUILTIN(PyObject_LengthHint, Py_ssize_t, PyObject*, Py_ssize_t) \
     BUILTIN(PyObject_Repr, PyObject*, PyObject*) \
-    BUILTIN(PyObject_RichCompare, PyObject*, PyObject*, PyObject*, int) \
     BUILTIN(PyObject_SetDoc, int, PyObject*, const char*) \
     BUILTIN(PyObject_SetItem, int, PyObject*, PyObject*, PyObject*) \
     BUILTIN(PyObject_Size, Py_ssize_t, PyObject*) \
@@ -368,6 +367,7 @@ typedef struct {
     BUILTIN(PyTruffle_Debug, int, void*) \
     BUILTIN(PyTruffle_DebugTrace, void) \
     BUILTIN(PyTruffle_Ellipsis, PyObject*) \
+    BUILTIN(PyTruffle_EnterRecursiveCall, int, const char*) \
     BUILTIN(PyTruffle_False, PyObject*) \
     BUILTIN(PyTruffle_FatalErrorFunc, void, const char*, const char*, int) \
     BUILTIN(PyTruffle_FileSystemDefaultEncoding, PyObject*) \
@@ -376,6 +376,7 @@ typedef struct {
     BUILTIN(PyTruffle_GetMaxNativeMemory, size_t) \
     BUILTIN(PyTruffle_HashConstant, long, int) \
     BUILTIN(PyTruffle_InitBuiltinTypesAndStructs, void, void*) \
+    BUILTIN(PyTruffle_LeaveRecursiveCall, void) \
     BUILTIN(PyTruffle_LogString, void, int, const char*) \
     BUILTIN(PyTruffle_MemoryViewFromBuffer, PyObject*, void*, PyObject*, Py_ssize_t, int, Py_ssize_t, const char*, int, void*, void*, void*, void*) \
     BUILTIN(PyTruffle_Native_Options, int) \
@@ -438,9 +439,7 @@ typedef struct {
     BUILTIN(Py_CompileString, PyObject*, const char*, const char*, int) \
     BUILTIN(Py_CompileStringExFlags, PyObject*, const char*, const char*, int, PyCompilerFlags*, int) \
     BUILTIN(Py_CompileStringObject, PyObject*, const char*, PyObject*, int, PyCompilerFlags*, int) \
-    BUILTIN(Py_EnterRecursiveCall, int, const char*) \
     BUILTIN(Py_GenericAlias, PyObject*, PyObject*, PyObject*) \
-    BUILTIN(Py_LeaveRecursiveCall, void) \
     BUILTIN(Py_get_PyASCIIObject_length, Py_ssize_t, PyASCIIObject*) \
     BUILTIN(Py_get_PyASCIIObject_state_ascii, unsigned int, PyASCIIObject*) \
     BUILTIN(Py_get_PyASCIIObject_state_compact, unsigned int, PyASCIIObject*) \
@@ -802,27 +801,6 @@ static inline int get_method_flags_wrapper(int flags) {
     return JWRAPPER_UNSUPPORTED;
 }
 
-#define MANAGED_REFCNT 10
-#define HANDLE_BASE 0x8000000000000000ULL
-#define IMMORTAL_REFCNT (INT64_MAX >> 1)
-
-#ifdef GRAALVM_PYTHON_LLVM_MANAGED
-#define points_to_py_handle_space(PTR) polyglot_is_value((PTR))
-#else /* GRAALVM_PYTHON_LLVM_MANAGED */
-
-#define points_to_py_handle_space(PTR) ((((uintptr_t) (PTR)) & HANDLE_BASE) != 0)
-
-static MUST_INLINE PyObject *stub_to_pointer(PyObject *stub_ptr)
-{
-    return ((uintptr_t) stub_ptr) | HANDLE_BASE;
-}
-
-static MUST_INLINE PyObject *pointer_to_stub(PyObject *o)
-{
-    return ((uintptr_t) o) & ~HANDLE_BASE;
-}
-#endif /* GRAALVM_PYTHON_LLVM_MANAGED */
-
 void register_native_slots(PyTypeObject* managed_class, PyGetSetDef* getsets, PyMemberDef* members);
 
 // export the SizeT arg parse functions, because we use them in contrast to cpython on windows for core modules that we link dynamically

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -93,3 +93,33 @@ PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
                                   defs, defcount,
                                   kwdefs, closure);
 }
+
+#ifndef GRAALVM_PYTHON_LLVM_MANAGED
+#if defined(__GNUC__)
+static __thread int _tls_recursion_depth = 0;
+#elif defined(_MSC_VER)
+static __declspec(thread) int _tls_recursion_depth = 0;
+#else
+#error "don't know how to declare thread local variable"
+#endif
+#endif /* GRAALVM_PYTHON_LLVM_MANAGED */
+
+int Py_EnterRecursiveCall(const char *where) {
+#ifdef GRAALVM_PYTHON_LLVM_MANAGED
+    return GraalPyTruffle_EnterRecursiveCall(where);
+#else /* GRAALVM_PYTHON_LLVM_MANAGED */
+    if (++_tls_recursion_depth > Py_DEFAULT_RECURSION_LIMIT) {
+        PyErr_SetString(PyExc_RecursionError, where);
+        return -1;
+    }
+    return 0;
+#endif /* GRAALVM_PYTHON_LLVM_MANAGED */
+}
+
+void Py_LeaveRecursiveCall()  {
+#ifdef GRAALVM_PYTHON_LLVM_MANAGED
+    GraalPyTruffle_LeaveRecursiveCall();
+#else /* GRAALVM_PYTHON_LLVM_MANAGED */
+    _tls_recursion_depth--;
+#endif /* GRAALVM_PYTHON_LLVM_MANAGED */
+}

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

@@ -187,7 +187,115 @@ PyObject_Print(PyObject *op, FILE *fp, int flags)
     return ret;
 }
 
-// 751
+/* For Python 3.0.1 and later, the old three-way comparison has been
+   completely removed in favour of rich comparisons.  PyObject_Compare() and
+   PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
+   The old tp_compare slot has been renamed to tp_as_async, and should no
+   longer be used.  Use tp_richcompare instead.
+
+   See (*) below for practical amendments.
+
+   tp_richcompare gets called with a first argument of the appropriate type
+   and a second object of an arbitrary type.  We never do any kind of
+   coercion.
+
+   The tp_richcompare slot should return an object, as follows:
+
+    NULL if an exception occurred
+    NotImplemented if the requested comparison is not implemented
+    any other false value if the requested comparison is false
+    any other true value if the requested comparison is true
+
+  The PyObject_RichCompare[Bool]() wrappers raise TypeError when they get
+  NotImplemented.
+
+  (*) Practical amendments:
+
+  - If rich comparison returns NotImplemented, == and != are decided by
+    comparing the object pointer (i.e. falling back to the base object
+    implementation).
+
+*/
+
+/* Map rich comparison operators to their swapped version, e.g. LT <--> GT */
+int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
+
+static const char * const opstrings[] = {"<", "<=", "==", "!=", ">", ">="};
+
+/* Perform a rich comparison, raising TypeError when the requested comparison
+   operator is not supported. */
+static PyObject *
+do_richcompare(PyObject *v, PyObject *w, int op)
+{
+    richcmpfunc f;
+    PyObject *res;
+    int checked_reverse_op = 0;
+
+    if (!Py_IS_TYPE(v, Py_TYPE(w)) &&
+        PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v)) &&
+        (f = Py_TYPE(w)->tp_richcompare) != NULL) {
+        checked_reverse_op = 1;
+        res = (*f)(w, v, _Py_SwappedOp[op]);
+        if (res != Py_NotImplemented)
+            return res;
+        Py_DECREF(res);
+    }
+    if ((f = Py_TYPE(v)->tp_richcompare) != NULL) {
+        res = (*f)(v, w, op);
+        if (res != Py_NotImplemented)
+            return res;
+        Py_DECREF(res);
+    }
+    if (!checked_reverse_op && (f = Py_TYPE(w)->tp_richcompare) != NULL) {
+        res = (*f)(w, v, _Py_SwappedOp[op]);
+        if (res != Py_NotImplemented)
+            return res;
+        Py_DECREF(res);
+    }
+    /* If neither object implements it, provide a sensible default
+       for == and !=, but raise an exception for ordering. */
+    switch (op) {
+    case Py_EQ:
+        res = (v == w) ? Py_True : Py_False;
+        break;
+    case Py_NE:
+        res = (v != w) ? Py_True : Py_False;
+        break;
+    default:
+        PyErr_Format(PyExc_TypeError,
+                      "'%s' not supported between instances of '%.100s' and '%.100s'",
+                      opstrings[op],
+                      Py_TYPE(v)->tp_name,
+                      Py_TYPE(w)->tp_name);
+        return NULL;
+    }
+    Py_INCREF(res);
+    return res;
+}
+
+/* Perform a rich comparison with object result.  This wraps do_richcompare()
+   with a check for NULL arguments and a recursion check. */
+
+PyObject *
+PyObject_RichCompare(PyObject *v, PyObject *w, int op)
+{
+    assert(Py_LT <= op && op <= Py_GE);
+    if (v == NULL || w == NULL) {
+        if (!PyErr_Occurred()) {
+            PyErr_BadInternalCall();
+        }
+        return NULL;
+    }
+    if (Py_EnterRecursiveCall(" in comparison")) {
+        return NULL;
+    }
+    PyObject *res = do_richcompare(v, w, op);
+    Py_LeaveRecursiveCall();
+    return res;
+}
+
+/* Perform a rich comparison with integer result.  This wraps
+   PyObject_RichCompare(), returning -1 for error, 0 for false, 1 for true. */
 int
 PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
 {