예제 #1
0
파일: bit_details.hpp 프로젝트: ncm/bit
constexpr T _lzcnt(T src)
{
    static_assert(binary_digits<T>::value, "");
    constexpr T digits = binary_digits<T>::value;
    T dest = 0;
    if (digits < std::numeric_limits<unsigned int>::digits) {
        dest = src ? __builtin_clz(src)
                     - (std::numeric_limits<unsigned int>::digits 
                     - digits)
                   : digits;
    } else if (digits == std::numeric_limits<unsigned int>::digits) {
        dest = src ? __builtin_clz(src) : digits;
    } else if (digits < std::numeric_limits<unsigned long int>::digits) {
        dest = src ? __builtin_clzl(src)
                     - (std::numeric_limits<unsigned long int>::digits 
                     - digits)
                   : digits;
    } else if (digits == std::numeric_limits<unsigned long int>::digits) {
        dest = src ? __builtin_clzl(src) : digits;
    } else if (digits < std::numeric_limits<unsigned long long int>::digits) {
        dest = src ? __builtin_clzll(src)
                     - (std::numeric_limits<unsigned long long int>::digits 
                     - digits)
                   : digits;
    } else if (digits == std::numeric_limits<unsigned long long int>::digits) {
        dest = src ? __builtin_clzll(src) : digits;
    } else {
        dest = _lzcnt(src, std::ignore);
    }
    return dest;
}
예제 #2
0
/* { dg-require-fdump "" } */
int
foo (unsigned long a)
{
  int b = __builtin_clzl (a);
  int c = __builtin_clzl (a);
  if (b == c)
    return 1;
  return 0;
}
예제 #3
0
파일: math.c 프로젝트: SonnyJim/freewpc
/** Divide a 32-bit value by a 16-bit value, and return the
 * quotient and the remainder */
