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

Directory: arch/alpha/include/asm
/* SPDX-License-Identifier: GPL-2.0 */
#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
Linus Torvalds (pre-git) 39 95.12% 4 80.00%
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
Linus Torvalds (pre-git) 42 93.33% 2 50.00%
Linus Torvalds 3 6.67% 2 50.00%
Total 45 100.00% 4 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
Linus Torvalds (pre-git) 38 92.68% 3 60.00%
Linus Torvalds 2 4.88% 1 20.00%
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
Nicholas 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 43 89.58% 1 50.00%
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
Nicholas Piggin 23 88.46% 1 33.33%
Linus Torvalds 2 7.69% 1 33.33%
Linus Torvalds (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
Linus Torvalds (pre-git) 38 92.68% 3 75.00%
Nicholas 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 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
Linus Torvalds (pre-git) 54 84.38% 7 77.78%
Nicholas Piggin 8 12.50% 1 11.11%
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
Nicholas 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
Linus Torvalds (pre-git) 66 97.06% 4 80.00%
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
Linus Torvalds (pre-git) 54 84.38% 7 77.78%
Nicholas Piggin 8 12.50% 1 11.11%
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
Linus Torvalds (pre-git) 67 97.10% 4 80.00%
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 39 60.94% 1 33.33%
Richard Henderson 17 26.56% 1 33.33%
Nicholas 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
Linus Torvalds (pre-git) 38 55.88% 5 71.43%
Richard Henderson 29 42.65% 1 14.29%
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
Linus Torvalds (pre-git) 42 93.33% 6 75.00%
Linus Torvalds 2 4.44% 1 12.50%
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
Linus Torvalds (pre-git) 40 50.63% 3 60.00%
Richard Henderson 38 48.10% 1 20.00%
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
Linus Torvalds (pre-git) 56 67.47% 6 60.00%
Richard Henderson 24 28.92% 2 20.00%
Akinobu Mita 2 2.41% 1 10.00%
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 78 95.12% 3 60.00%
Akinobu Mita 2 2.44% 1 20.00%
Ivan Kokshaysky 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
Linus Torvalds (pre-git) 23 85.19% 1 25.00%
Richard Henderson 3 11.11% 2 50.00%
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 12 63.16% 1 33.33%
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 49 76.56% 2 50.00%
Linus Torvalds 14 21.88% 1 25.00%
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 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 10 50.00% 1 50.00%
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
Linus Torvalds (pre-git) 11 61.11% 1 25.00%
Richard Henderson 4 22.22% 1 25.00%
Linus Torvalds 2 11.11% 1 25.00%
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 14 77.78% 1 25.00%
Linus Torvalds (pre-git) 2 11.11% 1 25.00%
Peter Zijlstra 1 5.56% 1 25.00%
Matt Turner 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 16 80.00% 1 33.33%
Peter Zijlstra 2 10.00% 1 33.33%
Linus Torvalds (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 16 80.00% 1 33.33%
Peter Zijlstra 2 10.00% 1 33.33%
Linus Torvalds (pre-git) 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 52 76.47% 1 50.00%
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
Linus Torvalds (pre-git) 659 45.29% 18 43.90%
Richard Henderson 424 29.14% 5 12.20%
Nicholas Piggin 136 9.35% 2 4.88%
Linus Torvalds 132 9.07% 2 4.88%
Ivan Kokshaysky 27 1.86% 3 7.32%
Alexander van Heukelum 20 1.37% 1 2.44%
Akinobu Mita 19 1.31% 4 9.76%
Matt Turner 18 1.24% 2 4.88%
Peter Zijlstra 10 0.69% 1 2.44%
Jiri Slaby 8 0.55% 1 2.44%
Greg Kroah-Hartman 1 0.07% 1 2.44%
Al Viro 1 0.07% 1 2.44%
Total 1455 100.00% 41 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.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Linus Torvalds (pre-git)	39	95.12%	4	80.00%
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.14 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
