/* Bit and bytes utilities.

   Bytes swap functions, reverse order of bytes:

   - _Py_bswap16(uint16_t)

   - _Py_bswap32(uint32_t)

   - _Py_bswap64(uint64_t)

*/

#ifndef Py_INTERNAL_BITUTILS_H

#define Py_INTERNAL_BITUTILS_H

#ifdef __cplusplus

extern "C" {

#endif

#ifndef Py_BUILD_CORE

#  error "this header requires Py_BUILD_CORE define"

#endif

#if defined(__GNUC__) \

      && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8))

   /* __builtin_bswap16() is available since GCC 4.8,

      __builtin_bswap32() is available since GCC 4.3,

      __builtin_bswap64() is available since GCC 4.3. */

#  define _PY_HAVE_BUILTIN_BSWAP

#endif

#ifdef _MSC_VER

   /* Get _byteswap_ushort(), _byteswap_ulong(), _byteswap_uint64() */

#  include <intrin.h>

#endif

static inline uint16_t

_Py_bswap16(uint16_t word)

{

#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap16)

    return __builtin_bswap16(word);

#elif defined(_MSC_VER)

    Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned short));

    return _byteswap_ushort(word);

#else

    // Portable implementation which doesn't rely on circular bit shift

    return ( ((word & UINT16_C(0x00FF)) << 8)

           | ((word & UINT16_C(0xFF00)) >> 8));

#endif

}

Unexecuted instantiation: longobject.c:_Py_bswap16

Unexecuted instantiation: dictobject.c:_Py_bswap16

Unexecuted instantiation: unicodeobject.c:_Py_bswap16

Unexecuted instantiation: hamt.c:_Py_bswap16

static inline uint32_t

_Py_bswap32(uint32_t word)

{

#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32)

    return __builtin_bswap32(word);

#elif defined(_MSC_VER)

    Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long));

    return _byteswap_ulong(word);

#else

    // Portable implementation which doesn't rely on circular bit shift

    return ( ((word & UINT32_C(0x000000FF)) << 24)

           | ((word & UINT32_C(0x0000FF00)) <<  8)

           | ((word & UINT32_C(0x00FF0000)) >>  8)

           | ((word & UINT32_C(0xFF000000)) >> 24));

#endif

}

Unexecuted instantiation: longobject.c:_Py_bswap32

Unexecuted instantiation: dictobject.c:_Py_bswap32

unicodeobject.c:_Py_bswap32

Line

Count

Source

50

{

51

#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32)

52

    return __builtin_bswap32(word);

53

#elif defined(_MSC_VER)

54

    Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long));

55

    return _byteswap_ulong(word);

56

#else

57

    // Portable implementation which doesn't rely on circular bit shift

58

    return ( ((word & UINT32_C(0x000000FF)) << 24)

59

           | ((word & UINT32_C(0x0000FF00)) <<  8)

60

           | ((word & UINT32_C(0x00FF0000)) >>  8)

61

           | ((word & UINT32_C(0xFF000000)) >> 24));

62

#endif

63

}

Unexecuted instantiation: hamt.c:_Py_bswap32

static inline uint64_t

_Py_bswap64(uint64_t word)

{

#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap64)

    return __builtin_bswap64(word);

#elif defined(_MSC_VER)

    return _byteswap_uint64(word);

#else

    // Portable implementation which doesn't rely on circular bit shift

    return ( ((word & UINT64_C(0x00000000000000FF)) << 56)

           | ((word & UINT64_C(0x000000000000FF00)) << 40)

           | ((word & UINT64_C(0x0000000000FF0000)) << 24)

           | ((word & UINT64_C(0x00000000FF000000)) <<  8)

           | ((word & UINT64_C(0x000000FF00000000)) >>  8)

           | ((word & UINT64_C(0x0000FF0000000000)) >> 24)

           | ((word & UINT64_C(0x00FF000000000000)) >> 40)

           | ((word & UINT64_C(0xFF00000000000000)) >> 56));

#endif

}

Unexecuted instantiation: longobject.c:_Py_bswap64

Unexecuted instantiation: dictobject.c:_Py_bswap64

Unexecuted instantiation: unicodeobject.c:_Py_bswap64

Unexecuted instantiation: hamt.c:_Py_bswap64

// Population count: count the number of 1's in 'x'

// (number of bits set to 1), also known as the hamming weight.

//

// Implementation note. CPUID is not used, to test if x86 POPCNT instruction

// can be used, to keep the implementation simple. For example, Visual Studio

// __popcnt() is not used this reason. The clang and GCC builtin function can

// use the x86 POPCNT instruction if the target architecture has SSE4a or

// newer.

static inline int

_Py_popcount32(uint32_t x)

{

#if (defined(__clang__) || defined(__GNUC__))

#if SIZEOF_INT >= 4

    Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned int));

    return __builtin_popcount(x);

#else

    // The C standard guarantees that unsigned long will always be big enough

    // to hold a uint32_t value without losing information.

    Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned long));

    return __builtin_popcountl(x);

