From c2af8566bcbb87439a60ae561672af449b8f178c Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 30 Aug 2024 13:52:53 +0300
Subject: [PATCH 1/5] gh-123497: New limit for Python integers on 64-bit
 platforms

Instead of be limited just by the size of addressable memory (2**63
bytes), Python integers are now also limited by the number of bits, so
the number of bit now always fit in 64-bit integer.

Both limits are much larger than what can be available on practice, so
there is no effect on users.

_PyLong_NumBits() and _PyLong_Frexp() are now always successful.
---
 Include/cpython/longobject.h   |   3 +-
 Include/internal/pycore_long.h |   9 +-
 Modules/_pickle.c              |   3 +-
 Modules/_randommodule.c        |   3 +-
 Modules/mathmodule.c           |   9 +-
 Objects/floatobject.c          |   6 +-
 Objects/longobject.c           | 175 ++++++++++-----------------------
 Python/ast_opt.c               |   7 +-
 8 files changed, 66 insertions(+), 149 deletions(-)

diff --git a/Include/cpython/longobject.h b/Include/cpython/longobject.h
index 82f8cc8a159c77..7a40029fb27da0 100644
--- a/Include/cpython/longobject.h
+++ b/Include/cpython/longobject.h
@@ -71,8 +71,7 @@ PyAPI_FUNC(int) _PyLong_Sign(PyObject *v);
    absolute value of a long.  For example, this returns 1 for 1 and -1, 2
    for 2 and -2, and 2 for 3 and -3.  It returns 0 for 0.
    v must not be NULL, and must be a normalized long.
-   (uint64_t)-1 is returned and OverflowError set if the true result doesn't
-   fit in a size_t.
+   Always successful.
 */
 PyAPI_FUNC(uint64_t) _PyLong_NumBits(PyObject *v);
 
diff --git a/Include/internal/pycore_long.h b/Include/internal/pycore_long.h
index 2c7ca6723c1973..91fbc6205fb3a5 100644
--- a/Include/internal/pycore_long.h
+++ b/Include/internal/pycore_long.h
@@ -79,14 +79,13 @@ static inline PyObject* _PyLong_FromUnsignedChar(unsigned char i)
 }
 
 // _PyLong_Frexp returns a double x and an exponent e such that the
-// true value is approximately equal to x * 2**e.  e is >= 0.  x is
+// true value is approximately equal to x * 2**e.  x is
 // 0.0 if and only if the input is 0 (in which case, e and x are both
-// zeroes); otherwise, 0.5 <= abs(x) < 1.0.  On overflow, which is
-// possible if the number of bits doesn't fit into a Py_ssize_t, sets
-// OverflowError and returns -1.0 for x, 0 for e.
+// zeroes); otherwise, 0.5 <= abs(x) < 1.0.
+// Always successful.
 //
 // Export for 'math' shared extension
-PyAPI_DATA(double) _PyLong_Frexp(PyLongObject *a, int64_t *e);
+PyAPI_DATA(double) _PyLong_Frexp(PyLongObject *a, uint64_t *e);
 
 extern PyObject* _PyLong_FromBytes(const char *, Py_ssize_t, int);
 
diff --git a/Modules/_pickle.c b/Modules/_pickle.c
index e0eda6080e42b3..6a94041e0a4734 100644
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -2155,8 +2155,7 @@ save_long(PicklerObject *self, PyObject *obj)
             return 0;
         }
         nbits = _PyLong_NumBits(obj);
-        if (nbits == (uint64_t)-1 && PyErr_Occurred())
-            goto error;
+        assert(!PyErr_Occurred());
         /* How many bytes do we need?  There are nbits >> 3 full
          * bytes of data, and nbits & 7 leftover bits.  If there
          * are any leftover bits, then we clearly need another
diff --git a/Modules/_randommodule.c b/Modules/_randommodule.c
index 3835a3072d96c6..b07e19dd351e81 100644
--- a/Modules/_randommodule.c
+++ b/Modules/_randommodule.c
@@ -335,8 +335,7 @@ random_seed(RandomObject *self, PyObject *arg)
 
     /* Now split n into 32-bit chunks, from the right. */
     bits = _PyLong_NumBits(n);
-    if (bits == (uint64_t)-1 && PyErr_Occurred())
-        goto Done;
+    assert(!PyErr_Occurred());
 
     /* Figure out how many 32-bit chunks this gives us. */
     keyused = bits == 0 ? 1 : (size_t)((bits - 1) / 32 + 1);
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index b7eb745177f37f..42b7426e9e6166 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -1680,9 +1680,7 @@ math_isqrt(PyObject *module, PyObject *n)
 
     /* c = (n.bit_length() - 1) // 2 */
     c = _PyLong_NumBits(n);