void udiv32 (U32 reg, U16 divisor, U32 *quotientp, U32 *remainderp)
{
	U32 quotient = 0;

	S16 y0 = 16 - __builtin_clz (divisor);
	while (reg >= divisor)
	{
		S16 guess = 31 - __builtin_clzl (reg) - y0;
		if ((guess > 0) && (guess < 32))
		{
			quotient += powers_of_two_table[guess];
			reg -= divisor * powers_of_two_table[guess];
		}
		else
		{
			quotient++;
			reg -= divisor;
		}
	}

	if (*remainderp)
		*remainderp = reg;
	if (*quotientp)
		*quotientp = quotient;
}
예제 #4
0
파일: mathsupport.c 프로젝트: 9beckert/TIR
unsigned int gt_determinebitspervalue(unsigned long maxvalue)
{
  unsigned int bits = 0;
  unsigned long value;

  for (value = maxvalue; value > 0; value >>= 1)
  {
    bits++;
  }
#define GT_MAXLOG2VALUE 63
  gt_assert(bits <= GT_MAXLOG2VALUE);
#ifdef USEbuiltin_clzl
  {
    unsigned int fastbits = (unsigned int) (sizeof(unsigned long) * CHAR_BIT) -
                            __builtin_clzl(maxvalue);
    if (bits != fastbits)
    {
      fprintf(stderr,"maxvalue=%lu: bits = %u != %d = clzl\n",
                        maxvalue,bits,fastbits);
      exit(EXIT_FAILURE);
    }
  }
#endif
  return bits;
}
예제 #5
0
Size findLastBit(Size a) {
#ifdef __GNUC__
#ifdef __X64__
    return sizeof(a)*8 - 1 - __builtin_clzl(a);
#else
    return sizeof(a)*8 - 1 - __builtin_clz(a);
#endif
#elif defined(_MSC_VER)
    unsigned long pos;
#ifdef __X64__
    _BitScanReverse64(&pos, a);
#else
	_BitScanReverse(&pos, a);
#endif
	return sizeof(a)*8 - 1 - pos;
#else
	//Very naive implementation.
	Size c = sizeof(a)*8 - 1;
    const Size mask = 1 << c;
	while(!(a & mask)) {
		a <<= 1;
		c--;
	}
	return c;
#endif
}
예제 #6
0
파일: strings.c 프로젝트: Strongc/WinObjC
static inline unsigned char
_BitScanReverse(unsigned long *_Index, unsigned long _Mask) {
  if (!_Mask)
    return 0;
  *_Index = 31 - __builtin_clzl(_Mask);
  return 1;
}
예제 #7
0
static void
sb_check (sb *ptr, size_t len)
{
  size_t want = ptr->len + len;

  if (want > ptr->max)
    {
      size_t max;

      want += MALLOC_OVERHEAD + 1;
      if ((ssize_t) want < 0)
	as_fatal ("string buffer overflow");
#if GCC_VERSION >= 3004
      max = (size_t) 1 << (CHAR_BIT * sizeof (want)
			   - (sizeof (want) <= sizeof (long)
			      ? __builtin_clzl ((long) want)
			      : __builtin_clzll ((long long) want)));
#else
      max = 128;
      while (want > max)
	max <<= 1;
#endif
      max -= MALLOC_OVERHEAD + 1;
      ptr->max = max;
      ptr->ptr = xrealloc (ptr->ptr, max + 1);
    }
}
예제 #8
0
파일: lwan.c 프로젝트: dreamsxin/lwan
size_t
lwan_nextpow2(size_t number)
{
#if defined(HAVE_BUILTIN_CLZLL)
    static const int size_bits = (int)sizeof(number) * CHAR_BIT;

    if (sizeof(size_t) == sizeof(unsigned int)) {
        return (size_t)1 << (size_bits - __builtin_clz((unsigned int)number));
    } else if (sizeof(size_t) == sizeof(unsigned long)) {
        return (size_t)1 << (size_bits - __builtin_clzl((unsigned long)number));
    } else if (sizeof(size_t) == sizeof(unsigned long long)) {
        return (size_t)1 << (size_bits - __builtin_clzll((unsigned long long)number));
    } else {
        (void)size_bits;
    }
#endif

    number--;
    number |= number >> 1;
    number |= number >> 2;
    number |= number >> 4;
    number |= number >> 8;
    number |= number >> 16;

    return number + 1;
}
예제 #9
0
파일: strbuf.c 프로젝트: byzhang/lwan
static size_t
find_next_power_of_two(size_t number)
{
#if HAVE_BUILTIN_CLZLL
    static const int size_bits = (int)sizeof(number) * CHAR_BIT;

    if (sizeof(size_t) == sizeof(unsigned int)) {
        return 1U << (size_bits - __builtin_clz((unsigned int)number));
    } else if (sizeof(size_t) == sizeof(unsigned long)) {
        return 1UL << (size_bits - __builtin_clzl((unsigned long)number));
    } else if (sizeof(size_t) == sizeof(unsigned long long)) {
        return 1ULL << (size_bits - __builtin_clzll((unsigned long long)number));
    } else {
        __builtin_unreachable();
    }
#else
    number--;
    number |= number >> 1;
    number |= number >> 2;
    number |= number >> 4;
    number |= number >> 8;
    number |= number >> 16;
    return number + 1;
#endif
}
예제 #10
0
/*
 * Binary logarithm of value (exact if the value is a power of 2,
 * appoximate otherwise)
 */
