#ifndef __TLSF_BITS_H__
#define __TLSF_BITS_H__

//
// Architecture-specific bit manipulation routines.
//
// TLSF achieves O(1) cost for malloc and free operations by limiting
// the search for a free block to a free list of guaranteed size
// adequate to fulfill the request, combined with efficient free list
// queries using bitmasks and architecture-specific bit-manipulation
// routines.
//
// Most modern processors provide instructions to count leading zeroes
// in a word, find the lowest and highest set bit, etc. These
// specific implementations will be used when available, falling back
// to a reasonably efficient generic implementation.
//
// NOTE: TLSF spec relies on ffs/fls returning value 0..31.
//   ffs/fls return 1-32 by default, returning 0 for error.
//

#if 0
inline int tlsf_ffs(unsigned int word)
{
	const unsigned int reverse = word & (~word + 1);
	const int bit = 32 - __clz(reverse);
	return bit - 1;
}

inline int tlsf_fls(unsigned int word)
{
	const int bit = word ? 32 - __clz(word) : 0;
	return bit - 1;
}

#else
/* Fall back to generic implementation. */

inline int tlsf_fls_generic(unsigned int word)
{
	int bit = 32;

	if (!word) bit -= 1;
	if (!(word & 0xffff0000)) { word <<= 16; bit -= 16; }
	if (!(word & 0xff000000)) { word <<= 8; bit -= 8; }
	if (!(word & 0xf0000000)) { word <<= 4; bit -= 4; }
	if (!(word & 0xc0000000)) { word <<= 2; bit -= 2; }
	if (!(word & 0x80000000)) { word <<= 1; bit -= 1; }

	return bit;
}

/* Implement ffs in terms of fls. */
inline int tlsf_ffs(unsigned int word)
{
	return tlsf_fls_generic(word & (~word + 1)) - 1;
}

inline int tlsf_fls(unsigned int word)
{
	return tlsf_fls_generic(word) - 1;
}
#endif

#define tlsf_fls_sizet tlsf_fls

#endif