-    if (c == (uint64_t)(-1)) {
-        goto error;
-    }
+    assert(!PyErr_Occurred());
     c = (c - 1U) / 2U;
 
     /* Fast path: if c <= 31 then n < 2**64 and we can compute directly with a
@@ -2185,7 +2183,7 @@ loghelper(PyObject* arg, double (*func)(double))
     /* If it is int, do it ourselves. */
     if (PyLong_Check(arg)) {
         double x, result;
-        int64_t e;
+        uint64_t e;
 
         /* Negative or zero inputs give a ValueError. */
         if (!_PyLong_IsPositive((PyLongObject *)arg)) {
@@ -2202,8 +2200,7 @@ loghelper(PyObject* arg, double (*func)(double))
                to compute the log anyway.  Clear the exception and continue. */
             PyErr_Clear();
             x = _PyLong_Frexp((PyLongObject *)arg, &e);
-            if (x == -1.0 && PyErr_Occurred())
-                return NULL;
+            assert(!PyErr_Occurred());
             /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
             result = func(x) + func(2.0) * e;
         }
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 68fd3e54632950..1bc4711d754aa8 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -419,11 +419,7 @@ float_richcompare(PyObject *v, PyObject *w, int op)
              * its magnitude must exceed the magnitude of any
              * finite float.
              */
-            if (nbits64 == (uint64_t)-1 && PyErr_Occurred()) {
-                /* This Python integer is so large that uint64_t isn't
-                 * big enough to hold the # of bits. */
-                PyErr_Clear();
-            }
+            assert(!PyErr_Occurred());
             i = (double)vsign;
             assert(wsign != 0);
             j = wsign * 2.0;
diff --git a/Objects/longobject.c b/Objects/longobject.c
index d34c8b6d71ab3f..01a33c59d037c4 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -133,8 +133,16 @@ long_normalize(PyLongObject *v)
 /* Allocate a new int object with size digits.
    Return NULL and set exception if we run out of memory. */
 
-#define MAX_LONG_DIGITS \
+#if SIZEOF_SIZE_T < 4
+# define MAX_LONG_DIGITS \
     ((PY_SSIZE_T_MAX - offsetof(PyLongObject, long_value.ob_digit))/sizeof(digit))
+#else
+/* Guarantee that the number of bits fits in uint64_t.
+   This is more than 2 exbibytes, that is more than many of modern
+   architectures support in principle.
+   -1 is added to avoid overflow in _PyLong_Frexp(). */
+# define MAX_LONG_DIGITS ((UINT64_MAX-1) / (uint64_t)PyLong_SHIFT)
+#endif
 
 PyLongObject *
 _PyLong_New(Py_ssize_t size)
@@ -818,21 +826,12 @@ _PyLong_NumBits(PyObject *vv)
     assert(ndigits == 0 || v->long_value.ob_digit[ndigits - 1] != 0);
     if (ndigits > 0) {
         digit msd = v->long_value.ob_digit[ndigits - 1];
-        if ((uint64_t)(ndigits - 1) > UINT64_MAX / (uint64_t)PyLong_SHIFT)
-            goto Overflow;
+        assert((uint64_t)ndigits <= UINT64_MAX / (uint64_t)PyLong_SHIFT);
         result = (uint64_t)(ndigits - 1) * (uint64_t)PyLong_SHIFT;
         msd_bits = bit_length_digit(msd);
-        if (UINT64_MAX - msd_bits < result)
-            goto Overflow;
         result += msd_bits;
     }
     return result;
-
-  Overflow:
-    /* Very unlikely. Such integer would require more than 2 exbibytes of RAM. */
-    PyErr_SetString(PyExc_OverflowError, "int has too many bits "
-                    "to express in a 64-bit integer");
-    return (uint64_t)-1;
 }
 
 PyObject *
@@ -1248,14 +1247,10 @@ PyLong_AsNativeBytes(PyObject* vv, void* buffer, Py_ssize_t n, int flags)
         /* Calculates the number of bits required for the *absolute* value
          * of v. This does not take sign into account, only magnitude. */
         uint64_t nb = _PyLong_NumBits((PyObject *)v);
-        if (nb == (uint64_t)-1) {
-            res = -1;
-        } else {
-            /* Normally this would be((nb - 1) / 8) + 1 to avoid rounding up
-             * multiples of 8 to the next byte, but we add an implied bit for
-             * the sign and it cancels out. */
-            res = (Py_ssize_t)(nb / 8) + 1;
-        }
+        /* Normally this would be((nb - 1) / 8) + 1 to avoid rounding up
+         * multiples of 8 to the next byte, but we add an implied bit for
+         * the sign and it cancels out. */
+        res = (Py_ssize_t)(nb / 8) + 1;
 
         /* Two edge cases exist that are best handled after extracting the
          * bits. These may result in us reporting overflow when the value
@@ -3413,10 +3408,11 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 #endif
 
 double
-_PyLong_Frexp(PyLongObject *a, int64_t *e)
+_PyLong_Frexp(PyLongObject *a, uint64_t *e)
 {
-    Py_ssize_t a_size, shift_digits, shift_bits, x_size;
-    int64_t a_bits;
+    Py_ssize_t a_size, shift_digits, x_size;
+    int shift_bits;
+    uint64_t a_bits;
     /* See below for why x_digits is always large enough. */
     digit rem;
     digit x_digits[2 + (DBL_MANT_DIG + 1) / PyLong_SHIFT] = {0,};
@@ -3432,14 +3428,7 @@ _PyLong_Frexp(PyLongObject *a, int64_t *e)
         *e = 0;
         return 0.0;
     }
