Release 4.10 arch/alpha/include/asm/bitops.h

Directory: arch/alpha/include/asm
#ifndef _ALPHA_BITOPS_H

#define _ALPHA_BITOPS_H

#ifndef _LINUX_BITOPS_H
#error only <linux/bitops.h> can be included directly
#endif

#include <asm/compiler.h>
#include <asm/barrier.h>

/*
 * Copyright 1994, Linus Torvalds.
 */

/*
 * These have to be done with inline assembly: that way the bit-setting
 * is guaranteed to be atomic. All bit operations return 0 if the bit
 * was cleared before the operation and != 0 if it was not.
 *
 * To get proper branch prediction for the main line, we must branch
 * forward to code at the end of this object's .text section, then
 * branch back to restart the operation.
 *
 * bit 0 is the LSB of addr; bit 64 is the LSB of (addr+1).
 */


static inline void

set_bit(unsigned long nr, volatile void * addr)
{
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
        "1:     ldl_l %0,%3\n"
        "       bis %0,%2,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,2f\n"
        ".subsection 2\n"
        "2:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m)
        :"Ir" (1UL << (nr & 31)), "m" (*m));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 39 95.12% 4 80.00%
linus torvalds linus torvalds 2 4.88% 1 20.00%
Total 41 100.00% 5 100.00%

/*
 * WARNING: non atomic version.
 */

static inline void

