[mirror_ubuntu-jammy-kernel.git] / include / asm-x86 / bitops_64.h

#ifndef _X86_64_BITOPS_H
#define _X86_64_BITOPS_H

/*
 * Copyright 1992, Linus Torvalds.
 */

extern long find_first_zero_bit(const unsigned long *addr, unsigned long size);
extern long find_next_zero_bit(const unsigned long *addr, long size, long offset);
extern long find_first_bit(const unsigned long *addr, unsigned long size);
extern long find_next_bit(const unsigned long *addr, long size, long offset);

/* return index of first bet set in val or max when no bit is set */
static inline long __scanbit(unsigned long val, unsigned long max)
{
	asm("bsfq %1,%0 ; cmovz %2,%0" : "=&r" (val) : "r" (val), "r" (max));
	return val;
}

#define find_first_bit(addr,size) \
((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
  (__scanbit(*(unsigned long *)addr,(size))) : \
  find_first_bit(addr,size)))

#define find_next_bit(addr,size,off) \
((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? 	  \
  ((off) + (__scanbit((*(unsigned long *)addr) >> (off),(size)-(off)))) : \
	find_next_bit(addr,size,off)))

#define find_first_zero_bit(addr,size) \
((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
  (__scanbit(~*(unsigned long *)addr,(size))) : \
  	find_first_zero_bit(addr,size)))
	
#define find_next_zero_bit(addr,size,off) \
((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? 	  \
  ((off)+(__scanbit(~(((*(unsigned long *)addr)) >> (off)),(size)-(off)))) : \
	find_next_zero_bit(addr,size,off)))

static inline void set_bit_string(unsigned long *bitmap, unsigned long i, 
				  int len) 
{ 
	unsigned long end = i + len; 
	while (i < end) {
		__set_bit(i, bitmap); 
		i++;
	}
} 

/**
 * ffz - find first zero in word.
 * @word: The word to search
 *
 * Undefined if no zero exists, so code should check against ~0UL first.
 */
static inline unsigned long ffz(unsigned long word)
{
	__asm__("bsfq %1,%0"
		:"=r" (word)
		:"r" (~word));
	return word;
}

/**
 * __ffs - find first bit in word.
 * @word: The word to search
 *
 * Undefined if no bit exists, so code should check against 0 first.
 */
static inline unsigned long __ffs(unsigned long word)
{
	__asm__("bsfq %1,%0"
		:"=r" (word)
		:"rm" (word));
	return word;
}

/*
 * __fls: find last bit set.
 * @word: The word to search
 *
 * Undefined if no zero exists, so code should check against ~0UL first.
 */
static inline unsigned long __fls(unsigned long word)
{
	__asm__("bsrq %1,%0"
		:"=r" (word)
		:"rm" (word));
	return word;
}

#ifdef __KERNEL__

#include <asm-generic/bitops/sched.h>

/**
 * ffs - find first bit set
 * @x: the word to search
 *
 * This is defined the same way as
 * the libc and compiler builtin ffs routines, therefore
 * differs in spirit from the above ffz (man ffs).
 */
static inline int ffs(int x)
{
	int r;

	__asm__("bsfl %1,%0\n\t"
		"cmovzl %2,%0" 
		: "=r" (r) : "rm" (x), "r" (-1));
	return r+1;
}

/**
 * fls64 - find last bit set in 64 bit word
 * @x: the word to search
 *
 * This is defined the same way as fls.
 */
static inline int fls64(__u64 x)
{
	if (x == 0)
		return 0;
	return __fls(x) + 1;
}

/**
 * fls - find last bit set
 * @x: the word to search
 *
 * This is defined the same way as ffs.
 */
static inline int fls(int x)
{
	int r;

	__asm__("bsrl %1,%0\n\t"
		"cmovzl %2,%0"
		: "=&r" (r) : "rm" (x), "rm" (-1));
	return r+1;
}

#define ARCH_HAS_FAST_MULTIPLIER 1

#include <asm-generic/bitops/hweight.h>

#endif /* __KERNEL__ */

#ifdef __KERNEL__

#include <asm-generic/bitops/ext2-non-atomic.h>

#define ext2_set_bit_atomic(lock,nr,addr) \
	        test_and_set_bit((nr),(unsigned long*)addr)
#define ext2_clear_bit_atomic(lock,nr,addr) \
	        test_and_clear_bit((nr),(unsigned long*)addr)

#include <asm-generic/bitops/minix.h>

#endif /* __KERNEL__ */

#endif /* _X86_64_BITOPS_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _X86_64_BITOPS_H
	2	#define _X86_64_BITOPS_H
	3
	4	/*
	5	* Copyright 1992, Linus Torvalds.
	6	*/
	7
ade8c56c RD	8	extern long find_first_zero_bit(const unsigned long *addr, unsigned long size);
	9	extern long find_next_zero_bit(const unsigned long *addr, long size, long offset);
	10	extern long find_first_bit(const unsigned long *addr, unsigned long size);
	11	extern long find_next_bit(const unsigned long *addr, long size, long offset);