-    int msd_bits = bit_length_digit(a->long_value.ob_digit[a_size-1]);
-    /* The following is an overflow-free version of the check
-       "if ((a_size - 1) * PyLong_SHIFT + msd_bits > PY_SSIZE_T_MAX) ..." */
-    if (a_size >= (INT64_MAX - 1) / PyLong_SHIFT + 1 &&
-        (a_size > (INT64_MAX - 1) / PyLong_SHIFT + 1 ||
-         msd_bits > (INT64_MAX - 1) % PyLong_SHIFT + 1))
-        goto overflow;
-    a_bits = (int64_t)(a_size - 1) * PyLong_SHIFT + msd_bits;
+    a_bits = _PyLong_NumBits((PyObject *)a);
 
     /* Shift the first DBL_MANT_DIG + 2 bits of a into x_digits[0:x_size]
        (shifting left if a_bits <= DBL_MANT_DIG + 2).
@@ -3468,18 +3457,18 @@ _PyLong_Frexp(PyLongObject *a, int64_t *e)
     */
     if (a_bits <= DBL_MANT_DIG + 2) {
         shift_digits = (DBL_MANT_DIG + 2 - (Py_ssize_t)a_bits) / PyLong_SHIFT;
-        shift_bits = (DBL_MANT_DIG + 2 - (Py_ssize_t)a_bits) % PyLong_SHIFT;
+        shift_bits = (DBL_MANT_DIG + 2 - (int)a_bits) % PyLong_SHIFT;
         x_size = shift_digits;
         rem = v_lshift(x_digits + x_size, a->long_value.ob_digit, a_size,
-                       (int)shift_bits);
+                       shift_bits);
         x_size += a_size;
         x_digits[x_size++] = rem;
     }
     else {
         shift_digits = (Py_ssize_t)((a_bits - DBL_MANT_DIG - 2) / PyLong_SHIFT);
-        shift_bits = (Py_ssize_t)((a_bits - DBL_MANT_DIG - 2) % PyLong_SHIFT);
+        shift_bits = (int)((a_bits - DBL_MANT_DIG - 2) % PyLong_SHIFT);
         rem = v_rshift(x_digits, a->long_value.ob_digit + shift_digits,
-                       a_size - shift_digits, (int)shift_bits);
+                       a_size - shift_digits, shift_bits);
         x_size = a_size - shift_digits;
         /* For correct rounding below, we need the least significant
            bit of x to be 'sticky' for this shift: if any of the bits
@@ -3505,21 +3494,13 @@ _PyLong_Frexp(PyLongObject *a, int64_t *e)
     /* Rescale;  make correction if result is 1.0. */
     dx /= 4.0 * EXP2_DBL_MANT_DIG;
     if (dx == 1.0) {
-        if (a_bits == INT64_MAX)
-            goto overflow;
+        assert(a_bits < UINT64_MAX);
         dx = 0.5;
         a_bits += 1;
     }
 
     *e = a_bits;
     return _PyLong_IsNegative(a) ? -dx : dx;
-
-  overflow:
-    /* exponent > PY_SSIZE_T_MAX */
-    PyErr_SetString(PyExc_OverflowError,
-                    "huge integer: number of bits overflows a Py_ssize_t");
-    *e = 0;
-    return -1.0;
 }
 
 /* Get a C double from an int object.  Rounds to the nearest double,
@@ -3528,7 +3509,7 @@ _PyLong_Frexp(PyLongObject *a, int64_t *e)
 double
 PyLong_AsDouble(PyObject *v)
 {
-    int64_t exponent;
+    uint64_t exponent;
     double x;
 
     if (v == NULL) {
@@ -3547,7 +3528,8 @@ PyLong_AsDouble(PyObject *v)
         return (double)medium_value((PyLongObject *)v);
     }
     x = _PyLong_Frexp((PyLongObject *)v, &exponent);
-    if ((x == -1.0 && PyErr_Occurred()) || exponent > DBL_MAX_EXP) {
+    assert(!PyErr_Occurred());
+    if (exponent > DBL_MAX_EXP) {
         PyErr_SetString(PyExc_OverflowError,
                         "int too large to convert to float");
         return -1.0;
@@ -5217,39 +5199,6 @@ long_bool(PyLongObject *v)
     return !_PyLong_IsZero(v);
 }
 
-/* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */
-static int
-divmod_shift(PyObject *shiftby, Py_ssize_t *wordshift, digit *remshift)
-{
-    assert(PyLong_Check(shiftby));
-    assert(!_PyLong_IsNegative((PyLongObject *)shiftby));
-    Py_ssize_t lshiftby = PyLong_AsSsize_t((PyObject *)shiftby);
-    if (lshiftby >= 0) {
-        *wordshift = lshiftby / PyLong_SHIFT;
-        *remshift = lshiftby % PyLong_SHIFT;
-        return 0;
-    }
-    /* PyLong_Check(shiftby) is true and shiftby is not negative, so it must
-       be that PyLong_AsSsize_t raised an OverflowError. */
-    assert(PyErr_ExceptionMatches(PyExc_OverflowError));
-    PyErr_Clear();
-    PyLongObject *wordshift_obj = divrem1((PyLongObject *)shiftby, PyLong_SHIFT, remshift);
-    if (wordshift_obj == NULL) {
-        return -1;
-    }
-    *wordshift = PyLong_AsSsize_t((PyObject *)wordshift_obj);
-    Py_DECREF(wordshift_obj);
-    if (*wordshift >= 0 && *wordshift < PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(digit)) {
-        return 0;
-    }
-    PyErr_Clear();
-    /* Clip the value.  With such large wordshift the right shift
-       returns 0 and the left shift raises an error in _PyLong_New(). */
-    *wordshift = PY_SSIZE_T_MAX / sizeof(digit);
-    *remshift = 0;
-    return 0;
-}
-
 /* Inner function for both long_rshift and _PyLong_Rshift, shifting an
    integer right by PyLong_SHIFT*wordshift + remshift bits.
    wordshift should be nonnegative. */
@@ -5343,8 +5292,7 @@ long_rshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift)
 static PyObject *
 long_rshift(PyObject *a, PyObject *b)
 {
-    Py_ssize_t wordshift;
-    digit remshift;
+    uint64_t shiftby;
 
     CHECK_BINOP(a, b);
 
@@ -5355,9 +5303,19 @@ long_rshift(PyObject *a, PyObject *b)
     if (_PyLong_IsZero((PyLongObject *)a)) {
         return PyLong_FromLong(0);
     }
-    if (divmod_shift(b, &wordshift, &remshift) < 0)
-        return NULL;
-    return long_rshift1((PyLongObject *)a, wordshift, remshift);
+    if (PyLong_AsUInt64(b, &shiftby) < 0) {
+        if (!PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            return NULL;
+        }
+        PyErr_Clear();
+        if (_PyLong_IsNegative((PyLongObject *)a)) {
+            return PyLong_FromLong(-1);
+        }
+        else {
+            return PyLong_FromLong(0);
+        }
+    }
+    return _PyLong_Rshift(a, shiftby);
 }
 
 /* Return a >> shiftby. */
