bpo-29782: Consolidate _Py_Bit_Length() (GH-20739) · python/cpython@794e7d1 (original) (raw)

`@@ -695,6 +695,13 @@ _PyLong_Sign(PyObject *vv)

`

695

695

`return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1);

`

696

696

`}

`

697

697

``

``

698

`+

static int

`

``

699

`+

bit_length_digit(digit x)

`

``

700

`+

{

`

``

701

`+

Py_BUILD_ASSERT(PyLong_SHIFT <= sizeof(unsigned long) * 8);

`

``

702

`+

return _Py_bit_length((unsigned long)x);

`

``

703

`+

}

`

``

704

+

698

705

`size_t

`

699

706

`_PyLong_NumBits(PyObject *vv)

`

700

707

`{

`

`@@ -712,7 +719,7 @@ _PyLong_NumBits(PyObject *vv)

`

712

719

`if ((size_t)(ndigits - 1) > SIZE_MAX / (size_t)PyLong_SHIFT)

`

713

720

` goto Overflow;

`

714

721

`result = (size_t)(ndigits - 1) * (size_t)PyLong_SHIFT;

`

715

``

`-

msd_bits = _Py_bit_length(msd);

`

``

722

`+

msd_bits = bit_length_digit(msd);

`

716

723

`if (SIZE_MAX - msd_bits < result)

`

717

724

` goto Overflow;

`

718

725

`result += msd_bits;

`

`@@ -1822,7 +1829,7 @@ long_format_binary(PyObject *aa, int base, int alternate,

`

1822

1829

`return -1;

`

1823

1830

` }

`

1824

1831

`size_a_in_bits = (size_a - 1) * PyLong_SHIFT +

`

1825

``

`-

_Py_bit_length(a->ob_digit[size_a - 1]);

`

``

1832

`+

bit_length_digit(a->ob_digit[size_a - 1]);

`

1826

1833

`/* Allow 1 character for a '-' sign. */

`

1827

1834

`sz = negative + (size_a_in_bits + (bits - 1)) / bits;

`

1828

1835

` }

`

`@@ -2642,7 +2649,7 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)

`

2642

2649

``

2643

2650

`/* normalize: shift w1 left so that its top digit is >= PyLong_BASE/2.

`

2644

2651

` shift v1 left by the same amount. Results go into w and v. */

`

2645

``

`-

d = PyLong_SHIFT - _Py_bit_length(w1->ob_digit[size_w-1]);

`

``

2652

`+

d = PyLong_SHIFT - bit_length_digit(w1->ob_digit[size_w-1]);

`

2646

2653

`carry = v_lshift(w->ob_digit, w1->ob_digit, size_w, d);

`

2647

2654

`assert(carry == 0);

`

2648

2655

`carry = v_lshift(v->ob_digit, v1->ob_digit, size_v, d);

`

`@@ -2764,7 +2771,7 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e)

`

2764

2771

`*e = 0;

`

2765

2772

`return 0.0;

`

2766

2773

` }

`

2767

``

`-

a_bits = _Py_bit_length(a->ob_digit[a_size-1]);

`

``

2774

`+

a_bits = bit_length_digit(a->ob_digit[a_size-1]);

`

2768

2775

`/* The following is an overflow-free version of the check

`

2769

2776

` "if ((a_size - 1) * PyLong_SHIFT + a_bits > PY_SSIZE_T_MAX) ..." */

`

2770

2777

`if (a_size >= (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 &&

`

`@@ -3857,8 +3864,8 @@ long_true_divide(PyObject *v, PyObject *w)

`

3857

3864

`/* Extreme underflow */

`

3858

3865

` goto underflow_or_zero;

`

3859

3866

`/* Next line is now safe from overflowing a Py_ssize_t */

`

3860

``

`-

diff = diff * PyLong_SHIFT + _Py_bit_length(a->ob_digit[a_size - 1]) -

`

3861

``

`-

_Py_bit_length(b->ob_digit[b_size - 1]);

`

``

3867

`+

diff = diff * PyLong_SHIFT + bit_length_digit(a->ob_digit[a_size - 1]) -

`

``

3868

`+

bit_length_digit(b->ob_digit[b_size - 1]);

`

3862

3869

`/* Now diff = a_bits - b_bits. */

`

3863

3870

`if (diff > DBL_MAX_EXP)

`

3864

3871

` goto overflow;

`

`@@ -3934,7 +3941,7 @@ long_true_divide(PyObject *v, PyObject *w)

`

3934

3941

` }

`

3935

3942

`x_size = Py_ABS(Py_SIZE(x));

`

3936

3943

`assert(x_size > 0); /* result of division is never zero */

`

3937

``

`-

x_bits = (x_size-1)*PyLong_SHIFT+_Py_bit_length(x->ob_digit[x_size-1]);

`

``

3944

`+

x_bits = (x_size-1)*PyLong_SHIFT+bit_length_digit(x->ob_digit[x_size-1]);

`

3938

3945

``

3939

3946

`/* The number of extra bits that have to be rounded away. */

`

3940

3947

`extra_bits = Py_MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG;

`

`@@ -4748,7 +4755,7 @@ _PyLong_GCD(PyObject *aarg, PyObject *barg)

`

4748

4755

`alloc_b = Py_SIZE(b);

`

4749

4756

`/* reduce until a fits into 2 digits */

`

4750

4757

`while ((size_a = Py_SIZE(a)) > 2) {

`

4751

``

`-

nbits = _Py_bit_length(a->ob_digit[size_a-1]);

`

``

4758

`+

nbits = bit_length_digit(a->ob_digit[size_a-1]);

`

4752

4759

`/* extract top 2*PyLong_SHIFT bits of a into x, along with

`

4753

4760

` corresponding bits of b into y */

`

4754

4761

`size_b = Py_SIZE(b);

`

`@@ -5269,7 +5276,7 @@ int_bit_length_impl(PyObject *self)

`

5269

5276

`return PyLong_FromLong(0);

`

5270

5277

``

5271

5278

`msd = ((PyLongObject *)self)->ob_digit[ndigits-1];

`

5272

``

`-

msd_bits = _Py_bit_length(msd);

`

``

5279

`+

msd_bits = bit_length_digit(msd);

`

5273

5280

``

5274

5281

`if (ndigits <= PY_SSIZE_T_MAX/PyLong_SHIFT)

`

5275

5282

`return PyLong_FromSsize_t((ndigits-1)*PyLong_SHIFT + msd_bits);

`