static PT_ID_T
pt_log2(PT_ID_T val)
{
	pt_assert(val > 0);
	return sizeof(unsigned long) * CHAR_BIT -
		__builtin_clzl((unsigned long) val) - 1;
}
예제 #11
0
uint32_t sl_siglines_process_signals(struct sl_siglines* sglns) 
{
    BUG_ON(!is_direction_receiver(sglns->dir));

	uint32_t nprocessed = 0;
	uint32_t i, bit_n, start_bit, end_bit, max_i = (sglns->num_lines/ NBITS_PER_UINT64);
	uint64_t* bits_p;
	uint64_t  bits_value;

	for (i = 0; i < max_i;	i++)
	{
		bits_p = &sglns->event_lines[i];
		bits_value = *bits_p;

		if (bits_value != 0)
		{
			start_bit = (uint32_t)__builtin_ctzl(bits_value);
			end_bit = NBITS_PER_UINT64 - (uint32_t)__builtin_clzl(bits_value);

			for (bit_n = start_bit; bit_n < end_bit; bit_n++)
			{
				if (unlikely(test_and_clear_bit(bits_p, bit_n) == 0)) continue;

				sl_sigline_t line = NBITS_PER_UINT64 * i + bit_n;
				sglns->handler(sglns, line);

				nprocessed++;
			}
		}
	}

    return nprocessed;
}
예제 #12
0
void check_clz(int n) {
  // RECOVER: builtins.cpp:[[@LINE+1]]:17: runtime error: passing zero to clz(), which is not a valid argument
  __builtin_clz(n);

  // RECOVER: builtins.cpp:[[@LINE+1]]:18: runtime error: passing zero to clz(), which is not a valid argument
  __builtin_clzl(n);

  // RECOVER: builtins.cpp:[[@LINE+1]]:19: runtime error: passing zero to clz(), which is not a valid argument
  __builtin_clzll(n);
}
예제 #13
0
    std::shared_ptr<qube<T>> get( const vec4i& s )
        {
            size_t bucket = 64 - __builtin_clzl( __znn_aligned_size<qube<T>>::value
                                                 + s[0]*s[1]*s[2]*s[3]*sizeof(T) - 1 );

            void*    mem  = buckets_[bucket].get();
            T*       data = __offset_cast<T>(mem, __znn_aligned_size<qube<T>>::value);
            qube<T>* c    = new (mem) qube<T>(s,data);

            return std::shared_ptr<qube<T>>(c,[this,bucket](qube<T>* c) {
                    this->buckets_[bucket].return_memory(c);
                }, allocator<qube<T>>());
        }
예제 #14
0
static void layer_state_set(uint32_t state)
{
    dprint("layer_state: ");
    layer_debug(); dprint(" to ");
    layer_state = state;
    layer_debug(); dprintln();
    clear_keyboard_but_mods(); // To avoid stuck keys

    // find highest set bit and set LED color appropriately
    uint8_t active_layer = 32 - __builtin_clzl(layer_state | default_layer_state) - 1;

    on_layer_change(active_layer);
}
예제 #15
0
int main() {
  volatile long a = 0x0000000000000001L;
  if (__builtin_clzl(a) != sizeof(long long) * 8 - 1) {
    return 1;
  }
  volatile long b = 0x000000006000beefL;
  if (__builtin_clzl(b) != sizeof(long long) * 8 - 31) {
    return 1;
  }
  volatile long c = 0x000000008abc0000L;
  if (__builtin_clzl(c) != sizeof(long long) * 8 - 32) {
    return 1;
  }
  volatile long d = 0x6000beef00000000L;
  if (__builtin_clzl(d) != sizeof(long long) * 8 - 63) {
    return 1;
  }
  volatile long e = 0x8abc000000000000L;
  if (__builtin_clzl(e) != sizeof(long long) * 8 - 64) {
    return 1;
  }
  return 0;
}
예제 #16
0
int log2_u64(uint64_t v) {
    #if USE_BUILTINS
        if (v == 0) {
            return 0;
        } else {
            return 63 - __builtin_clzl(v);
        }
    #else
        uint32_t top = v >> 32;
        if (top == 0) {
            return log2_u32(v);
        } else {
            return 32 + log2_u32(top);
        }
    #endif
}
예제 #17
0
        // 按 bit 数前面 0 的个数
        int Clz(size_t x)
        {
#ifdef _MSC_VER
            unsigned long r = 0;
# ifdef XXLIB_64BIT
            _BitScanReverse64(&r, x);
            return 63 - r;
# else
            _BitScanReverse(&r, x);
            return 31 - r;
# endif
#else
# ifdef XXLIB_64BIT
            return __builtin_clzl(x);
# else
            return __builtin_clz(x);
# endif
#endif
        }