@@ -5430,8 +5388,7 @@ long_lshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift)
 static PyObject *
 long_lshift(PyObject *a, PyObject *b)
 {
-    Py_ssize_t wordshift;
-    digit remshift;
+    uint64_t shiftby;
 
     CHECK_BINOP(a, b);
 
@@ -5442,9 +5399,14 @@ long_lshift(PyObject *a, PyObject *b)
     if (_PyLong_IsZero((PyLongObject *)a)) {
         return PyLong_FromLong(0);
     }
-    if (divmod_shift(b, &wordshift, &remshift) < 0)
+    if (PyLong_AsUInt64(b, &shiftby) < 0) {
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "too many digits in integer");
+        }
         return NULL;
-    return long_lshift1((PyLongObject *)a, wordshift, remshift);
+    }
+    return _PyLong_Lshift(a, shiftby);
 }
 
 /* Return a << shiftby. */
@@ -6213,11 +6175,7 @@ static PyObject *
 int_bit_length_impl(PyObject *self)
 /*[clinic end generated code: output=fc1977c9353d6a59 input=e4eb7a587e849a32]*/
 {
-    uint64_t nbits = _PyLong_NumBits(self);
-    if (nbits == (uint64_t)-1) {
-        return NULL;
-    }
-    return PyLong_FromUnsignedLongLong(nbits);
+    return PyLong_FromUInt64(_PyLong_NumBits(self));
 }
 
 static int
@@ -6251,40 +6209,13 @@ int_bit_count_impl(PyObject *self)
 
     PyLongObject *z = (PyLongObject *)self;
     Py_ssize_t ndigits = _PyLong_DigitCount(z);
-    Py_ssize_t bit_count = 0;
+    uint64_t bit_count = 0;
 
-    /* Each digit has up to PyLong_SHIFT ones, so the accumulated bit count
-       from the first PY_SSIZE_T_MAX/PyLong_SHIFT digits can't overflow a
-       Py_ssize_t. */
-    Py_ssize_t ndigits_fast = Py_MIN(ndigits, PY_SSIZE_T_MAX/PyLong_SHIFT);
-    for (Py_ssize_t i = 0; i < ndigits_fast; i++) {
+    for (Py_ssize_t i = 0; i < ndigits; i++) {
         bit_count += popcount_digit(z->long_value.ob_digit[i]);
     }
 
-    PyObject *result = PyLong_FromSsize_t(bit_count);
-    if (result == NULL) {
-        return NULL;
-    }
-
-    /* Use Python integers if bit_count would overflow. */
-    for (Py_ssize_t i = ndigits_fast; i < ndigits; i++) {
-        PyObject *x = PyLong_FromLong(popcount_digit(z->long_value.ob_digit[i]));
-        if (x == NULL) {
-            goto error;
-        }
-        PyObject *y = long_add((PyLongObject *)result, (PyLongObject *)x);
-        Py_DECREF(x);
-        if (y == NULL) {
-            goto error;
-        }
-        Py_SETREF(result, y);
-    }
-
-    return result;
-
-  error:
-    Py_DECREF(result);
-    return NULL;
+    return PyLong_FromUInt64(bit_count);
 }
 
 /*[clinic input]
diff --git a/Python/ast_opt.c b/Python/ast_opt.c
index 5a51305d2a7ade..330328816aa62a 100644
--- a/Python/ast_opt.c
+++ b/Python/ast_opt.c
@@ -171,9 +171,6 @@ safe_multiply(PyObject *v, PyObject *w)
     ) {
         uint64_t vbits = _PyLong_NumBits(v);
         uint64_t wbits = _PyLong_NumBits(w);
-        if (vbits == (uint64_t)-1 || wbits == (uint64_t)-1) {
-            return NULL;
-        }
         if (vbits + wbits > MAX_INT_SIZE) {
             return NULL;
         }
@@ -217,7 +214,7 @@ safe_power(PyObject *v, PyObject *w)
     ) {
         uint64_t vbits = _PyLong_NumBits(v);
         size_t wbits = PyLong_AsSize_t(w);
-        if (vbits == (uint64_t)-1 || wbits == (size_t)-1) {
+        if (wbits == (size_t)-1) {
             return NULL;
         }
         if (vbits > MAX_INT_SIZE / wbits) {
@@ -236,7 +233,7 @@ safe_lshift(PyObject *v, PyObject *w)
     ) {
         uint64_t vbits = _PyLong_NumBits(v);
         size_t wbits = PyLong_AsSize_t(w);
-        if (vbits == (uint64_t)-1 || wbits == (size_t)-1) {
+        if (wbits == (size_t)-1) {
             return NULL;
         }
         if (wbits > MAX_INT_SIZE || vbits > MAX_INT_SIZE - wbits) {

From 4eaa5fdace45d302e9e8e0cd45f4cf68cc81ebe2 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Wed, 4 Sep 2024 13:51:14 +0300
Subject: [PATCH 2/5] Address review comments.

---
 Objects/longobject.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 01a33c59d037c4..e37ac52742e9d0 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1247,7 +1247,7 @@ PyLong_AsNativeBytes(PyObject* vv, void* buffer, Py_ssize_t n, int flags)
         /* Calculates the number of bits required for the *absolute* value
          * of v. This does not take sign into account, only magnitude. */
         uint64_t nb = _PyLong_NumBits((PyObject *)v);
-        /* Normally this would be((nb - 1) / 8) + 1 to avoid rounding up
+        /* Normally this would be ((nb - 1) / 8) + 1 to avoid rounding up
          * multiples of 8 to the next byte, but we add an implied bit for
          * the sign and it cancels out. */
         res = (Py_ssize_t)(nb / 8) + 1;