__set_bit(unsigned long nr, volatile void * addr)
{
	int *m = ((int *) addr) + (nr >> 5);

	*m |= 1 << (nr & 31);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 42 93.33% 1 33.33%
linus torvalds linus torvalds 3 6.67% 2 66.67%
Total 45 100.00% 3 100.00%


static inline void

clear_bit(unsigned long nr, volatile void * addr)
{
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
        "1:     ldl_l %0,%3\n"
        "       bic %0,%2,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,2f\n"
        ".subsection 2\n"
        "2:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m)
        :"Ir" (1UL << (nr & 31)), "m" (*m));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 38 92.68% 3 60.00%
linus torvalds linus torvalds 2 4.88% 1 20.00%
richard henderson richard henderson 1 2.44% 1 20.00%
Total 41 100.00% 5 100.00%


static inline void

clear_bit_unlock(unsigned long nr, volatile void * addr)
{
	smp_mb();
	clear_bit(nr, addr);
}

Contributors
Person Tokens Prop Commits CommitProp
nick piggin nick piggin 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%

/*
 * WARNING: non atomic version.
 */

static __inline__ void

__clear_bit(unsigned long nr, volatile void * addr)
{
	int *m = ((int *) addr) + (nr >> 5);

	*m &= ~(1 << (nr & 31));
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 43 89.58% 1 50.00%
richard henderson richard henderson 5 10.42% 1 50.00%
Total 48 100.00% 2 100.00%


static inline void

__clear_bit_unlock(unsigned long nr, volatile void * addr)
{
	smp_mb();
	__clear_bit(nr, addr);
}

Contributors
Person Tokens Prop Commits CommitProp
nick piggin nick piggin 23 88.46% 1 33.33%
linus torvalds linus torvalds 2 7.69% 1 33.33%
pre-git pre-git 1 3.85% 1 33.33%
Total 26 100.00% 3 100.00%


static inline void

change_bit(unsigned long nr, volatile void * addr)
{
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
        "1:     ldl_l %0,%3\n"
        "       xor %0,%2,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,2f\n"
        ".subsection 2\n"
        "2:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m)
        :"Ir" (1UL << (nr & 31)), "m" (*m));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 38 92.68% 3 75.00%
nick piggin nick piggin 3 7.32% 1 25.00%
Total 41 100.00% 4 100.00%

/*
 * WARNING: non atomic version.
 */

static __inline__ void

__change_bit(unsigned long nr, volatile void * addr)
{
	int *m = ((int *) addr) + (nr >> 5);

	*m ^= 1 << (nr & 31);
}

Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%


static inline int

test_and_set_bit(unsigned long nr, volatile void *addr)
{
	unsigned long oldbit;
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	"1:     ldl_l %0,%4\n"
        "       and %0,%3,%2\n"
        "       bne %2,2f\n"
        "       xor %0,%3,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,3f\n"
        "2:\n"
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	".subsection 2\n"
        "3:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
        :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");

	return oldbit != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 54 84.38% 7 77.78%
nick piggin nick piggin 8 12.50% 1 11.11%
linus torvalds linus torvalds 2 3.12% 1 11.11%
Total 64 100.00% 9 100.00%


static inline int

test_and_set_bit_lock(unsigned long nr, volatile void *addr)
{
	unsigned long oldbit;
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
        "1:     ldl_l %0,%4\n"
        "       and %0,%3,%2\n"
        "       bne %2,2f\n"
        "       xor %0,%3,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,3f\n"
        "2:\n"
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	".subsection 2\n"
        "3:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
        :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");

	return oldbit != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
nick piggin nick piggin 57 100.00% 1 100.00%
Total 57 100.00% 1 100.00%

/*
 * WARNING: non atomic version.
 */

static inline int

__test_and_set_bit(unsigned long nr, volatile void * addr)
{
	unsigned long mask = 1 << (nr & 0x1f);
	int *m = ((int *) addr) + (nr >> 5);
	int old = *m;

	*m = old | mask;
	return (old & mask) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 66 97.06% 4 80.00%
linus torvalds linus torvalds 2 2.94% 1 20.00%
Total 68 100.00% 5 100.00%


static inline int

test_and_clear_bit(unsigned long nr, volatile void * addr)
{
	unsigned long oldbit;
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	"1:     ldl_l %0,%4\n"
        "       and %0,%3,%2\n"
        "       beq %2,2f\n"
        "       xor %0,%3,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,3f\n"
        "2:\n"
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	".subsection 2\n"
        "3:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
        :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");

	return oldbit != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 54 84.38% 7 77.78%
nick piggin nick piggin 8 12.50% 1 11.11%
linus torvalds linus torvalds 2 3.12% 1 11.11%
Total 64 100.00% 9 100.00%

/*
 * WARNING: non atomic version.
 */

static inline int

__test_and_clear_bit(unsigned long nr, volatile void * addr)
{
	unsigned long mask = 1 << (nr & 0x1f);
	int *m = ((int *) addr) + (nr >> 5);
	int old = *m;

	*m = old & ~mask;
	return (old & mask) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 67 97.10% 4 80.00%
linus torvalds linus torvalds 2 2.90% 1 20.00%
Total 69 100.00% 5 100.00%


static inline int

test_and_change_bit(unsigned long nr, volatile void * addr)
{
	unsigned long oldbit;
	unsigned long temp;
	int *m = ((int *) addr) + (nr >> 5);

	__asm__ __volatile__(
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	"1:     ldl_l %0,%4\n"
        "       and %0,%3,%2\n"
        "       xor %0,%3,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,3f\n"
#ifdef CONFIG_SMP
	"       mb\n"
#endif
	".subsection 2\n"
        "3:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
        :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");

	return oldbit != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 39 60.94% 1 33.33%
richard henderson richard henderson 17 26.56% 1 33.33%
nick piggin nick piggin 8 12.50% 1 33.33%
Total 64 100.00% 3 100.00%

/*
 * WARNING: non atomic version.
 */

static __inline__ int

__test_and_change_bit(unsigned long nr, volatile void * addr)
{
	unsigned long mask = 1 << (nr & 0x1f);
	int *m = ((int *) addr) + (nr >> 5);
	int old = *m;

	*m = old ^ mask;
	return (old & mask) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 38 55.88% 5 71.43%
richard henderson richard henderson 29 42.65% 1 14.29%
linus torvalds linus torvalds 1 1.47% 1 14.29%
Total 68 100.00% 7 100.00%


static inline int

test_bit(int nr, const volatile void * addr)
{
	return (1UL & (((const int *) addr)[nr >> 5] >> (nr & 31))) != 0UL;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 42 93.33% 6 75.00%
linus torvalds linus torvalds 2 4.44% 1 12.50%
ivan kokshaysky ivan kokshaysky 1 2.22% 1 12.50%
Total 45 100.00% 8 100.00%

/*
 * ffz = Find First Zero in word. Undefined if no zero exists,
 * so code should check against ~0UL first..
 *
 * Do a binary search on the bits.  Due to the nature of large
 * constants on the alpha, it is worthwhile to split the search.
 */


static inline unsigned long ffz_b(unsigned long x)
{
	unsigned long sum, x1, x2, x4;

	x = ~x & -~x;		/* set first 0 bit, clear others */
	x1 = x & 0xAA;
	x2 = x & 0xCC;
	x4 = x & 0xF0;
	sum = x2 ? 2 : 0;
	sum += (x4 != 0) * 4;
	sum += (x1 != 0);

	return sum;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 40 50.63% 3 60.00%
richard henderson richard henderson 38 48.10% 1 20.00%
linus torvalds linus torvalds 1 1.27% 1 20.00%
Total 79 100.00% 5 100.00%



static inline unsigned long ffz(unsigned long word)
{
#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
	/* Whee.  EV67 can calculate it directly.  */
	return __kernel_cttz(~word);
#else
	unsigned long bits, qofs, bofs;

	bits = __kernel_cmpbge(word, ~0UL);
	qofs = ffz_b(bits);
	bits = __kernel_extbl(word, qofs);
	bofs = ffz_b(bits);

	return qofs*8 + bofs;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 56 67.47% 6 60.00%
richard henderson richard henderson 24 28.92% 2 20.00%
akinobu mita akinobu mita 2 2.41% 1 10.00%
linus torvalds linus torvalds 1 1.20% 1 10.00%
Total 83 100.00% 10 100.00%

/*
 * __ffs = Find First set bit in word.  Undefined if no set bit exists.
 */


static inline unsigned long __ffs(unsigned long word)
{
#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
	/* Whee.  EV67 can calculate it directly.  */
	return __kernel_cttz(word);
#else
	unsigned long bits, qofs, bofs;

	bits = __kernel_cmpbge(0, word);
	qofs = ffz_b(bits);
	bits = __kernel_extbl(word, qofs);
	bofs = ffz_b(~bits);

	return qofs*8 + bofs;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 78 95.12% 3 60.00%
ivan kokshaysky ivan kokshaysky 2 2.44% 1 20.00%
akinobu mita akinobu mita 2 2.44% 1 20.00%
Total 82 100.00% 5 100.00%

#ifdef __KERNEL__

/*
 * ffs: find first bit set. This is defined the same way as
 * the libc and compiler builtin ffs routines, therefore
 * differs in spirit from the above __ffs.
 */



static inline int ffs(int word)
{
	int result = __ffs(word) + 1;
	return word ? result : 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 23 85.19% 1 25.00%
richard henderson richard henderson 3 11.11% 2 50.00%
linus torvalds linus torvalds 1 3.70% 1 25.00%
Total 27 100.00% 4 100.00%

/*
 * fls: find last bit set.
 */
#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)


static inline int fls64(unsigned long word)
{
	return 64 - __kernel_ctlz(word);
}
Contributors
Person Tokens Prop Commits CommitProp
ivan kokshaysky ivan kokshaysky 12 63.16% 1 33.33%
richard henderson richard henderson 7 36.84% 2 66.67%
Total 19 100.00% 3 100.00%

#else
extern const unsigned char __flsm1_tab[256];



static inline int fls64(unsigned long x)
{
	unsigned long t, a, r;

	t = __kernel_cmpbge (x, 0x0101010101010101UL);
	a = __flsm1_tab[t];
	t = __kernel_extbl (x, a);
	r = a*8 + __flsm1_tab[t] + (x != 0);

	return r;
}
Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 49 76.56% 2 50.00%
linus torvalds linus torvalds 14 21.88% 1 25.00%
al viro al viro 1 1.56% 1 25.00%
Total 64 100.00% 4 100.00%

#endif



static inline unsigned long __fls(unsigned long x)
{
	return fls64(x) - 1;
}

Contributors
Person Tokens Prop Commits CommitProp
alexander van heukelum alexander van heukelum 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



static inline int fls(int x)
{
	return fls64((unsigned int) x);
}

Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 10 50.00% 1 50.00%
linus torvalds linus torvalds 10 50.00% 1 50.00%
Total 20 100.00% 2 100.00%

/*
 * hweightN: returns the hamming weight (i.e. the number
 * of bits set) of a N-bit word
 */

#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
/* Whee.  EV67 can calculate it directly.  */


static inline unsigned long __arch_hweight64(unsigned long w)
{
	return __kernel_ctpop(w);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 11 61.11% 1 25.00%
richard henderson richard henderson 4 22.22% 1 25.00%
linus torvalds linus torvalds 2 11.11% 1 25.00%
peter zijlstra peter zijlstra 1 5.56% 1 25.00%
Total 18 100.00% 4 100.00%



static inline unsigned int __arch_hweight32(unsigned int w)
{
	return __arch_hweight64(w);
}

Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 14 77.78% 1 25.00%
pre-git pre-git 2 11.11% 1 25.00%
matt turner matt turner 1 5.56% 1 25.00%
peter zijlstra peter zijlstra 1 5.56% 1 25.00%
Total 18 100.00% 4 100.00%



static inline unsigned int __arch_hweight16(unsigned int w)
{
	return __arch_hweight64(w & 0xffff);
}

Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 16 80.00% 1 33.33%
peter zijlstra peter zijlstra 2 10.00% 1 33.33%
pre-git pre-git 2 10.00% 1 33.33%
Total 20 100.00% 3 100.00%



static inline unsigned int __arch_hweight8(unsigned int w)
{
	return __arch_hweight64(w & 0xff);
}
Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 16 80.00% 1 33.33%
pre-git pre-git 2 10.00% 1 33.33%
peter zijlstra peter zijlstra 2 10.00% 1 33.33%
Total 20 100.00% 3 100.00%

#else
#include <asm-generic/bitops/arch_hweight.h>
#endif

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

#endif /* __KERNEL__ */

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

#ifdef __KERNEL__

/*
 * Every architecture must define this function. It's the fastest
 * way of searching a 100-bit bitmap.  It's guaranteed that at least
 * one of the 100 bits is cleared.
 */

static inline unsigned long

sched_find_first_bit(const unsigned long b[2])
{
	unsigned long b0, b1, ofs, tmp;

	b0 = b[0];
	b1 = b[1];
	ofs = (b0 ? 0 : 64);
	tmp = (b0 ? b0 : b1);

	return __ffs(tmp) + ofs;
}

Contributors
Person Tokens Prop Commits CommitProp
richard henderson richard henderson 52 76.47% 1 50.00%
matt turner matt turner 16 23.53% 1 50.00%
Total 68 100.00% 2 100.00%

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

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

#endif /* __KERNEL__ */

#endif /* _ALPHA_BITOPS_H */
Overall Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 659 45.32% 18 45.00%
richard henderson richard henderson 424 29.16% 5 12.50%
nick piggin nick piggin 136 9.35% 2 5.00%
linus torvalds linus torvalds 132 9.08% 2 5.00%
ivan kokshaysky ivan kokshaysky 27 1.86% 3 7.50%
alexander van heukelum alexander van heukelum 20 1.38% 1 2.50%
akinobu mita akinobu mita 19 1.31% 4 10.00%
matt turner matt turner 18 1.24% 2 5.00%
peter zijlstra peter zijlstra 10 0.69% 1 2.50%
jiri slaby jiri slaby 8 0.55% 1 2.50%
al viro al viro 1 0.07% 1 2.50%
Total 1454 100.00% 40 100.00%
Directory: arch/alpha/include/asm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
pre-git	pre-git	39	95.12%	4	80.00%
linus torvalds	linus torvalds	2	4.88%	1	20.00%
	Total	41	100.00%	5	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 arch/alpha/include/asm/bitops.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