예제 #18
0
PascalHashTable*
PHNew(OPHeap* heap, uint64_t num_objects, double load,
      size_t key_inline_size, size_t valsize)
{
  PascalHashTable* table;
  uint64_t capacity;
  uint32_t capacity_clz, capacity_ms4b, capacity_msb;
  size_t bucket_size;
  void* bucket_ptr;

  op_assert(load > 0.0 && load < 1.0,
            "load %lf must within close interval (0.0, 1.0)\n", load);
  capacity = (uint64_t)(num_objects / load);
  if (capacity < 8)
    capacity = 8;
  capacity_clz = __builtin_clzl(capacity);
  capacity_msb = 64 - capacity_clz;
  capacity_ms4b = round_up_div(capacity, 1UL << (capacity_msb - 4));
  capacity = (uint64_t)capacity_ms4b << (capacity_msb - 4);

  bucket_size = sizeof(oplenref_t) + key_inline_size + valsize;

  table = OPCalloc(heap, 1, sizeof(PascalHashTable));
  if (!table)
    return NULL;
  bucket_ptr = OPCalloc(heap, 1, bucket_size * capacity);
  if (!bucket_ptr)
    {
      OPDealloc(table);
      return NULL;
    }
  table->bucket_ref = OPPtr2Ref(bucket_ptr);
  table->large_data_threshold = DEFAULT_LARGE_DATA_THRESHOLD;
  table->capacity_clz = capacity_clz;
  table->capacity_ms4b = capacity_ms4b;
  table->objcnt_high = (uint64_t)(capacity * load);
  table->objcnt_low = capacity * 2 / 10;
  table->key_inline_size = key_inline_size;
  table->valsize = valsize;
  return table;
}
예제 #19
0
/*
 * Given an element size, compute its freelist index.
 * We free an element into the freelist containing similarly-sized elements.
 * We try to allocate elements starting with the freelist containing
 * similarly-sized elements, and if necessary, we search freelists
 * containing larger elements.
 *
 * Example element size ranges for a heap with five free lists:
 *   heap->free_head[0] - (0   , 2^8]
 *   heap->free_head[1] - (2^8 , 2^10]
 *   heap->free_head[2] - (2^10 ,2^12]
 *   heap->free_head[3] - (2^12, 2^14]
 *   heap->free_head[4] - (2^14, MAX_SIZE]
 */
size_t
malloc_elem_free_list_index(size_t size)
{
#define MALLOC_MINSIZE_LOG2   8
#define MALLOC_LOG2_INCREMENT 2

	size_t log2;
	size_t index;

	if (size <= (1UL << MALLOC_MINSIZE_LOG2))
		return 0;

	/* Find next power of 2 >= size. */
	log2 = sizeof(size) * 8 - __builtin_clzl(size-1);

	/* Compute freelist index, based on log2(size). */
	index = (log2 - MALLOC_MINSIZE_LOG2 + MALLOC_LOG2_INCREMENT - 1) /
	        MALLOC_LOG2_INCREMENT;

	return (index <= RTE_HEAP_NUM_FREELISTS-1?
	        index: RTE_HEAP_NUM_FREELISTS-1);
}
예제 #20
0
파일: bt.c 프로젝트: RobertDash/pspp
/* Returns the number of high-order 0-bits in X.
   Undefined if X is zero. */