#endif

#else

    // 32-bit SWAR (SIMD Within A Register) popcount

    // Binary: 0 1 0 1 ...

    const uint32_t M1 = 0x55555555;

    // Binary: 00 11 00 11. ..

    const uint32_t M2 = 0x33333333;

    // Binary: 0000 1111 0000 1111 ...

    const uint32_t M4 = 0x0F0F0F0F;

    // Put count of each 2 bits into those 2 bits

    x = x - ((x >> 1) & M1);

    // Put count of each 4 bits into those 4 bits

    x = (x & M2) + ((x >> 2) & M2);

    // Put count of each 8 bits into those 8 bits

    x = (x + (x >> 4)) & M4;

    // Sum of the 4 byte counts.

    // Take care when considering changes to the next line. Portability and

    // correctness are delicate here, thanks to C's "integer promotions" (C99

    // §6.3.1.1p2). On machines where the `int` type has width greater than 32

    // bits, `x` will be promoted to an `int`, and following C's "usual

    // arithmetic conversions" (C99 §6.3.1.8), the multiplication will be

    // performed as a multiplication of two `unsigned int` operands. In this

    // case it's critical that we cast back to `uint32_t` in order to keep only

    // the least significant 32 bits. On machines where the `int` type has

    // width no greater than 32, the multiplication is of two 32-bit unsigned

    // integer types, and the (uint32_t) cast is a no-op. In both cases, we

    // avoid the risk of undefined behaviour due to overflow of a

    // multiplication of signed integer types.

    return (uint32_t)(x * 0x01010101U) >> 24;

#endif

}

longobject.c:_Py_popcount32

Line

Count

Source

96

{

97

#if (defined(__clang__) || defined(__GNUC__))

98

99

#if SIZEOF_INT >= 4

100

    Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned int));

101

    return __builtin_popcount(x);

102

#else

103

    // The C standard guarantees that unsigned long will always be big enough

104

    // to hold a uint32_t value without losing information.

105

    Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned long));

106

    return __builtin_popcountl(x);

107

#endif

108

109

#else

110

    // 32-bit SWAR (SIMD Within A Register) popcount

111

112

    // Binary: 0 1 0 1 ...

113

    const uint32_t M1 = 0x55555555;

114

    // Binary: 00 11 00 11. ..

115

    const uint32_t M2 = 0x33333333;

116

    // Binary: 0000 1111 0000 1111 ...

117

    const uint32_t M4 = 0x0F0F0F0F;

118

119

    // Put count of each 2 bits into those 2 bits

120

    x = x - ((x >> 1) & M1);

121

    // Put count of each 4 bits into those 4 bits

122

    x = (x & M2) + ((x >> 2) & M2);

123

    // Put count of each 8 bits into those 8 bits

124

    x = (x + (x >> 4)) & M4;

125

    // Sum of the 4 byte counts.

126

    // Take care when considering changes to the next line. Portability and

127

    // correctness are delicate here, thanks to C's "integer promotions" (C99

128

    // §6.3.1.1p2). On machines where the `int` type has width greater than 32

129

    // bits, `x` will be promoted to an `int`, and following C's "usual

130

    // arithmetic conversions" (C99 §6.3.1.8), the multiplication will be

131

    // performed as a multiplication of two `unsigned int` operands. In this

132

    // case it's critical that we cast back to `uint32_t` in order to keep only

133

    // the least significant 32 bits. On machines where the `int` type has

134

    // width no greater than 32, the multiplication is of two 32-bit unsigned

135

    // integer types, and the (uint32_t) cast is a no-op. In both cases, we

136

    // avoid the risk of undefined behaviour due to overflow of a

137

    // multiplication of signed integer types.

138

    return (uint32_t)(x * 0x01010101U) >> 24;

139

#endif

140

}

Unexecuted instantiation: dictobject.c:_Py_popcount32

Unexecuted instantiation: unicodeobject.c:_Py_popcount32

hamt.c:_Py_popcount32

Line

Count

Source

96

{

97

#if (defined(__clang__) || defined(__GNUC__))

98

99

#if SIZEOF_INT >= 4

100

    Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned int));

101

    return __builtin_popcount(x);

102

#else

103

    // The C standard guarantees that unsigned long will always be big enough

104

    // to hold a uint32_t value without losing information.

105

    Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned long));

106

    return __builtin_popcountl(x);

107

#endif

108

109

#else

110

    // 32-bit SWAR (SIMD Within A Register) popcount

111

112

    // Binary: 0 1 0 1 ...

113

    const uint32_t M1 = 0x55555555;

114

    // Binary: 00 11 00 11. ..

115

    const uint32_t M2 = 0x33333333;

116

    // Binary: 0000 1111 0000 1111 ...

117

    const uint32_t M4 = 0x0F0F0F0F;

118

119

    // Put count of each 2 bits into those 2 bits

120

    x = x - ((x >> 1) & M1);

121

    // Put count of each 4 bits into those 4 bits

122

    x = (x & M2) + ((x >> 2) & M2);