1da177e4 LT	12
1da177e4 LT	13	/* return index of first bet set in val or max when no bit is set */
d2ccc3fd	14	static inline long __scanbit(unsigned long val, unsigned long max)
1da177e4 LT	15	{
	16	asm("bsfq %1,%0 ; cmovz %2,%0" : "=&r" (val) : "r" (val), "r" (max));
	17	return val;
	18	}
	19
	20	#define find_first_bit(addr,size) \
	21	((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
	22	(__scanbit((unsigned long )addr,(size))) : \
	23	find_first_bit(addr,size)))
	24
	25	#define find_next_bit(addr,size,off) \
	26	((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
	27	((off) + (__scanbit(((unsigned long )addr) >> (off),(size)-(off)))) : \
	28	find_next_bit(addr,size,off)))
	29
	30	#define find_first_zero_bit(addr,size) \
	31	((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
	32	(__scanbit(~(unsigned long )addr,(size))) : \
	33	find_first_zero_bit(addr,size)))
	34
	35	#define find_next_zero_bit(addr,size,off) \
	36	((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
	37	((off)+(__scanbit(~((((unsigned long )addr)) >> (off)),(size)-(off)))) : \
	38	find_next_zero_bit(addr,size,off)))
	39
1da177e4 LT	40	static inline void set_bit_string(unsigned long *bitmap, unsigned long i,
	41	int len)
	42	{
	43	unsigned long end = i + len;
	44	while (i < end) {
	45	__set_bit(i, bitmap);
	46	i++;
	47	}
	48	}
	49
1da177e4 LT	50	/**
	51	* ffz - find first zero in word.
	52	* @word: The word to search
	53	*
	54	* Undefined if no zero exists, so code should check against ~0UL first.
	55	*/
ade8c56c	56	static inline unsigned long ffz(unsigned long word)
1da177e4 LT	57	{
	58	__asm__("bsfq %1,%0"
	59	:"=r" (word)
	60	:"r" (~word));
	61	return word;
	62	}
	63
	64	/**
	65	* __ffs - find first bit in word.
	66	* @word: The word to search
	67	*
	68	* Undefined if no bit exists, so code should check against 0 first.
	69	*/
ade8c56c	70	static inline unsigned long __ffs(unsigned long word)
1da177e4 LT	71	{
	72	__asm__("bsfq %1,%0"
	73	:"=r" (word)
	74	:"rm" (word));
	75	return word;
	76	}
	77
90933fc8 SH	78	/*
	79	* __fls: find last bit set.
	80	* @word: The word to search
	81	*
	82	* Undefined if no zero exists, so code should check against ~0UL first.
	83	*/
ade8c56c	84	static inline unsigned long __fls(unsigned long word)
90933fc8 SH	85	{
	86	__asm__("bsrq %1,%0"
	87	:"=r" (word)
	88	:"rm" (word));
	89	return word;
	90	}
	91
1da177e4 LT	92	#ifdef __KERNEL__
1da177e4 LT	93
f33e2fba	94	#include <asm-generic/bitops/sched.h>
1da177e4 LT	95
	96	/**
	97	* ffs - find first bit set
	98	* @x: the word to search
	99	*
	100	* This is defined the same way as
	101	* the libc and compiler builtin ffs routines, therefore
	102	* differs in spirit from the above ffz (man ffs).
	103	*/
ade8c56c	104	static inline int ffs(int x)
1da177e4 LT	105	{
	106	int r;
	107
	108	__asm__("bsfl %1,%0\n\t"
	109	"cmovzl %2,%0"
	110	: "=r" (r) : "rm" (x), "r" (-1));
	111	return r+1;
	112	}
	113
90933fc8 SH	114	/**
	115	* fls64 - find last bit set in 64 bit word
	116	* @x: the word to search
	117	*
	118	* This is defined the same way as fls.
	119	*/
ade8c56c	120	static inline int fls64(__u64 x)
90933fc8 SH	121	{
	122	if (x == 0)
	123	return 0;
	124	return __fls(x) + 1;
	125	}
	126
636dd2b7 SH	127	/**
	128	* fls - find last bit set
	129	* @x: the word to search
	130	*
	131	* This is defined the same way as ffs.
	132	*/
ade8c56c	133	static inline int fls(int x)
636dd2b7 SH	134	{
	135	int r;
	136
	137	__asm__("bsrl %1,%0\n\t"
	138	"cmovzl %2,%0"
	139	: "=&r" (r) : "rm" (x), "rm" (-1));
	140	return r+1;
	141	}
	142
0136611c AK	143	#define ARCH_HAS_FAST_MULTIPLIER 1
0136611c AK	144
f33e2fba	145	#include <asm-generic/bitops/hweight.h>
1da177e4 LT	146
	147	#endif /* __KERNEL__ */
	148
	149	#ifdef __KERNEL__
	150
f33e2fba AM	151	#include <asm-generic/bitops/ext2-non-atomic.h>
f33e2fba AM	152
1da177e4 LT	153	#define ext2_set_bit_atomic(lock,nr,addr) \
1da177e4 LT	154	test_and_set_bit((nr),(unsigned long*)addr)
1da177e4 LT	155	#define ext2_clear_bit_atomic(lock,nr,addr) \
1da177e4 LT	156	test_and_clear_bit((nr),(unsigned long*)addr)
f33e2fba AM	157
f33e2fba AM	158	#include <asm-generic/bitops/minix.h>
1da177e4	159
1da177e4 LT	160	#endif /* __KERNEL__ */
	161
	162	#endif /* _X86_64_BITOPS_H */