static inline int
count_leading_zeros (size_t x)
{
#if __GNUC__ >= 4
#if SIZE_MAX > ULONG_MAX
  return __builtin_clzll (x);
#elif SIZE_MAX > UINT_MAX
  return __builtin_clzl (x);
#else
  return __builtin_clz (x);
#endif
#else
  /* This algorithm is from _Hacker's Delight_ section 5.3. */
  size_t y;
  int n;

#define COUNT_STEP(BITS)                        \
        y = x >> BITS;                          \
        if (y != 0)                             \
          {                                     \
            n -= BITS;                          \
            x = y;                              \
          }

  n = sizeof (size_t) * CHAR_BIT;
#if SIZE_MAX >> 31 >> 31 >> 2
  COUNT_STEP (64);
#endif
#if SIZE_MAX >> 31 >> 1
  COUNT_STEP (32);
#endif
  COUNT_STEP (16);
  COUNT_STEP (8);
  COUNT_STEP (4);
  COUNT_STEP (2);
  y = x >> 1;
  return y != 0 ? n - 2 : n - x;
#endif
}
예제 #21
0
파일: tbl.c 프로젝트: GabiTarsa/c-libutl
/*
** Integer log base 2 of a 32 bits integer values.
**   llog2(0) == llog2(1) == 0
*/
static unsigned short llog2(unsigned long x)
{
  long l = 0;

  x &= 0xFFFFFFFF;
  
  if (x==0) return 0;
  
  #ifndef UTL_NOASM
    #if defined(__POCC__) || defined(_MSC_VER) || defined (__WATCOMC__)
        /* Pelles C            MS Visual C++         OpenWatcom*/
      __asm { mov eax, [x]
              bsr ecx, eax
              mov  l, ecx
      }
    #elif defined(__GNUC__)
      l = (unsigned short) ((sizeof(long)*8 -1) - __builtin_clzl(x));
    #else
      #define UTL_NOASM
    #endif  
  #endif
  
  #ifdef UTL_NOASM  /* Make a binary search.*/
    if (x & 0xFFFF0000) {l += 16; x >>= 16;} /* 11111111111111110000000000000000 */
예제 #22
0
파일: lzd.c 프로젝트: 0day-ci/gcc
long test_clzl(long a)
{
  return __builtin_clzl(a);
}
예제 #23
0
파일: tty.c 프로젝트: hghazal/node
static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt,
    DWORD* error) {
  /* We can only write 8k characters at a time. Windows can't handle */
  /* much more characters in a single console write anyway. */
  WCHAR utf16_buf[8192];
  DWORD utf16_buf_used = 0;
  int i;

#define FLUSH_TEXT()                                                \
  do {                                                              \
    if (utf16_buf_used > 0) {                                       \
      uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error);   \
      utf16_buf_used = 0;                                           \
    }                                                               \
  } while (0)

  /* Cache for fast access */
  unsigned char utf8_bytes_left = handle->utf8_bytes_left;
  unsigned int utf8_codepoint = handle->utf8_codepoint;
  unsigned char previous_eol = handle->previous_eol;
  unsigned char ansi_parser_state = handle->ansi_parser_state;

  /* Store the error here. If we encounter an error, stop trying to do i/o */
  /* but keep parsing the buffer so we leave the parser in a consistent */
  /* state. */
  *error = ERROR_SUCCESS;

  EnterCriticalSection(&uv_tty_output_lock);

  for (i = 0; i < bufcnt; i++) {
    uv_buf_t buf = bufs[i];
    unsigned int j;

    for (j = 0; j < buf.len; j++) {
      unsigned char c = buf.base[j];

      /* Run the character through the utf8 decoder We happily accept non */
      /* shortest form encodings and invalid code points - there's no real */
      /* harm that can be done. */
      if (utf8_bytes_left == 0) {
        /* Read utf-8 start byte */
        DWORD first_zero_bit;
        unsigned char not_c = ~c;
#ifdef _MSC_VER /* msvc */
        if (_BitScanReverse(&first_zero_bit, not_c)) {
#else /* assume gcc */
        if (first_zero_bit = __builtin_clzl(not_c), c != 0) {
#endif
          if (first_zero_bit == 7) {
            /* Ascii - pass right through */
            utf8_codepoint = (unsigned int) c;

          } else if (first_zero_bit <= 5) {
            /* Multibyte sequence */
            utf8_codepoint = (0xff >> (8 - first_zero_bit)) & c;
            utf8_bytes_left = (char) (6 - first_zero_bit);

          } else {
            /* Invalid continuation */
            utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
          }

        } else {
          /* 0xff -- invalid */
          utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
        }

      } else if ((c & 0xc0) == 0x80) {
예제 #24
0
static inline unsigned int log2_floor(unsigned long a) {
    return 63-__builtin_clzl(a);
}
예제 #25
0
char isnormal_negzero[!__builtin_isnormal(-0.0) ? 1 : -1];
char isnormal_neg    [__builtin_isnormal(-1.0) ? 1 : -1];
char isnormal_inf_neg[!__builtin_isnormal(-__builtin_inf()) ? 1 : -1];
char isnormal_nan    [!__builtin_isnormal(__builtin_nan("")) ? 1 : -1];
char isnormal_snan   [!__builtin_isnormal(__builtin_nans("")) ? 1 : -1];

//double       g19 = __builtin_powi(2.0, 4);
//float        g20 = __builtin_powif(2.0f, 4);
//long double  g21 = __builtin_powil(2.0L, 4);

#define BITSIZE(x) (sizeof(x) * 8)
char clz1[__builtin_clz(1) == BITSIZE(int) - 1 ? 1 : -1];
char clz2[__builtin_clz(7) == BITSIZE(int) - 3 ? 1 : -1];
char clz3[__builtin_clz(1 << (BITSIZE(int) - 1)) == 0 ? 1 : -1];
int clz4 = __builtin_clz(0); // expected-error {{not a compile-time constant}}
char clz5[__builtin_clzl(0xFL) == BITSIZE(long) - 4 ? 1 : -1];
char clz6[__builtin_clzll(0xFFLL) == BITSIZE(long long) - 8 ? 1 : -1];
char clz7[__builtin_clzs(0x1) == BITSIZE(short) - 1 ? 1 : -1];
char clz8[__builtin_clzs(0xf) == BITSIZE(short) - 4 ? 1 : -1];
char clz9[__builtin_clzs(0xfff) == BITSIZE(short) - 12 ? 1 : -1];

char ctz1[__builtin_ctz(1) == 0 ? 1 : -1];
char ctz2[__builtin_ctz(8) == 3 ? 1 : -1];
char ctz3[__builtin_ctz(1 << (BITSIZE(int) - 1)) == BITSIZE(int) - 1 ? 1 : -1];
int ctz4 = __builtin_ctz(0); // expected-error {{not a compile-time constant}}
char ctz5[__builtin_ctzl(0x10L) == 4 ? 1 : -1];
char ctz6[__builtin_ctzll(0x100LL) == 8 ? 1 : -1];
char ctz7[__builtin_ctzs(1 << (BITSIZE(short) - 1)) == BITSIZE(short) - 1 ? 1 : -1];

char popcount1[__builtin_popcount(0) == 0 ? 1 : -1];
char popcount2[__builtin_popcount(0xF0F0) == 8 ? 1 : -1];
예제 #26
0
inline unsigned int count_leading_zeros_impl(
		unsigned long int n, std::size_t w) {
	return static_cast<unsigned int>(__builtin_clzl(n))
		- static_cast<unsigned int>(
			bit_width<unsigned long int>() - w);
}
예제 #27
0
파일: alloc.c 프로젝트: descent/osdev
/*
 * Given a size value, find the correct bin
 * to place the requested allocation in.
 */
static size_t __attribute__ ((always_inline, pure)) klmalloc_bin_size(size_t size) {
	size_t bin = sizeof(size) * CHAR_BIT - __builtin_clzl(size);
	bin += !!(size & (size - 1));
	return klmalloc_adjust_bin(bin);
}
예제 #28
0
static int __attribute__((noinline)) clzl(unsigned long x)
{
	return __builtin_clzl(x);
}
inline int leading_zero_count<unsigned long>(unsigned long word) {  // NOLINT(runtime/int)
  return __builtin_clzl(word);
}
예제 #30
0
// Count leading zeroes
inline uintptr_t clz(uintptr_t n){
  return __builtin_clzl(n);
}