123

    // Put count of each 8 bits into those 8 bits

124

    x = (x + (x >> 4)) & M4;

125

    // Sum of the 4 byte counts.

126

    // Take care when considering changes to the next line. Portability and

127

    // correctness are delicate here, thanks to C's "integer promotions" (C99

128

    // §6.3.1.1p2). On machines where the `int` type has width greater than 32

129

    // bits, `x` will be promoted to an `int`, and following C's "usual

130

    // arithmetic conversions" (C99 §6.3.1.8), the multiplication will be

131

    // performed as a multiplication of two `unsigned int` operands. In this

132

    // case it's critical that we cast back to `uint32_t` in order to keep only

133

    // the least significant 32 bits. On machines where the `int` type has

134

    // width no greater than 32, the multiplication is of two 32-bit unsigned

135

    // integer types, and the (uint32_t) cast is a no-op. In both cases, we

136

    // avoid the risk of undefined behaviour due to overflow of a

137

    // multiplication of signed integer types.

138

    return (uint32_t)(x * 0x01010101U) >> 24;

139

#endif

140

}

// Return the index of the most significant 1 bit in 'x'. This is the smallest

// integer k such that x < 2**k. Equivalent to floor(log2(x)) + 1 for x != 0.

static inline int

_Py_bit_length(unsigned long x)

{

#if (defined(__clang__) || defined(__GNUC__))

    if (x != 0) {

  Branch (149:9): [True: 10.5M, False: 0]
  Branch (149:9): [True: 2.34M, False: 0]

        // __builtin_clzl() is available since GCC 3.4.

        // Undefined behavior for x == 0.

        return (int)sizeof(unsigned long) * 8 - __builtin_clzl(x);

    }

    else {

        return 0;

    }

#elif defined(_MSC_VER)

    // _BitScanReverse() is documented to search 32 bits.

    Py_BUILD_ASSERT(sizeof(unsigned long) <= 4);

    unsigned long msb;

    if (_BitScanReverse(&msb, x)) {

        return (int)msb + 1;

    }

    else {

        return 0;

    }

#else

    const int BIT_LENGTH_TABLE[32] = {

        0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5

    };

    int msb = 0;

    while (x >= 32) {

        msb += 6;

        x >>= 6;

    }

    msb += BIT_LENGTH_TABLE[x];

    return msb;

#endif

}

longobject.c:_Py_bit_length

Line

Count

Source

147

{

148

#if (defined(__clang__) || defined(__GNUC__))

149

    if (x != 0) {

  Branch (149:9): [True: 10.5M, False: 0]

150

        // __builtin_clzl() is available since GCC 3.4.

151

        // Undefined behavior for x == 0.

152

        return (int)sizeof(unsigned long) * 8 - __builtin_clzl(x);

153

    }

154

    else {

155

        return 0;

156

    }

157

#elif defined(_MSC_VER)

158

    // _BitScanReverse() is documented to search 32 bits.

159

    Py_BUILD_ASSERT(sizeof(unsigned long) <= 4);

160

    unsigned long msb;

161

    if (_BitScanReverse(&msb, x)) {

162

        return (int)msb + 1;

163

    }

164

    else {

165

        return 0;

166

    }

167

#else

168

    const int BIT_LENGTH_TABLE[32] = {

169

        0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

170

        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5

171

    };

172

    int msb = 0;

173

    while (x >= 32) {

174

        msb += 6;

175

        x >>= 6;

176

    }

177

    msb += BIT_LENGTH_TABLE[x];

178

    return msb;

179

#endif

180

}

dictobject.c:_Py_bit_length

Line

Count

Source

147

{

148

#if (defined(__clang__) || defined(__GNUC__))

149

    if (x != 0) {

  Branch (149:9): [True: 2.34M, False: 0]

150

        // __builtin_clzl() is available since GCC 3.4.

151

        // Undefined behavior for x == 0.

152

        return (int)sizeof(unsigned long) * 8 - __builtin_clzl(x);

153

    }

154

    else {

155

        return 0;

156

    }

157

#elif defined(_MSC_VER)

158

    // _BitScanReverse() is documented to search 32 bits.

159

    Py_BUILD_ASSERT(sizeof(unsigned long) <= 4);

160

    unsigned long msb;

161

    if (_BitScanReverse(&msb, x)) {

162

        return (int)msb + 1;

163

    }

164

    else {

165

        return 0;

166

    }

167

#else

168

    const int BIT_LENGTH_TABLE[32] = {

169

        0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

170

        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5

171

    };

172

    int msb = 0;

173

    while (x >= 32) {

174

        msb += 6;

175

        x >>= 6;

176

    }

177

    msb += BIT_LENGTH_TABLE[x];

178

    return msb;

179

#endif

180

}

Unexecuted instantiation: unicodeobject.c:_Py_bit_length

Unexecuted instantiation: hamt.c:_Py_bit_length

#ifdef __cplusplus

}

#endif

#endif /* !Py_INTERNAL_BITUTILS_H */