@@ -6175,7 +6175,9 @@ static PyObject *
 int_bit_length_impl(PyObject *self)
 /*[clinic end generated code: output=fc1977c9353d6a59 input=e4eb7a587e849a32]*/
 {
-    return PyLong_FromUInt64(_PyLong_NumBits(self));
+    uint64_t nbits =_PyLong_NumBits(self);
+    assert(!PyErr_Occurred());
+    return PyLong_FromUInt64(nbits);
 }
 
 static int

From ee87e7ff30b6cdab2670fe56bfad0cc58e91807d Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Wed, 4 Sep 2024 15:04:20 +0300
Subject: [PATCH 3/5] Update Objects/longobject.c

Co-authored-by: Victor Stinner <vstinner@python.org>
---
 Objects/longobject.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index e37ac52742e9d0..93f034ab28e558 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -6175,7 +6175,7 @@ static PyObject *
 int_bit_length_impl(PyObject *self)
 /*[clinic end generated code: output=fc1977c9353d6a59 input=e4eb7a587e849a32]*/
 {
-    uint64_t nbits =_PyLong_NumBits(self);
+    uint64_t nbits = _PyLong_NumBits(self);
     assert(!PyErr_Occurred());
     return PyLong_FromUInt64(nbits);
 }

From f0d16b8dd57fdf491baa6d2c9ad45ae1997adfe6 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Thu, 5 Sep 2024 11:42:50 +0300
Subject: [PATCH 4/5] Use signed integer type for the count of bits.

---
 Include/cpython/longobject.h   |  2 +-
 Include/internal/pycore_long.h |  6 ++--
 Modules/_pickle.c              |  3 +-
 Modules/_randommodule.c        |  3 +-
 Modules/mathmodule.c           | 20 ++++++------
 Objects/floatobject.c          |  7 +++--
 Objects/longobject.c           | 57 ++++++++++++++++++----------------
 Python/ast_opt.c               | 16 ++++++----
 8 files changed, 64 insertions(+), 50 deletions(-)

diff --git a/Include/cpython/longobject.h b/Include/cpython/longobject.h
index 7a40029fb27da0..b239f7c557e016 100644
--- a/Include/cpython/longobject.h
+++ b/Include/cpython/longobject.h
@@ -73,7 +73,7 @@ PyAPI_FUNC(int) _PyLong_Sign(PyObject *v);
    v must not be NULL, and must be a normalized long.
    Always successful.
 */
-PyAPI_FUNC(uint64_t) _PyLong_NumBits(PyObject *v);
+PyAPI_FUNC(int64_t) _PyLong_NumBits(PyObject *v);
 
 /* _PyLong_FromByteArray:  View the n unsigned bytes as a binary integer in
    base 256, and return a Python int with the same numeric value.
diff --git a/Include/internal/pycore_long.h b/Include/internal/pycore_long.h
index 91fbc6205fb3a5..088ffda73a1890 100644
--- a/Include/internal/pycore_long.h
+++ b/Include/internal/pycore_long.h
@@ -85,7 +85,7 @@ static inline PyObject* _PyLong_FromUnsignedChar(unsigned char i)
 // Always successful.
 //
 // Export for 'math' shared extension
-PyAPI_DATA(double) _PyLong_Frexp(PyLongObject *a, uint64_t *e);
+PyAPI_DATA(double) _PyLong_Frexp(PyLongObject *a, int64_t *e);
 
 extern PyObject* _PyLong_FromBytes(const char *, Py_ssize_t, int);
 
@@ -104,10 +104,10 @@ PyAPI_DATA(PyObject*) _PyLong_DivmodNear(PyObject *, PyObject *);
 PyAPI_DATA(PyObject*) _PyLong_Format(PyObject *obj, int base);
 
 // Export for 'math' shared extension
-PyAPI_DATA(PyObject*) _PyLong_Rshift(PyObject *, uint64_t);
+PyAPI_DATA(PyObject*) _PyLong_Rshift(PyObject *, int64_t);
 
 // Export for 'math' shared extension
-PyAPI_DATA(PyObject*) _PyLong_Lshift(PyObject *, uint64_t);
+PyAPI_DATA(PyObject*) _PyLong_Lshift(PyObject *, int64_t);
 
 PyAPI_FUNC(PyObject*) _PyLong_Add(PyLongObject *left, PyLongObject *right);
 PyAPI_FUNC(PyObject*) _PyLong_Multiply(PyLongObject *left, PyLongObject *right);
diff --git a/Modules/_pickle.c b/Modules/_pickle.c
index 6a94041e0a4734..b144affebf6584 100644
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -2140,7 +2140,7 @@ save_long(PicklerObject *self, PyObject *obj)
 
     if (self->proto >= 2) {
         /* Linear-time pickling. */
-        uint64_t nbits;
+        int64_t nbits;
         size_t nbytes;
         unsigned char *pdata;
         char header[5];
@@ -2155,6 +2155,7 @@ save_long(PicklerObject *self, PyObject *obj)
             return 0;
         }
         nbits = _PyLong_NumBits(obj);
+        assert(nbits >= 0);
         assert(!PyErr_Occurred());
         /* How many bytes do we need?  There are nbits >> 3 full
          * bytes of data, and nbits & 7 leftover bits.  If there
diff --git a/Modules/_randommodule.c b/Modules/_randommodule.c
index b07e19dd351e81..ad66df47349db0 100644
--- a/Modules/_randommodule.c
+++ b/Modules/_randommodule.c
@@ -295,7 +295,7 @@ random_seed(RandomObject *self, PyObject *arg)
     int result = -1;  /* guilty until proved innocent */
     PyObject *n = NULL;
     uint32_t *key = NULL;
