Add functions to hide some internals of long object.

python · markshannon · Mar 22, 2023 · Jan 25, 2023 · Jan 25, 2023 · Feb 28, 2023
commit 0ec07e442b35fbf55e4e174f44d6d188b40b945c
diff --git a/Include/cpython/longintrepr.h b/Include/cpython/longintrepr.h
@@ -94,6 +94,10 @@ PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t);
 /* Return a copy of src. */
 PyAPI_FUNC(PyObject *) _PyLong_Copy(PyLongObject *src);
 
+PyAPI_FUNC(PyLongObject *)
+_PyLong_FromDigits(int sign, Py_ssize_t digit_count, digit *digits);
+
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/Include/internal/pycore_long.h b/Include/internal/pycore_long.h
@@ -112,7 +112,7 @@ PyAPI_FUNC(char*) _PyLong_FormatBytesWriter(
 
 /* Return 1 if the argument is positive single digit int */
 static inline int
-_PyLong_IsPositiveSingleDigit(PyObject* sub) {
+_PyLong_IsPositiveSingleDigit(const PyObject* op) {
     /*  For a positive single digit int, the value of Py_SIZE(sub) is 0 or 1.
 
         We perform a fast check using a single comparison by casting from int
@@ -124,11 +124,55 @@ _PyLong_IsPositiveSingleDigit(PyObject* sub) {
         The function is not affected by -fwrapv, -fno-wrapv and -ftrapv
         compiler options of GCC and clang
     */
-    assert(PyLong_CheckExact(sub));
-    Py_ssize_t signed_size = Py_SIZE(sub);
+    assert(PyLong_Check(op));
+    Py_ssize_t signed_size = Py_SIZE(op);
     return ((size_t)signed_size) <= 1;
 }
 
+
+static inline int
+_PyLong_IsSingleDigit(const PyObject* op) {
+    assert(PyLong_Check(op));
+    Py_ssize_t signed_size = Py_SIZE(op);
+    return ((size_t)(signed_size+1)) <= 2;
+}
+
+static inline Py_ssize_t
+_PyLong_SingleDigitValue(const PyLongObject *op)
+{
+    assert(PyLong_Check(op));
+    assert(Py_SIZE(op) >= -1 && Py_SIZE(op) <= 1);
+    return Py_SIZE(op) * op->long_value.ob_digit[0];
+}
+
+static inline Py_ssize_t
+_PyLong_DigitCount(const PyLongObject *op)
+{
+    assert(PyLong_Check(op));
+    return Py_ABS(Py_SIZE(op));
+}
+
+
+static inline bool
+_PyLong_IsNegative(const PyLongObject *op)
+{
+    return Py_SIZE(op) < 0;
+}
+
+
+static inline bool
+_PyLong_IsZero(const PyLongObject *op)
+{
+    return Py_SIZE(op) == 0;
+}
+
+static inline bool
+_PyLong_IsPositive(const PyLongObject *op)
+{
+    return Py_SIZE(op) > 0;
+}
+
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/Modules/_decimal/_decimal.c b/Modules/_decimal/_decimal.c
@@ -30,6 +30,7 @@
 #endif
 
 #include <Python.h>
+#include "pycore_long.h"          // _PyLong_IsZero()
 #include "pycore_pystate.h"       // _PyThreadState_GET()
 #include "complexobject.h"
 #include "mpdecimal.h"
@@ -2146,35 +2147,25 @@ dec_from_long(PyTypeObject *type, PyObject *v,
 {
     PyObject *dec;
     PyLongObject *l = (PyLongObject *)v;
-    Py_ssize_t ob_size;
-    size_t len;
-    uint8_t sign;
 
     dec = PyDecType_New(type);
     if (dec == NULL) {
         return NULL;
     }
 
-    ob_size = Py_SIZE(l);
-    if (ob_size == 0) {
+    if (_PyLong_IsZero(l)) {
         _dec_settriple(dec, MPD_POS, 0, 0);
         return dec;
     }
 
-    if (ob_size < 0) {
-        len = -ob_size;
-        sign = MPD_NEG;
-    }
-    else {
-        len = ob_size;
-        sign = MPD_POS;
-    }
+    uint8_t sign = _PyLong_IsNegative(l) ? MPD_NEG :  MPD_POS;
 
-    if (len == 1) {
-        _dec_settriple(dec, sign, *l->long_value.ob_digit, 0);
+    if (_PyLong_IsSingleDigit((PyObject *)l)) {
+        _dec_settriple(dec, sign, l->long_value.ob_digit[0], 0);
         mpd_qfinalize(MPD(dec), ctx, status);
         return dec;
     }
+    size_t len = _PyLong_DigitCount(l);
 
 #if PYLONG_BITS_IN_DIGIT == 30
     mpd_qimport_u32(MPD(dec), l->long_value.ob_digit, len, sign, PyLong_BASE,
@@ -3482,7 +3473,6 @@ dec_as_long(PyObject *dec, PyObject *context, int round)
     PyLongObject *pylong;
     digit *ob_digit;
     size_t n;
-    Py_ssize_t i;
     mpd_t *x;
     mpd_context_t workctx;
     uint32_t status = 0;
@@ -3536,26 +3526,9 @@ dec_as_long(PyObject *dec, PyObject *context, int round)
     }
 
     assert(n > 0);
-    pylong = _PyLong_New(n);
-    if (pylong == NULL) {
-        mpd_free(ob_digit);
-        mpd_del(x);
-        return NULL;
-    }
-
-    memcpy(pylong->long_value.ob_digit, ob_digit, n * sizeof(digit));
+    assert(!mpd_iszero(x));
+    pylong = _PyLong_FromDigits(mpd_isnegative(x) ? -1 : 1, n, ob_digit);
     mpd_free(ob_digit);
-
-    i = n;
-    while ((i > 0) && (pylong->long_value.ob_digit[i-1] == 0)) {
-        i--;
-    }
-
-    Py_SET_SIZE(pylong, i);
-    if (mpd_isnegative(x) && !mpd_iszero(x)) {
-        Py_SET_SIZE(pylong, -i);
-    }
-
     mpd_del(x);
     return (PyObject *) pylong;
 }

diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
@@ -729,7 +729,7 @@ long_lcm(PyObject *a, PyObject *b)
 {
     PyObject *g, *m, *f, *ab;
 
-    if (Py_SIZE(a) == 0 || Py_SIZE(b) == 0) {
+    if (_PyLong_IsZero((PyLongObject *)a) || _PyLong_IsZero((PyLongObject *)b)) {
         return PyLong_FromLong(0);
     }
     g = _PyLong_GCD(a, b);
@@ -2147,7 +2147,7 @@ loghelper(PyObject* arg, double (*func)(double))
         Py_ssize_t e;
 
         /* Negative or zero inputs give a ValueError. */
-        if (Py_SIZE(arg) <= 0) {
+        if (!_PyLong_IsPositive((PyLongObject *)arg)) {
             PyErr_SetString(PyExc_ValueError,
                             "math domain error");
             return NULL;
@@ -3751,12 +3751,12 @@ math_perm_impl(PyObject *module, PyObject *n, PyObject *k)
     }
     assert(PyLong_CheckExact(n) && PyLong_CheckExact(k));
 
-    if (Py_SIZE(n) < 0) {
+    if (_PyLong_IsNegative((PyLongObject *)n)) {
         PyErr_SetString(PyExc_ValueError,
                         "n must be a non-negative integer");
         goto error;
     }
-    if (Py_SIZE(k) < 0) {
+    if (_PyLong_IsNegative((PyLongObject *)k)) {
         PyErr_SetString(PyExc_ValueError,
                         "k must be a non-negative integer");
         goto error;
@@ -3843,12 +3843,12 @@ math_comb_impl(PyObject *module, PyObject *n, PyObject *k)
     }
     assert(PyLong_CheckExact(n) && PyLong_CheckExact(k));
 
-    if (Py_SIZE(n) < 0) {
+    if (_PyLong_IsNegative((PyLongObject *)n)) {
         PyErr_SetString(PyExc_ValueError,
                         "n must be a non-negative integer");
         goto error;
     }
-    if (Py_SIZE(k) < 0) {
+    if (_PyLong_IsNegative((PyLongObject *)k)) {
         PyErr_SetString(PyExc_ValueError,
                         "k must be a non-negative integer");
         goto error;
@@ -3880,7 +3880,8 @@ math_comb_impl(PyObject *module, PyObject *n, PyObject *k)
         if (temp == NULL) {
             goto error;
         }
-        if (Py_SIZE(temp) < 0) {
+        assert(PyLong_Check(temp));
+        if (_PyLong_IsNegative((PyLongObject *)temp)) {
             Py_DECREF(temp);
             result = PyLong_FromLong(0);
             goto done;

diff --git a/Objects/listobject.c b/Objects/listobject.c
@@ -4,6 +4,7 @@
 #include "pycore_abstract.h"      // _PyIndex_Check()
 #include "pycore_interp.h"        // PyInterpreterState.list
 #include "pycore_list.h"          // struct _Py_list_state, _PyListIterObject
+#include "pycore_long.h"          // _PyLong_DigitCount
 #include "pycore_object.h"        // _PyObject_GC_TRACK()
 #include "pycore_tuple.h"         // _PyTuple_FromArray()
 #include <stddef.h>
@@ -2149,19 +2150,14 @@ unsafe_long_compare(PyObject *v, PyObject *w, MergeState *ms)
     /* Modified from Objects/longobject.c:long_compare, assuming: */
     assert(Py_IS_TYPE(v, &PyLong_Type));
     assert(Py_IS_TYPE(w, &PyLong_Type));
-    assert(Py_ABS(Py_SIZE(v)) <= 1);
-    assert(Py_ABS(Py_SIZE(w)) <= 1);
+    assert(_PyLong_IsSingleDigit(v));
+    assert(_PyLong_IsSingleDigit(w));
 
     vl = (PyLongObject*)v;
     wl = (PyLongObject*)w;
 
-    v0 = Py_SIZE(vl) == 0 ? 0 : (sdigit)vl->long_value.ob_digit[0];
-    w0 = Py_SIZE(wl) == 0 ? 0 : (sdigit)wl->long_value.ob_digit[0];
-
-    if (Py_SIZE(vl) < 0)
-        v0 = -v0;
-    if (Py_SIZE(wl) < 0)
-        w0 = -w0;
+    v0 = _PyLong_SingleDigitValue(vl);
+    w0 = _PyLong_SingleDigitValue(wl);
 
     res = v0 < w0;
     assert(res == PyObject_RichCompareBool(v, w, Py_LT));
@@ -2359,7 +2355,7 @@ list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse)
             if (keys_are_all_same_type) {
                 if (key_type == &PyLong_Type &&
                     ints_are_bounded &&
-                    Py_ABS(Py_SIZE(key)) > 1) {
+                    !_PyLong_IsSingleDigit(key)) {
 
                     ints_are_bounded = 0;
                 }

diff --git a/Objects/longobject.c b/Objects/longobject.c
@@ -170,30 +170,40 @@ _PyLong_New(Py_ssize_t size)
     return result;
 }
 
+PyLongObject *
+_PyLong_FromDigits(int sign, Py_ssize_t digit_count, digit *digits)
+{
+    assert(digit_count >= 0);
+    PyLongObject *result = _PyLong_New(digit_count);
+    if (result == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    assert(sign >= -1 && sign <= 1);
+    result->long_value.ob_size = sign * digit_count;
+    memcpy(result->long_value.ob_digit, digits, digit_count * sizeof(digit));
+    return result;
+}
+
 PyObject *
 _PyLong_Copy(PyLongObject *src)
 {
-    PyLongObject *result;
     Py_ssize_t i;
 
     assert(src != NULL);
     i = Py_SIZE(src);
-    if (i < 0)
-        i = -(i);
+    int sign = 1;
+    if (i < 0) {
+        i = -i;
+        sign = -1;
+    }
     if (i < 2) {
         stwodigits ival = medium_value(src);
         if (IS_SMALL_INT(ival)) {
             return get_small_int((sdigit)ival);
         }
     }
-    result = _PyLong_New(i);
-    if (result != NULL) {
-        Py_SET_SIZE(result, Py_SIZE(src));
-        while (--i >= 0) {
-            result->long_value.ob_digit[i] = src->long_value.ob_digit[i];
-        }
-    }
-    return (PyObject *)result;
+    return (PyObject *)_PyLong_FromDigits(sign, i, src->long_value.ob_digit);
 }
 
 static PyObject *

@@ -5,6 +5,7 @@
 #include "pycore_ast.h"           // _PyAST_Validate()
 #include "pycore_call.h"          // _PyObject_CallNoArgs()
 #include "pycore_compile.h"       // _PyAST_Compile()
+#include "pycore_long.h"          // _PyLong_SingleDigitValue
 #include "pycore_object.h"        // _Py_AddToAllObjects()
 #include "pycore_pyerrors.h"      // _PyErr_NoMemory()
 #include "pycore_pystate.h"       // _PyThreadState_GET()
@@ -2506,12 +2507,11 @@ builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start)
                 long b;
                 overflow = 0;
                 /* Single digits are common, fast, and cannot overflow on unpacking. */
-                switch (Py_SIZE(item)) {
-                    case -1: b = -(sdigit) ((PyLongObject*)item)->long_value.ob_digit[0]; break;
-                    // Note: the continue goes to the top of the "while" loop that iterates over the elements
-                    case  0: Py_DECREF(item); continue;
-                    case  1: b = ((PyLongObject*)item)->long_value.ob_digit[0]; break;
-                    default: b = PyLong_AsLongAndOverflow(item, &overflow); break;
+                if (_PyLong_IsSingleDigit(item)) {
+                    b = _PyLong_SingleDigitValue((PyLongObject *)item);
+                }
+                else {
+                    b = PyLong_AsLongAndOverflow(item, &overflow);
                 }
                 if (overflow == 0 &&
                     (i_result >= 0 ? (b <= LONG_MAX - i_result)

@@ -357,7 +357,6 @@ dummy_func(
 
             // Deopt unless 0 <= sub < PyList_Size(list)
             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), BINARY_SUBSCR);
-            assert(((PyLongObject *)_PyLong_GetZero())->long_value.ob_digit[0] == 0);
             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
             DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);
             STAT_INC(BINARY_SUBSCR, hit);
@@ -375,7 +374,6 @@ dummy_func(
 
             // Deopt unless 0 <= sub < PyTuple_Size(list)
             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), BINARY_SUBSCR);
-            assert(((PyLongObject *)_PyLong_GetZero())->long_value.ob_digit[0] == 0);
             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
             DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);
             STAT_INC(BINARY_SUBSCR, hit);
@@ -1782,12 +1780,13 @@ dummy_func(
             assert(cframe.use_tracing == 0);
             DEOPT_IF(!PyLong_CheckExact(left), COMPARE_AND_BRANCH);
             DEOPT_IF(!PyLong_CheckExact(right), COMPARE_AND_BRANCH);
-            DEOPT_IF((size_t)(Py_SIZE(left) + 1) > 2, COMPARE_AND_BRANCH);
-            DEOPT_IF((size_t)(Py_SIZE(right) + 1) > 2, COMPARE_AND_BRANCH);
+            DEOPT_IF(!_PyLong_IsSingleDigit(left), COMPARE_AND_BRANCH);
+            DEOPT_IF(!_PyLong_IsSingleDigit(right), COMPARE_AND_BRANCH);
             STAT_INC(COMPARE_AND_BRANCH, hit);
-            assert(Py_ABS(Py_SIZE(left)) <= 1 && Py_ABS(Py_SIZE(right)) <= 1);
-            Py_ssize_t ileft = Py_SIZE(left) * ((PyLongObject *)left)->long_value.ob_digit[0];
-            Py_ssize_t iright = Py_SIZE(right) * ((PyLongObject *)right)->long_value.ob_digit[0];
+            assert(_PyLong_DigitCount((PyLongObject *)left) <= 1 &&
+                   _PyLong_DigitCount((PyLongObject *)right) <= 1);
+            Py_ssize_t ileft = _PyLong_SingleDigitValue((PyLongObject *)left);
+            Py_ssize_t iright = _PyLong_SingleDigitValue((PyLongObject *)right);
             // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg
             int sign_ish = COMPARISON_BIT(ileft, iright);
             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h