@@ -787,26 +787,6 @@ _PyLong_Sign(PyObject *vv)
787
787
return Py_SIZE (v ) == 0 ? 0 : (Py_SIZE (v ) < 0 ? -1 : 1 );
788
788
}
789
789
790
- /* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d <
791
- 2**k if d is nonzero, else 0. */
792
-
793
- static const unsigned char BitLengthTable [32 ] = {
794
- 0 , 1 , 2 , 2 , 3 , 3 , 3 , 3 , 4 , 4 , 4 , 4 , 4 , 4 , 4 , 4 ,
795
- 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5
796
- };
797
-
798
- static int
799
- bits_in_digit (digit d )
800
- {
801
- int d_bits = 0 ;
802
- while (d >= 32 ) {
803
- d_bits += 6 ;
804
- d >>= 6 ;
805
- }
806
- d_bits += (int )BitLengthTable [d ];
807
- return d_bits ;
808
- }
809
-
810
790
size_t
811
791
_PyLong_NumBits (PyObject * vv )
812
792
{
@@ -824,7 +804,7 @@ _PyLong_NumBits(PyObject *vv)
824
804
if ((size_t )(ndigits - 1 ) > SIZE_MAX / (size_t )PyLong_SHIFT )
825
805
goto Overflow ;
826
806
result = (size_t )(ndigits - 1 ) * (size_t )PyLong_SHIFT ;
827
- msd_bits = bits_in_digit (msd );
807
+ msd_bits = _Py_bit_length (msd );
828
808
if (SIZE_MAX - msd_bits < result )
829
809
goto Overflow ;
830
810
result += msd_bits ;
@@ -1985,7 +1965,7 @@ long_format_binary(PyObject *aa, int base, int alternate,
1985
1965
return -1 ;
1986
1966
}
1987
1967
size_a_in_bits = (size_a - 1 ) * PyLong_SHIFT +
1988
- bits_in_digit (a -> ob_digit [size_a - 1 ]);
1968
+ _Py_bit_length (a -> ob_digit [size_a - 1 ]);
1989
1969
/* Allow 1 character for a '-' sign. */
1990
1970
sz = negative + (size_a_in_bits + (bits - 1 )) / bits ;
1991
1971
}
@@ -2805,7 +2785,7 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
2805
2785
2806
2786
/* normalize: shift w1 left so that its top digit is >= PyLong_BASE/2.
2807
2787
shift v1 left by the same amount. Results go into w and v. */
2808
- d = PyLong_SHIFT - bits_in_digit (w1 -> ob_digit [size_w - 1 ]);
2788
+ d = PyLong_SHIFT - _Py_bit_length (w1 -> ob_digit [size_w - 1 ]);
2809
2789
carry = v_lshift (w -> ob_digit , w1 -> ob_digit , size_w , d );
2810
2790
assert (carry == 0 );
2811
2791
carry = v_lshift (v -> ob_digit , v1 -> ob_digit , size_v , d );
@@ -2926,7 +2906,7 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e)
2926
2906
* e = 0 ;
2927
2907
return 0.0 ;
2928
2908
}
2929
- a_bits = bits_in_digit (a -> ob_digit [a_size - 1 ]);
2909
+ a_bits = _Py_bit_length (a -> ob_digit [a_size - 1 ]);
2930
2910
/* The following is an overflow-free version of the check
2931
2911
"if ((a_size - 1) * PyLong_SHIFT + a_bits > PY_SSIZE_T_MAX) ..." */
2932
2912
if (a_size >= (PY_SSIZE_T_MAX - 1 ) / PyLong_SHIFT + 1 &&
@@ -4020,8 +4000,8 @@ long_true_divide(PyObject *v, PyObject *w)
4020
4000
/* Extreme underflow */
4021
4001
goto underflow_or_zero ;
4022
4002
/* Next line is now safe from overflowing a Py_ssize_t */
4023
- diff = diff * PyLong_SHIFT + bits_in_digit (a -> ob_digit [a_size - 1 ]) -
4024
- bits_in_digit (b -> ob_digit [b_size - 1 ]);
4003
+ diff = diff * PyLong_SHIFT + _Py_bit_length (a -> ob_digit [a_size - 1 ]) -
4004
+ _Py_bit_length (b -> ob_digit [b_size - 1 ]);
4025
4005
/* Now diff = a_bits - b_bits. */
4026
4006
if (diff > DBL_MAX_EXP )
4027
4007
goto overflow ;
@@ -4097,7 +4077,7 @@ long_true_divide(PyObject *v, PyObject *w)
4097
4077
}
4098
4078
x_size = Py_ABS (Py_SIZE (x ));
4099
4079
assert (x_size > 0 ); /* result of division is never zero */
4100
- x_bits = (x_size - 1 )* PyLong_SHIFT + bits_in_digit (x -> ob_digit [x_size - 1 ]);
4080
+ x_bits = (x_size - 1 )* PyLong_SHIFT + _Py_bit_length (x -> ob_digit [x_size - 1 ]);
4101
4081
4102
4082
/* The number of extra bits that have to be rounded away. */
4103
4083
extra_bits = Py_MAX (x_bits , DBL_MIN_EXP - shift ) - DBL_MANT_DIG ;
@@ -4805,7 +4785,7 @@ _PyLong_GCD(PyObject *aarg, PyObject *barg)
4805
4785
alloc_b = Py_SIZE (b );
4806
4786
/* reduce until a fits into 2 digits */
4807
4787
while ((size_a = Py_SIZE (a )) > 2 ) {
4808
- nbits = bits_in_digit (a -> ob_digit [size_a - 1 ]);
4788
+ nbits = _Py_bit_length (a -> ob_digit [size_a - 1 ]);
4809
4789
/* extract top 2*PyLong_SHIFT bits of a into x, along with
4810
4790
corresponding bits of b into y */
4811
4791
size_b = Py_SIZE (b );
@@ -5322,7 +5302,7 @@ int_bit_length_impl(PyObject *self)
5322
5302
return PyLong_FromLong (0 );
5323
5303
5324
5304
msd = ((PyLongObject * )self )-> ob_digit [ndigits - 1 ];
5325
- msd_bits = bits_in_digit (msd );
5305
+ msd_bits = _Py_bit_length (msd );
5326
5306
5327
5307
if (ndigits <= PY_SSIZE_T_MAX /PyLong_SHIFT )
5328
5308
return PyLong_FromSsize_t ((ndigits - 1 )* PyLong_SHIFT + msd_bits );
0 commit comments