-    uint64_t bits;
+    int64_t bits;
     size_t keyused;
     int res;
 
@@ -335,6 +335,7 @@ random_seed(RandomObject *self, PyObject *arg)
 
     /* Now split n into 32-bit chunks, from the right. */
     bits = _PyLong_NumBits(n);
+    assert(bits >= 0);
     assert(!PyErr_Occurred());
 
     /* Figure out how many 32-bit chunks this gives us. */
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 42b7426e9e6166..624328ace3d4db 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -1657,7 +1657,7 @@ math_isqrt(PyObject *module, PyObject *n)
 /*[clinic end generated code: output=35a6f7f980beab26 input=5b6e7ae4fa6c43d6]*/
 {
     int a_too_large, c_bit_length;
-    uint64_t c, d;
+    int64_t c, d;
     uint64_t m;
     uint32_t u;
     PyObject *a = NULL, *b;
@@ -1680,12 +1680,13 @@ math_isqrt(PyObject *module, PyObject *n)
 
     /* c = (n.bit_length() - 1) // 2 */
     c = _PyLong_NumBits(n);
+    assert(c > 0);
     assert(!PyErr_Occurred());
-    c = (c - 1U) / 2U;
+    c = (c - 1) / 2;
 
     /* Fast path: if c <= 31 then n < 2**64 and we can compute directly with a
        fast, almost branch-free algorithm. */
-    if (c <= 31U) {
+    if (c <= 31) {
         int shift = 31 - (int)c;
         m = (uint64_t)PyLong_AsUnsignedLongLong(n);
         Py_DECREF(n);
@@ -1702,13 +1703,13 @@ math_isqrt(PyObject *module, PyObject *n)
 
     /* From n >= 2**64 it follows that c.bit_length() >= 6. */
     c_bit_length = 6;
-    while ((c >> c_bit_length) > 0U) {
+    while ((c >> c_bit_length) > 0) {
         ++c_bit_length;
     }
 
     /* Initialise d and a. */
     d = c >> (c_bit_length - 5);
-    b = _PyLong_Rshift(n, 2U*c - 62U);
+    b = _PyLong_Rshift(n, 2*c - 62);
     if (b == NULL) {
         goto error;
     }
@@ -1725,12 +1726,12 @@ math_isqrt(PyObject *module, PyObject *n)
 
     for (int s = c_bit_length - 6; s >= 0; --s) {
         PyObject *q;
-        uint64_t e = d;
+        int64_t e = d;
 
         d = c >> s;
 
         /* q = (n >> 2*c - e - d + 1) // a */
-        q = _PyLong_Rshift(n, 2U*c - d - e + 1U);
+        q = _PyLong_Rshift(n, 2*c - d - e + 1);
         if (q == NULL) {
             goto error;
         }
@@ -1740,7 +1741,7 @@ math_isqrt(PyObject *module, PyObject *n)
         }
 
         /* a = (a << d - 1 - e) + q */
-        Py_SETREF(a, _PyLong_Lshift(a, d - 1U - e));
+        Py_SETREF(a, _PyLong_Lshift(a, d - 1 - e));
         if (a == NULL) {
             Py_DECREF(q);
             goto error;
@@ -2183,7 +2184,7 @@ loghelper(PyObject* arg, double (*func)(double))
     /* If it is int, do it ourselves. */
     if (PyLong_Check(arg)) {
         double x, result;
-        uint64_t e;
+        int64_t e;
 
         /* Negative or zero inputs give a ValueError. */
         if (!_PyLong_IsPositive((PyLongObject *)arg)) {
@@ -2200,6 +2201,7 @@ loghelper(PyObject* arg, double (*func)(double))
                to compute the log anyway.  Clear the exception and continue. */
             PyErr_Clear();
             x = _PyLong_Frexp((PyLongObject *)arg, &e);
+            assert(e >= 0);
             assert(!PyErr_Occurred());
             /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
             result = func(x) + func(2.0) * e;
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 1bc4711d754aa8..ba2abadce01c48 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -411,15 +411,16 @@ float_richcompare(PyObject *v, PyObject *w, int op)
         }
         /* The signs are the same. */
         /* Convert w to a double if it fits.  In particular, 0 fits. */
-        uint64_t nbits64 = _PyLong_NumBits(w);
-        if (nbits64 > (unsigned int)DBL_MAX_EXP) {
+        int64_t nbits64 = _PyLong_NumBits(w);
+        assert(nbits64 >= 0);
+        assert(!PyErr_Occurred());
+        if (nbits64 > DBL_MAX_EXP) {
             /* This Python integer is larger than any finite C double.
              * Replace with little doubles
              * that give the same outcome -- w is so large that
              * its magnitude must exceed the magnitude of any
              * finite float.
              */
-            assert(!PyErr_Occurred());
             i = (double)vsign;
             assert(wsign != 0);
             j = wsign * 2.0;
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 93f034ab28e558..64e7af92964a97 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -137,11 +137,11 @@ long_normalize(PyLongObject *v)
 # define MAX_LONG_DIGITS \
     ((PY_SSIZE_T_MAX - offsetof(PyLongObject, long_value.ob_digit))/sizeof(digit))
 #else
-/* Guarantee that the number of bits fits in uint64_t.
-   This is more than 2 exbibytes, that is more than many of modern
+/* Guarantee that the number of bits fits in int64_t.
+   This is more than an exbibyte, that is more than many of modern
    architectures support in principle.
    -1 is added to avoid overflow in _PyLong_Frexp(). */
-# define MAX_LONG_DIGITS ((UINT64_MAX-1) / (uint64_t)PyLong_SHIFT)
+# define MAX_LONG_DIGITS ((INT64_MAX-1) / PyLong_SHIFT)
 #endif
 
 PyLongObject *
@@ -812,11 +812,11 @@ bit_length_digit(digit x)
     return _Py_bit_length((unsigned long)x);
 }
 
-uint64_t
+int64_t
 _PyLong_NumBits(PyObject *vv)
 {
     PyLongObject *v = (PyLongObject *)vv;
-    uint64_t result = 0;
+    int64_t result = 0;
     Py_ssize_t ndigits;
     int msd_bits;
 
@@ -826,8 +826,8 @@ _PyLong_NumBits(PyObject *vv)
     assert(ndigits == 0 || v->long_value.ob_digit[ndigits - 1] != 0);
     if (ndigits > 0) {
         digit msd = v->long_value.ob_digit[ndigits - 1];
-        assert((uint64_t)ndigits <= UINT64_MAX / (uint64_t)PyLong_SHIFT);
-        result = (uint64_t)(ndigits - 1) * (uint64_t)PyLong_SHIFT;
+        assert(ndigits <= INT64_MAX / PyLong_SHIFT);
+        result = (int64_t)(ndigits - 1) * PyLong_SHIFT;
         msd_bits = bit_length_digit(msd);
         result += msd_bits;
     }
@@ -1246,7 +1246,8 @@ PyLong_AsNativeBytes(PyObject* vv, void* buffer, Py_ssize_t n, int flags)
 
         /* Calculates the number of bits required for the *absolute* value
          * of v. This does not take sign into account, only magnitude. */
-        uint64_t nb = _PyLong_NumBits((PyObject *)v);
+        int64_t nb = _PyLong_NumBits((PyObject *)v);
+        assert(nb >= 0);
         /* Normally this would be ((nb - 1) / 8) + 1 to avoid rounding up
          * multiples of 8 to the next byte, but we add an implied bit for
          * the sign and it cancels out. */
@@ -3408,11 +3409,11 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 #endif
 
 double
-_PyLong_Frexp(PyLongObject *a, uint64_t *e)
+_PyLong_Frexp(PyLongObject *a, int64_t *e)
 {
     Py_ssize_t a_size, shift_digits, x_size;
     int shift_bits;
-    uint64_t a_bits;
+    int64_t a_bits;
     /* See below for why x_digits is always large enough. */
     digit rem;
     digit x_digits[2 + (DBL_MANT_DIG + 1) / PyLong_SHIFT] = {0,};
@@ -3494,7 +3495,7 @@ _PyLong_Frexp(PyLongObject *a, uint64_t *e)
     /* Rescale;  make correction if result is 1.0. */
     dx /= 4.0 * EXP2_DBL_MANT_DIG;
     if (dx == 1.0) {
-        assert(a_bits < UINT64_MAX);
+        assert(a_bits < INT64_MAX);
         dx = 0.5;
         a_bits += 1;
     }
@@ -3509,7 +3510,7 @@ _PyLong_Frexp(PyLongObject *a, uint64_t *e)
 double
 PyLong_AsDouble(PyObject *v)
 {
-    uint64_t exponent;
+    int64_t exponent;
     double x;
 
     if (v == NULL) {
@@ -3528,6 +3529,7 @@ PyLong_AsDouble(PyObject *v)
         return (double)medium_value((PyLongObject *)v);
     }
     x = _PyLong_Frexp((PyLongObject *)v, &exponent);
+    assert(exponent >= 0);
     assert(!PyErr_Occurred());
     if (exponent > DBL_MAX_EXP) {
         PyErr_SetString(PyExc_OverflowError,
@@ -5292,7 +5294,7 @@ long_rshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift)
 static PyObject *
 long_rshift(PyObject *a, PyObject *b)
 {
-    uint64_t shiftby;
+    int64_t shiftby;
 
     CHECK_BINOP(a, b);
 
@@ -5303,7 +5305,7 @@ long_rshift(PyObject *a, PyObject *b)
     if (_PyLong_IsZero((PyLongObject *)a)) {
         return PyLong_FromLong(0);
     }
-    if (PyLong_AsUInt64(b, &shiftby) < 0) {
+    if (PyLong_AsInt64(b, &shiftby) < 0) {
         if (!PyErr_ExceptionMatches(PyExc_OverflowError)) {
             return NULL;
         }
@@ -5320,17 +5322,18 @@ long_rshift(PyObject *a, PyObject *b)
 
 /* Return a >> shiftby. */
 PyObject *
-_PyLong_Rshift(PyObject *a, uint64_t shiftby)
+_PyLong_Rshift(PyObject *a, int64_t shiftby)
 {
     Py_ssize_t wordshift;
     digit remshift;
 
     assert(PyLong_Check(a));
+    assert(shiftby >= 0);
     if (_PyLong_IsZero((PyLongObject *)a)) {
         return PyLong_FromLong(0);
     }
-#if PY_SSIZE_T_MAX <= UINT64_MAX / PyLong_SHIFT
-    if (shiftby > (uint64_t)PY_SSIZE_T_MAX * PyLong_SHIFT) {
+#if PY_SSIZE_T_MAX <= INT64_MAX / PyLong_SHIFT
+    if (shiftby > (int64_t)PY_SSIZE_T_MAX * PyLong_SHIFT) {
         if (_PyLong_IsNegative((PyLongObject *)a)) {
             return PyLong_FromLong(-1);
         }
@@ -5388,7 +5391,7 @@ long_lshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift)
 static PyObject *
 long_lshift(PyObject *a, PyObject *b)
 {
-    uint64_t shiftby;
+    int64_t shiftby;
 
     CHECK_BINOP(a, b);
 
@@ -5399,7 +5402,7 @@ long_lshift(PyObject *a, PyObject *b)
     if (_PyLong_IsZero((PyLongObject *)a)) {
         return PyLong_FromLong(0);
     }
-    if (PyLong_AsUInt64(b, &shiftby) < 0) {
+    if (PyLong_AsInt64(b, &shiftby) < 0) {
         if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
             PyErr_SetString(PyExc_OverflowError,
                             "too many digits in integer");
@@ -5411,17 +5414,18 @@ long_lshift(PyObject *a, PyObject *b)
 
 /* Return a << shiftby. */
 PyObject *
-_PyLong_Lshift(PyObject *a, uint64_t shiftby)
+_PyLong_Lshift(PyObject *a, int64_t shiftby)
 {
     Py_ssize_t wordshift;
     digit remshift;
 
     assert(PyLong_Check(a));
+    assert(shiftby >= 0);
     if (_PyLong_IsZero((PyLongObject *)a)) {
         return PyLong_FromLong(0);
     }
-#if PY_SSIZE_T_MAX <= UINT64_MAX / PyLong_SHIFT
-    if (shiftby > (uint64_t)PY_SSIZE_T_MAX * PyLong_SHIFT) {
+#if PY_SSIZE_T_MAX <= INT64_MAX / PyLong_SHIFT
+    if (shiftby > (int64_t)PY_SSIZE_T_MAX * PyLong_SHIFT) {
         PyErr_SetString(PyExc_OverflowError,
                         "too many digits in integer");
         return NULL;
@@ -6175,9 +6179,10 @@ static PyObject *
 int_bit_length_impl(PyObject *self)
 /*[clinic end generated code: output=fc1977c9353d6a59 input=e4eb7a587e849a32]*/
 {
-    uint64_t nbits = _PyLong_NumBits(self);
+    int64_t nbits = _PyLong_NumBits(self);
+    assert(nbits >= 0);
     assert(!PyErr_Occurred());
-    return PyLong_FromUInt64(nbits);
+    return PyLong_FromInt64(nbits);
 }
 
 static int
@@ -6211,13 +6216,13 @@ int_bit_count_impl(PyObject *self)
 
     PyLongObject *z = (PyLongObject *)self;
     Py_ssize_t ndigits = _PyLong_DigitCount(z);
-    uint64_t bit_count = 0;
+    int64_t bit_count = 0;
 
     for (Py_ssize_t i = 0; i < ndigits; i++) {
         bit_count += popcount_digit(z->long_value.ob_digit[i]);
     }
 
-    return PyLong_FromUInt64(bit_count);
+    return PyLong_FromInt64(bit_count);
 }
 
 /*[clinic input]
diff --git a/Python/ast_opt.c b/Python/ast_opt.c
index 330328816aa62a..8a9ad01eee0328 100644
--- a/Python/ast_opt.c
+++ b/Python/ast_opt.c
@@ -169,8 +169,10 @@ safe_multiply(PyObject *v, PyObject *w)
     if (PyLong_Check(v) && PyLong_Check(w) &&
         !_PyLong_IsZero((PyLongObject *)v) && !_PyLong_IsZero((PyLongObject *)w)
     ) {
-        uint64_t vbits = _PyLong_NumBits(v);
-        uint64_t wbits = _PyLong_NumBits(w);
+        int64_t vbits = _PyLong_NumBits(v);
+        int64_t wbits = _PyLong_NumBits(w);
+        assert(vbits >= 0);
+        assert(wbits >= 0);
         if (vbits + wbits > MAX_INT_SIZE) {
             return NULL;
         }
@@ -212,12 +214,13 @@ safe_power(PyObject *v, PyObject *w)
     if (PyLong_Check(v) && PyLong_Check(w) &&
         !_PyLong_IsZero((PyLongObject *)v) && _PyLong_IsPositive((PyLongObject *)w)
     ) {
-        uint64_t vbits = _PyLong_NumBits(v);
+        int64_t vbits = _PyLong_NumBits(v);
         size_t wbits = PyLong_AsSize_t(w);
+        assert(vbits >= 0);
         if (wbits == (size_t)-1) {
             return NULL;
         }
-        if (vbits > MAX_INT_SIZE / wbits) {
+        if ((uint64_t)vbits > MAX_INT_SIZE / wbits) {
             return NULL;
         }
     }
@@ -231,12 +234,13 @@ safe_lshift(PyObject *v, PyObject *w)
     if (PyLong_Check(v) && PyLong_Check(w) &&
         !_PyLong_IsZero((PyLongObject *)v) && !_PyLong_IsZero((PyLongObject *)w)
     ) {
-        uint64_t vbits = _PyLong_NumBits(v);
+        int64_t vbits = _PyLong_NumBits(v);
         size_t wbits = PyLong_AsSize_t(w);
+        assert(vbits >= 0);
         if (wbits == (size_t)-1) {
             return NULL;
         }
-        if (wbits > MAX_INT_SIZE || vbits > MAX_INT_SIZE - wbits) {
+        if (wbits > MAX_INT_SIZE || (uint64_t)vbits > MAX_INT_SIZE - wbits) {
             return NULL;
         }
     }

From 91868e50df0dbbc3919d165d39190fbb4792a034 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Thu, 5 Sep 2024 13:36:29 +0300
Subject: [PATCH 5/5] Fix MAX_LONG_DIGITS on 32-bit platforms.

---
 Objects/longobject.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 64e7af92964a97..9beb5884a6932b 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -133,7 +133,7 @@ long_normalize(PyLongObject *v)
 /* Allocate a new int object with size digits.
    Return NULL and set exception if we run out of memory. */
 
-#if SIZEOF_SIZE_T < 4
+#if SIZEOF_SIZE_T < 8
 # define MAX_LONG_DIGITS \
     ((PY_SSIZE_T_MAX - offsetof(PyLongObject, long_value.ob_digit))/sizeof(digit))
 #else