[linux.git] / lib / find_next_bit.c

/* find_next_bit.c: fallback find next bit implementation
 *
 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/bitops.h>
#include <linux/module.h>
#include <asm/types.h>
#include <asm/byteorder.h>

#define BITOP_WORD(nr)		((nr) / BITS_PER_LONG)

#ifdef CONFIG_GENERIC_FIND_NEXT_BIT
/*
 * Find the next set bit in a memory region.
 */
unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
			    unsigned long offset)
{
	const unsigned long *p = addr + BITOP_WORD(offset);
	unsigned long result = offset & ~(BITS_PER_LONG-1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	size -= result;
	offset %= BITS_PER_LONG;
	if (offset) {
		tmp = *(p++);
		tmp &= (~0UL << offset);
		if (size < BITS_PER_LONG)
			goto found_first;
		if (tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}
	while (size & ~(BITS_PER_LONG-1)) {
		if ((tmp = *(p++)))
			goto found_middle;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = *p;

found_first:
	tmp &= (~0UL >> (BITS_PER_LONG - size));
	if (tmp == 0UL)		/* Are any bits set? */
		return result + size;	/* Nope. */
found_middle:
	return result + __ffs(tmp);
}
EXPORT_SYMBOL(find_next_bit);

/*
 * This implementation of find_{first,next}_zero_bit was stolen from
 * Linus' asm-alpha/bitops.h.
 */
unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
				 unsigned long offset)
{
	const unsigned long *p = addr + BITOP_WORD(offset);
	unsigned long result = offset & ~(BITS_PER_LONG-1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	size -= result;
	offset %= BITS_PER_LONG;
	if (offset) {
		tmp = *(p++);
		tmp |= ~0UL >> (BITS_PER_LONG - offset);
		if (size < BITS_PER_LONG)
			goto found_first;
		if (~tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}
	while (size & ~(BITS_PER_LONG-1)) {
		if (~(tmp = *(p++)))
			goto found_middle;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = *p;

found_first:
	tmp |= ~0UL << size;
	if (tmp == ~0UL)	/* Are any bits zero? */
		return result + size;	/* Nope. */
found_middle:
	return result + ffz(tmp);
}
EXPORT_SYMBOL(find_next_zero_bit);
#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */

#ifdef CONFIG_GENERIC_FIND_FIRST_BIT
/*
 * Find the first set bit in a memory region.
 */
unsigned long find_first_bit(const unsigned long *addr, unsigned long size)
{
	const unsigned long *p = addr;
	unsigned long result = 0;
	unsigned long tmp;

	while (size & ~(BITS_PER_LONG-1)) {
		if ((tmp = *(p++)))
			goto found;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;

	tmp = (*p) & (~0UL >> (BITS_PER_LONG - size));
	if (tmp == 0UL)		/* Are any bits set? */
		return result + size;	/* Nope. */
found:
	return result + __ffs(tmp);
}
EXPORT_SYMBOL(find_first_bit);

/*
 * Find the first cleared bit in a memory region.
 */
unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
{
	const unsigned long *p = addr;
	unsigned long result = 0;
	unsigned long tmp;

	while (size & ~(BITS_PER_LONG-1)) {
		if (~(tmp = *(p++)))
			goto found;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;

	tmp = (*p) | (~0UL << size);
	if (tmp == ~0UL)	/* Are any bits zero? */
		return result + size;	/* Nope. */
found:
	return result + ffz(tmp);
}
EXPORT_SYMBOL(find_first_zero_bit);
#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */

#ifdef __BIG_ENDIAN

/* include/linux/byteorder does not support "unsigned long" type */
static inline unsigned long ext2_swabp(const unsigned long * x)
{
#if BITS_PER_LONG == 64
	return (unsigned long) __swab64p((u64 *) x);
#elif BITS_PER_LONG == 32
	return (unsigned long) __swab32p((u32 *) x);
#else
#error BITS_PER_LONG not defined
#endif
}

/* include/linux/byteorder doesn't support "unsigned long" type */
static inline unsigned long ext2_swab(const unsigned long y)
{
#if BITS_PER_LONG == 64
	return (unsigned long) __swab64((u64) y);
#elif BITS_PER_LONG == 32
	return (unsigned long) __swab32((u32) y);
#else
#error BITS_PER_LONG not defined
#endif
}

unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned
		long size, unsigned long offset)
{
	const unsigned long *p = addr + BITOP_WORD(offset);
	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	size -= result;
	offset &= (BITS_PER_LONG - 1UL);
	if (offset) {
		tmp = ext2_swabp(p++);
		tmp |= (~0UL >> (BITS_PER_LONG - offset));
		if (size < BITS_PER_LONG)
			goto found_first;
		if (~tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}

	while (size & ~(BITS_PER_LONG - 1)) {
		if (~(tmp = *(p++)))
			goto found_middle_swap;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = ext2_swabp(p);
found_first:
	tmp |= ~0UL << size;
	if (tmp == ~0UL)	/* Are any bits zero? */
		return result + size; /* Nope. Skip ffz */
found_middle:
	return result + ffz(tmp);

found_middle_swap:
	return result + ffz(ext2_swab(tmp));
}

EXPORT_SYMBOL(generic_find_next_zero_le_bit);

unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned
		long size, unsigned long offset)
{
	const unsigned long *p = addr + BITOP_WORD(offset);
	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	size -= result;
	offset &= (BITS_PER_LONG - 1UL);
	if (offset) {
		tmp = ext2_swabp(p++);
		tmp &= (~0UL << offset);
		if (size < BITS_PER_LONG)
			goto found_first;
		if (tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}

	while (size & ~(BITS_PER_LONG - 1)) {
		tmp = *(p++);
		if (tmp)
			goto found_middle_swap;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = ext2_swabp(p);
found_first:
	tmp &= (~0UL >> (BITS_PER_LONG - size));
	if (tmp == 0UL)		/* Are any bits set? */
		return result + size; /* Nope. */
found_middle:
	return result + __ffs(tmp);

found_middle_swap:
	return result + __ffs(ext2_swab(tmp));
}
EXPORT_SYMBOL(generic_find_next_le_bit);
#endif /* __BIG_ENDIAN */
Commit	Line	Data
1da177e4 LT	1	/* find_next_bit.c: fallback find next bit implementation
	2	*
	3	* Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells ([email protected])
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/bitops.h>
40234401	13	#include <linux/module.h>
c7f612cd	14	#include <asm/types.h>
930ae745	15	#include <asm/byteorder.h>
1da177e4	16
c7f612cd AM	17	#define BITOP_WORD(nr) ((nr) / BITS_PER_LONG)
c7f612cd AM	18
77b9bd9c	19	#ifdef CONFIG_GENERIC_FIND_NEXT_BIT
64970b68 AH	20	/*
64970b68 AH	21	* Find the next set bit in a memory region.
c7f612cd	22	*/
fee4b19f TG	23	unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
fee4b19f TG	24	unsigned long offset)
1da177e4	25	{
c7f612cd AM	26	const unsigned long *p = addr + BITOP_WORD(offset);
c7f612cd AM	27	unsigned long result = offset & ~(BITS_PER_LONG-1);
1da177e4 LT	28	unsigned long tmp;
1da177e4 LT	29
c7f612cd AM	30	if (offset >= size)
	31	return size;
	32	size -= result;
	33	offset %= BITS_PER_LONG;
1da177e4	34	if (offset) {
c7f612cd AM	35	tmp = *(p++);
	36	tmp &= (~0UL << offset);
	37	if (size < BITS_PER_LONG)
	38	goto found_first;
	39	if (tmp)
	40	goto found_middle;
	41	size -= BITS_PER_LONG;
	42	result += BITS_PER_LONG;
	43	}
	44	while (size & ~(BITS_PER_LONG-1)) {
	45	if ((tmp = *(p++)))
	46	goto found_middle;
	47	result += BITS_PER_LONG;
	48	size -= BITS_PER_LONG;
1da177e4	49	}
c7f612cd AM	50	if (!size)
	51	return result;
	52	tmp = *p;
1da177e4	53
c7f612cd AM	54	found_first:
	55	tmp &= (~0UL >> (BITS_PER_LONG - size));
	56	if (tmp == 0UL) /* Are any bits set? */
	57	return result + size; /* Nope. */
	58	found_middle:
	59	return result + __ffs(tmp);
	60	}
fee4b19f	61	EXPORT_SYMBOL(find_next_bit);
1da177e4	62
c7f612cd AM	63	/*
	64	* This implementation of find_{first,next}_zero_bit was stolen from
	65	* Linus' asm-alpha/bitops.h.
	66	*/
fee4b19f TG	67	unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
fee4b19f TG	68	unsigned long offset)
c7f612cd AM	69	{
	70	const unsigned long *p = addr + BITOP_WORD(offset);
	71	unsigned long result = offset & ~(BITS_PER_LONG-1);
	72	unsigned long tmp;
1da177e4	73
c7f612cd AM	74	if (offset >= size)
	75	return size;
	76	size -= result;
	77	offset %= BITS_PER_LONG;
	78	if (offset) {
	79	tmp = *(p++);
	80	tmp \|= ~0UL >> (BITS_PER_LONG - offset);
	81	if (size < BITS_PER_LONG)
	82	goto found_first;
	83	if (~tmp)
	84	goto found_middle;
	85	size -= BITS_PER_LONG;
	86	result += BITS_PER_LONG;
	87	}
	88	while (size & ~(BITS_PER_LONG-1)) {
	89	if (~(tmp = *(p++)))
	90	goto found_middle;
	91	result += BITS_PER_LONG;
	92	size -= BITS_PER_LONG;
1da177e4	93	}
c7f612cd AM	94	if (!size)
	95	return result;
	96	tmp = *p;
1da177e4	97
c7f612cd AM	98	found_first:
	99	tmp \|= ~0UL << size;
	100	if (tmp == ~0UL) /* Are any bits zero? */
	101	return result + size; /* Nope. */
	102	found_middle:
	103	return result + ffz(tmp);
1da177e4	104	}
fee4b19f	105	EXPORT_SYMBOL(find_next_zero_bit);
77b9bd9c AH	106	#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */
	107
	108	#ifdef CONFIG_GENERIC_FIND_FIRST_BIT
	109	/*
	110	* Find the first set bit in a memory region.
	111	*/
fee4b19f	112	unsigned long find_first_bit(const unsigned long *addr, unsigned long size)
77b9bd9c AH	113	{
	114	const unsigned long *p = addr;
	115	unsigned long result = 0;
	116	unsigned long tmp;
	117
	118	while (size & ~(BITS_PER_LONG-1)) {
	119	if ((tmp = *(p++)))
	120	goto found;
	121	result += BITS_PER_LONG;
	122	size -= BITS_PER_LONG;
	123	}
	124	if (!size)
	125	return result;
	126
	127	tmp = (*p) & (~0UL >> (BITS_PER_LONG - size));
	128	if (tmp == 0UL) /* Are any bits set? */
	129	return result + size; /* Nope. */
	130	found:
	131	return result + __ffs(tmp);
	132	}
fee4b19f	133	EXPORT_SYMBOL(find_first_bit);
77b9bd9c AH	134
	135	/*
	136	* Find the first cleared bit in a memory region.
	137	*/
fee4b19f	138	unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
77b9bd9c AH	139	{
	140	const unsigned long *p = addr;
	141	unsigned long result = 0;
	142	unsigned long tmp;
	143
	144	while (size & ~(BITS_PER_LONG-1)) {
	145	if (~(tmp = *(p++)))
	146	goto found;
	147	result += BITS_PER_LONG;
	148	size -= BITS_PER_LONG;
	149	}
	150	if (!size)
	151	return result;
	152
	153	tmp = (*p) \| (~0UL << size);
	154	if (tmp == ~0UL) /* Are any bits zero? */
	155	return result + size; /* Nope. */
	156	found:
	157	return result + ffz(tmp);
	158	}
fee4b19f	159	EXPORT_SYMBOL(find_first_zero_bit);
77b9bd9c	160	#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
930ae745 AM	161
	162	#ifdef __BIG_ENDIAN
	163
	164	/* include/linux/byteorder does not support "unsigned long" type */
	165	static inline unsigned long ext2_swabp(const unsigned long * x)
	166	{
	167	#if BITS_PER_LONG == 64
	168	return (unsigned long) __swab64p((u64 *) x);
	169	#elif BITS_PER_LONG == 32
	170	return (unsigned long) __swab32p((u32 *) x);
	171	#else
	172	#error BITS_PER_LONG not defined
	173	#endif
	174	}
	175
	176	/* include/linux/byteorder doesn't support "unsigned long" type */
	177	static inline unsigned long ext2_swab(const unsigned long y)
	178	{
	179	#if BITS_PER_LONG == 64
	180	return (unsigned long) __swab64((u64) y);
	181	#elif BITS_PER_LONG == 32
	182	return (unsigned long) __swab32((u32) y);
	183	#else
	184	#error BITS_PER_LONG not defined
	185	#endif
	186	}
	187
	188	unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned
	189	long size, unsigned long offset)
	190	{
	191	const unsigned long *p = addr + BITOP_WORD(offset);
	192	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	193	unsigned long tmp;
	194
	195	if (offset >= size)
	196	return size;
	197	size -= result;
	198	offset &= (BITS_PER_LONG - 1UL);
	199	if (offset) {
	200	tmp = ext2_swabp(p++);
	201	tmp \|= (~0UL >> (BITS_PER_LONG - offset));
	202	if (size < BITS_PER_LONG)
	203	goto found_first;
	204	if (~tmp)
	205	goto found_middle;
	206	size -= BITS_PER_LONG;
	207	result += BITS_PER_LONG;
	208	}
	209
	210	while (size & ~(BITS_PER_LONG - 1)) {
	211	if (~(tmp = *(p++)))
	212	goto found_middle_swap;
	213	result += BITS_PER_LONG;
	214	size -= BITS_PER_LONG;
	215	}
	216	if (!size)
	217	return result;
	218	tmp = ext2_swabp(p);
	219	found_first:
	220	tmp \|= ~0UL << size;
	221	if (tmp == ~0UL) /* Are any bits zero? */
	222	return result + size; /* Nope. Skip ffz */
	223	found_middle:
	224	return result + ffz(tmp);
225
226	found_middle_swap:
227	return result + ffz(ext2_swab(tmp));
228	}
229
230	EXPORT_SYMBOL(generic_find_next_zero_le_bit);
231
aa02ad67 AK	232	unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned
	233	long size, unsigned long offset)
	234	{
	235	const unsigned long *p = addr + BITOP_WORD(offset);
	236	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	237	unsigned long tmp;
	238
	239	if (offset >= size)
	240	return size;
	241	size -= result;
	242	offset &= (BITS_PER_LONG - 1UL);
	243	if (offset) {
	244	tmp = ext2_swabp(p++);
	245	tmp &= (~0UL << offset);
	246	if (size < BITS_PER_LONG)
	247	goto found_first;
	248	if (tmp)
	249	goto found_middle;
	250	size -= BITS_PER_LONG;
	251	result += BITS_PER_LONG;
	252	}
	253
	254	while (size & ~(BITS_PER_LONG - 1)) {
	255	tmp = *(p++);
	256	if (tmp)
	257	goto found_middle_swap;
	258	result += BITS_PER_LONG;
	259	size -= BITS_PER_LONG;
	260	}
	261	if (!size)
	262	return result;
	263	tmp = ext2_swabp(p);
	264	found_first:
	265	tmp &= (~0UL >> (BITS_PER_LONG - size));
	266	if (tmp == 0UL) /* Are any bits set? */
	267	return result + size; /* Nope. */
	268	found_middle:
	269	return result + __ffs(tmp);
	270
	271	found_middle_swap:
	272	return result + __ffs(ext2_swab(tmp));
	273	}
	274	EXPORT_SYMBOL(generic_find_next_le_bit);
930ae745	275	#endif /* __BIG_ENDIAN */