python · serhiy-storchaka · Aug 30, 2024 · Sep 3, 2024 · Sep 4, 2024 · Sep 4, 2024
diff --git 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
@@ -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
@@ -2161,8 +2161,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

@@ -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
@@ -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
@@ -407,18 +407,14 @@ 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);
+        assert(!PyErr_Occurred());
        if (nbits64 > (unsigned int)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.
             */
-            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();
-            }
            i = (double)vsign;
            assert(wsign != 0);
            j = wsign * 2.0;