lib/count-one-bits.h

   1 /* count-one-bits.h -- counts the number of 1-bits in a word.
   2    Copyright (C) 2007-2019 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Ben Pfaff.  */
  18
  19 #ifndef COUNT_ONE_BITS_H
  20 #define COUNT_ONE_BITS_H 1
  21
  22 #include <limits.h>
  23 #include <stdlib.h>
  24
  25 #ifndef _GL_INLINE_HEADER_BEGIN
  26  #error "Please include config.h first."
  27 #endif
  28 _GL_INLINE_HEADER_BEGIN
  29 #ifndef COUNT_ONE_BITS_INLINE
  30 # define COUNT_ONE_BITS_INLINE _GL_INLINE
  31 #endif
  32
  33 /* Expand to code that computes the number of 1-bits of the local
  34    variable 'x' of type TYPE (an unsigned integer type) and return it
  35    from the current function.  */
  36 #define COUNT_ONE_BITS_GENERIC(TYPE)                                   \
  37     do                                                                  \
  38       {                                                                 \
  39         int count = 0;                                                  \
  40         int bits;                                                       \
  41         for (bits = 0; bits < sizeof (TYPE) * CHAR_BIT; bits += 32)     \
  42           {                                                             \
  43             count += count_one_bits_32 (x);                             \
  44             x = x >> 31 >> 1;                                           \
  45           }                                                             \
  46         return count;                                                   \
  47       }                                                                 \
  48     while (0)
  49
  50 /* Assuming the GCC builtin is BUILTIN and the MSC builtin is MSC_BUILTIN,
  51    expand to code that computes the number of 1-bits of the local
  52    variable 'x' of type TYPE (an unsigned integer type) and return it
  53    from the current function.  */
  54 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  55 # define COUNT_ONE_BITS(BUILTIN, MSC_BUILTIN, TYPE) return BUILTIN (x)
  56 #else
  57
  58 /* Compute and return the number of 1-bits set in the least
  59    significant 32 bits of X. */
  60 COUNT_ONE_BITS_INLINE int
  61 count_one_bits_32 (unsigned int x)
  62 {
  63   x = ((x & 0xaaaaaaaaU) >> 1) + (x & 0x55555555U);
  64   x = ((x & 0xccccccccU) >> 2) + (x & 0x33333333U);
  65   x = (x >> 16) + (x & 0xffff);
  66   x = ((x & 0xf0f0) >> 4) + (x & 0x0f0f);
  67   return (x >> 8) + (x & 0x00ff);
  68 }
  69
  70 # if 1500 <= _MSC_VER && (defined _M_IX86 || defined _M_X64)
  71
  72 /* While gcc falls back to its own generic code if the machine
  73    on which it's running doesn't support popcount, with Microsoft's
  74    compiler we need to detect and fallback ourselves.  */
  75 #  pragma intrinsic __cpuid
  76 #  pragma intrinsic __popcnt
  77 #  pragma intrinsic __popcnt64
  78
  79 /* Return nonzero if popcount is supported.  */
  80
  81 /* 1 if supported, 0 if not supported, -1 if unknown.  */
  82 extern int popcount_support;
  83
  84 COUNT_ONE_BITS_INLINE int
  85 popcount_supported (void)
  86 {
  87   if (popcount_support < 0)
  88     {
  89       int cpu_info[4];
  90       __cpuid (cpu_info, 1);
  91       popcount_support = (cpu_info[2] >> 23) & 1;  /* See MSDN.  */
  92     }
  93   return popcount_support;
  94 }
  95
  96 #  define COUNT_ONE_BITS(BUILTIN, MSC_BUILTIN, TYPE)    \
  97      do                                                 \
  98        {                                                \
  99          if (popcount_supported ())                     \
 100            return MSC_BUILTIN (x);                      \
 101          else                                           \
 102            COUNT_ONE_BITS_GENERIC (TYPE);               \
 103        }                                                \
 104      while (0)
 105 # else
 106 #  define COUNT_ONE_BITS(BUILTIN, MSC_BUILTIN, TYPE)    \
 107      COUNT_ONE_BITS_GENERIC (TYPE)
 108 # endif
 109 #endif
 110
 111 /* Compute and return the number of 1-bits set in X. */
 112 COUNT_ONE_BITS_INLINE int
 113 count_one_bits (unsigned int x)
 114 {
 115   COUNT_ONE_BITS (__builtin_popcount, __popcnt, unsigned int);
 116 }
 117
 118 /* Compute and return the number of 1-bits set in X. */
 119 COUNT_ONE_BITS_INLINE int
 120 count_one_bits_l (unsigned long int x)
 121 {
 122   COUNT_ONE_BITS (__builtin_popcountl, __popcnt, unsigned long int);
 123 }
 124
 125 #if HAVE_UNSIGNED_LONG_LONG_INT
 126 /* Compute and return the number of 1-bits set in X. */
 127 COUNT_ONE_BITS_INLINE int
 128 count_one_bits_ll (unsigned long long int x)
 129 {
 130   COUNT_ONE_BITS (__builtin_popcountll, __popcnt64, unsigned long long int);
 131 }
 132 #endif
 133
 134 _GL_INLINE_HEADER_END
 135
 136 #endif /* COUNT_ONE_BITS_H */