arch/arc/include/asm/bitops.h

137

return x ? BITS_PER_LONG - 1 - __builtin_clzl(x) : 0;

arch/arc/kernel/unwind.c

53

unsigned offs:BITS_PER_LONG / 2;

arch/arc/kernel/unwind.c

54

unsigned width:BITS_PER_LONG / 2;

arch/arm64/kvm/trng.c

36

for (i = 0; i < DIV_ROUND_UP(num_bits, BITS_PER_LONG); i++)

arch/hexagon/include/asm/bitops.h

175

: "r" (addr[BIT_WORD(nr)]), "r" (nr % BITS_PER_LONG)

arch/hexagon/include/asm/bitops.h

190

: "r" (addr[BIT_WORD(nr)]), "r" (nr % BITS_PER_LONG)

arch/hexagon/kernel/smp.c

43

msg = find_next_bit(ops, BITS_PER_LONG, msg+1);

arch/hexagon/kernel/smp.c

66

} while (msg < BITS_PER_LONG);

arch/loongarch/include/asm/bootinfo.h

27

#define NR_WORDS DIV_ROUND_UP(NR_CPUS, BITS_PER_LONG)

arch/loongarch/kernel/paravirt.c

105

(unsigned long)(bitmap >> BITS_PER_LONG), min);

arch/loongarch/kernel/paravirt.c

114

(unsigned long)(bitmap >> BITS_PER_LONG), min);

arch/loongarch/kernel/paravirt.c

66

#define KVM_IPI_CLUSTER_SIZE (2 * BITS_PER_LONG)

arch/loongarch/kvm/exit.c

842

DECLARE_BITMAP(ipi_bitmap, BITS_PER_LONG * 2) = {

arch/loongarch/kvm/exit.c

848

for_each_set_bit(cpu, ipi_bitmap, BITS_PER_LONG * 2) {

arch/loongarch/mm/maccess.c

9

return (unsigned long)unsafe_src >> (BITS_PER_LONG - 1);

arch/m68k/mm/mcfmmu.c

28

unsigned long context_map[LAST_CONTEXT / BITS_PER_LONG + 1];

arch/microblaze/mm/mmu_context.c

29

unsigned long context_map[LAST_CONTEXT / BITS_PER_LONG + 1];

arch/mips/include/asm/bitops.h

120

int bit = nr % BITS_PER_LONG;

arch/mips/include/asm/bitops.h

161

int bit = nr % BITS_PER_LONG;

arch/mips/include/asm/bitops.h

183

int bit = nr % BITS_PER_LONG;

arch/mips/include/asm/bitops.h

227

int bit = nr % BITS_PER_LONG;

arch/mips/include/asm/bitops.h

264

int bit = nr % BITS_PER_LONG;

arch/mips/include/asm/bitops.h

334

if (BITS_PER_LONG == 32 && !__builtin_constant_p(word) &&

arch/mips/include/asm/bitops.h

347

if (BITS_PER_LONG == 64 && !__builtin_constant_p(word) &&

arch/mips/include/asm/bitops.h

360

num = BITS_PER_LONG - 1;

arch/mips/include/asm/bitops.h

362

#if BITS_PER_LONG == 64

arch/mips/include/asm/bitops.h

368

if (!(word & (~0ul << (BITS_PER_LONG-16)))) {

arch/mips/include/asm/bitops.h

372

if (!(word & (~0ul << (BITS_PER_LONG-8)))) {

arch/mips/include/asm/bitops.h

376

if (!(word & (~0ul << (BITS_PER_LONG-4)))) {

arch/mips/include/asm/bitops.h

380

if (!(word & (~0ul << (BITS_PER_LONG-2)))) {

arch/mips/include/asm/bitops.h

384

if (!(word & (~0ul << (BITS_PER_LONG-1))))

arch/mips/include/asm/bitops.h

92

int bit = nr % BITS_PER_LONG;

arch/mips/include/asm/div64.h

14

#if BITS_PER_LONG == 32

arch/mips/include/asm/mipsregs.h

290

#define MIPS_ENTRYLO_XI (_ULCAST_(1) << (BITS_PER_LONG - 2))

arch/mips/include/asm/mipsregs.h

291

#define MIPS_ENTRYLO_RI (_ULCAST_(1) << (BITS_PER_LONG - 1))

arch/mips/kernel/vpe.c

44

#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

arch/mips/kvm/vz.c

1882

if (BITS_PER_LONG == 32) {

arch/mips/kvm/vz.c

1898

if (BITS_PER_LONG == 32) {

arch/mips/lib/bitops.c

112

unsigned int bit = nr % BITS_PER_LONG;

arch/mips/lib/bitops.c

136

unsigned int bit = nr % BITS_PER_LONG;

arch/mips/lib/bitops.c

24

unsigned int bit = nr % BITS_PER_LONG;

arch/mips/lib/bitops.c

45

unsigned int bit = nr % BITS_PER_LONG;

arch/mips/lib/bitops.c

66

unsigned int bit = nr % BITS_PER_LONG;

arch/mips/lib/bitops.c

88

unsigned int bit = nr % BITS_PER_LONG;

arch/mips/mm/maccess.c

9

return (unsigned long)unsafe_src >> (BITS_PER_LONG - 1);

arch/mips/mm/tlbex.c

2518

fillbits = max_t(int, (int)BITS_PER_LONG - pabits, 0);

arch/parisc/include/asm/checksum.h

121

#if BITS_PER_LONG > 32

arch/parisc/include/asm/dma.h

26

#define DMA_CHUNK_SIZE (BITS_PER_LONG*PAGE_SIZE)

arch/parisc/include/asm/hash.h

49

#if BITS_PER_LONG == 64

arch/parisc/include/asm/irq.h

26

#define CPU_IRQ_MAX (CPU_IRQ_BASE + (BITS_PER_LONG - 1))

arch/parisc/include/asm/pgtable.h

123

#if (PGDIR_SHIFT + PAGE_SHIFT + PGD_TABLE_ORDER - BITS_PER_PGD_ENTRY) > BITS_PER_LONG

arch/parisc/include/asm/pgtable.h

124

#define BITS_PER_PGD (BITS_PER_LONG - PGDIR_SHIFT)

arch/parisc/include/asm/pgtable.h

138

#define MAX_ADDRBITS (BITS_PER_LONG)

arch/parisc/kernel/irq.c

349

return (BITS_PER_LONG - bit) + TIMER_IRQ;

arch/parisc/kernel/pci-dma.c

256

mask >>= BITS_PER_LONG - pages_needed;

arch/parisc/kernel/pci-dma.c

312

mask >>= BITS_PER_LONG - pages_mapped;

arch/parisc/kernel/time.c

211

.mask = CLOCKSOURCE_MASK(BITS_PER_LONG),

arch/parisc/kernel/time.c

229

sched_clock_register(read_cr16_sched_clock, BITS_PER_LONG, cr16_clock_freq);

arch/parisc/kernel/time.c

81

unsigned long max_delta = (1UL << (BITS_PER_LONG - 1));

arch/parisc/lib/memset.c

5

#define OPSIZ (BITS_PER_LONG/8)

arch/parisc/mm/init.c

552

> BITS_PER_LONG);

arch/parisc/net/bpf_jit_comp64.c

101

pos &= (BITS_PER_LONG - 1);

arch/parisc/net/bpf_jit_comp64.c

83

pos &= (BITS_PER_LONG - 1);

arch/powerpc/include/asm/bitops.h

46

#define PPC_BITLSHIFT(be) (BITS_PER_LONG - 1 - (be))

arch/powerpc/include/asm/book3s/64/mmu-hash.h

668

#define LOW_SLICE_ARRAY_SZ (BITS_PER_LONG / BITS_PER_BYTE)

arch/powerpc/include/asm/cpu_has_feature.h

19

#define NUM_CPU_FTR_KEYS BITS_PER_LONG

arch/powerpc/include/asm/paca.h

155

unsigned char mm_ctx_low_slices_psize[BITS_PER_LONG / BITS_PER_BYTE];

arch/powerpc/include/asm/ppc_asm.h

17

#define SZL (BITS_PER_LONG/8)

arch/powerpc/include/asm/uaccess.h

473

unsigned long mask = (unsigned long)(((long)addr >> (BITS_PER_LONG - 1)) & LONG_MAX);

arch/powerpc/kernel/smp.c

302

#define IPI_MESSAGE(A) (1uL << ((BITS_PER_LONG - 8) - 8 * (A)))

arch/powerpc/kexec/core.c

25

#define cpu_to_be_ulong __PASTE(cpu_to_be, BITS_PER_LONG)

arch/powerpc/kexec/core.c

26

#define __be_word __PASTE(__be, BITS_PER_LONG)

arch/powerpc/kvm/book3s_xics.h

64

#define ICP_RESEND_MAP_SIZE (KVMPPC_XICS_MAX_ICS_ID / BITS_PER_LONG + 1)

arch/powerpc/mm/book3s32/mmu_context.c

49

static unsigned long context_map[LAST_CONTEXT / BITS_PER_LONG + 1];

arch/powerpc/mm/nohash/mmu_context.c

79

(sizeof(unsigned long) * (LAST_CONTEXT / BITS_PER_LONG + 1))

arch/riscv/include/asm/arch_hweight.h

12

#if (BITS_PER_LONG == 64)

arch/riscv/include/asm/arch_hweight.h

14

#elif (BITS_PER_LONG == 32)

arch/riscv/include/asm/arch_hweight.h

46

#if BITS_PER_LONG == 64

arch/riscv/include/asm/bitops.h

171

#if (BITS_PER_LONG == 64)

arch/riscv/include/asm/bitops.h

173

#elif (BITS_PER_LONG == 32)

arch/riscv/include/asm/bitops.h

37

#if (BITS_PER_LONG == 64)

arch/riscv/include/asm/bitops.h

40

#elif (BITS_PER_LONG == 32)

arch/riscv/include/asm/bitops.h

83

return BITS_PER_LONG - 1 - word;

arch/riscv/include/asm/bitops.h

94

(unsigned long)(BITS_PER_LONG - 1 - __builtin_clzl(word)) : \

arch/riscv/include/asm/swab.h

44

x = x >> (BITS_PER_LONG - size); \

arch/riscv/include/asm/vector.h

272

unsigned long vl, vtype_inval = 1UL << (BITS_PER_LONG - 1);

arch/riscv/kernel/sbi.c

270

if (hartid + BITS_PER_LONG <= htop ||

arch/riscv/kernel/sbi.c

271

hbase + BITS_PER_LONG <= hartid) {

arch/riscv/kernel/sbi.c

42

if (hartid >= BITS_PER_LONG) {

arch/riscv/kvm/aia.c

25

struct kvm_vcpu *owners[BITS_PER_LONG];

arch/riscv/kvm/aia.c

270

switch (bitpos / BITS_PER_LONG) {

arch/riscv/kvm/aia.c

292

return (hviprio >> (bitpos % BITS_PER_LONG)) & TOPI_IPRIO_MASK;

arch/riscv/kvm/aia.c

303

switch (bitpos / BITS_PER_LONG) {

arch/riscv/kvm/aia.c

325

hviprio &= ~(TOPI_IPRIO_MASK << (bitpos % BITS_PER_LONG));

arch/riscv/kvm/aia.c

326

hviprio |= (unsigned long)prio << (bitpos % BITS_PER_LONG);

arch/riscv/kvm/aia.c

328

switch (bitpos / BITS_PER_LONG) {

arch/riscv/kvm/aia.c

364

nirqs = 4 * (BITS_PER_LONG / 32);

arch/riscv/kvm/aia.c

476

for_each_set_bit(i, &hgei_mask, BITS_PER_LONG) {

arch/riscv/kvm/aia_imsic.c

24

unsigned long eip[BITS_PER_TYPE(u64) / BITS_PER_LONG];

arch/riscv/kvm/aia_imsic.c

25

unsigned long eie[BITS_PER_TYPE(u64) / BITS_PER_LONG];

arch/riscv/kvm/aia_imsic.c

252

unsigned long eipend[BITS_PER_TYPE(u64) / BITS_PER_LONG];

arch/riscv/kvm/vcpu_onereg.c

738

for (i = 0; i < BITS_PER_LONG; i++) {

arch/riscv/kvm/vcpu_onereg.c

739

ext_id = i + reg_num * BITS_PER_LONG;

arch/riscv/kvm/vcpu_onereg.c

761

for_each_set_bit(i, &reg_val, BITS_PER_LONG) {

arch/riscv/kvm/vcpu_onereg.c

762

ext_id = i + reg_num * BITS_PER_LONG;

arch/riscv/kvm/vcpu_pmu.c

181

for_each_set_bit(i, &cmask, BITS_PER_LONG) {

arch/riscv/kvm/vcpu_sbi.c

265

for_each_set_bit(i, &reg_val, BITS_PER_LONG) {

arch/riscv/kvm/vcpu_sbi.c

266

ext_id = i + reg_num * BITS_PER_LONG;

arch/riscv/kvm/vcpu_sbi.c

285

for (i = 0; i < BITS_PER_LONG; i++) {

arch/riscv/kvm/vcpu_sbi.c

286

ext_id = i + reg_num * BITS_PER_LONG;

arch/riscv/kvm/vcpu_sbi_v01.c

56

for_each_set_bit(i, &hmask, BITS_PER_LONG) {

arch/s390/boot/als.c

38

for (j = 0; j < BITS_PER_LONG; j++) {

arch/s390/boot/als.c

39

if (!(val & (1UL << (BITS_PER_LONG - 1 - j))))

arch/s390/boot/als.c

52

u16_to_decimal(val_str, i * BITS_PER_LONG + j);

arch/s390/include/asm/airq.h

76

const unsigned long be_to_le = BITS_PER_LONG - 1;

arch/s390/include/asm/airq.h

82

const unsigned long be_to_le = BITS_PER_LONG - 1;

arch/s390/include/asm/bitops.h

100

return clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);

arch/s390/include/asm/bitops.h

106

return test_and_clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);

arch/s390/include/asm/bitops.h

111

return __set_bit(nr ^ (BITS_PER_LONG - 1), ptr);

arch/s390/include/asm/bitops.h

116

return __clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);

arch/s390/include/asm/bitops.h

122

return test_bit(nr ^ (BITS_PER_LONG - 1), ptr);

arch/s390/include/asm/bitops.h

196

return BITS_PER_LONG - __flogr(-val & val);

arch/s390/include/asm/bitops.h

62

addr += (nr ^ (BITS_PER_LONG - BITS_PER_BYTE)) / BITS_PER_BYTE;

arch/s390/include/asm/bitops.h

95

return set_bit(nr ^ (BITS_PER_LONG - 1), ptr);

arch/s390/include/asm/irqflags.h

12

#define ARCH_IRQ_ENABLED (3UL << (BITS_PER_LONG - 8))

arch/s390/include/asm/word-at-a-time.h

28

return (data ^ (BITS_PER_LONG - 1)) >> 3;

arch/s390/kernel/alternative.c

28

unsigned long facilities[MAX_FACILITY_BIT / BITS_PER_LONG];

arch/s390/kernel/alternative.c

29

unsigned long mfeatures[MAX_MFEATURE_BIT / BITS_PER_LONG];

arch/s390/kernel/ptrace.c

171

(1UL << (BITS_PER_LONG - 1)) : 0;

arch/s390/kernel/ptrace.c

181

child->thread.per_event.cause << (BITS_PER_LONG - 16);

arch/s390/kernel/ptrace.c

188

child->thread.per_event.paid << (BITS_PER_LONG - 8);

arch/s390/kernel/ptrace.c

249

tmp <<= BITS_PER_LONG - 32;

arch/s390/kernel/ptrace.c

390

child->thread.ufpu.fpc = data >> (BITS_PER_LONG - 32);

arch/s390/kvm/interrupt.c

1706

isc = __fls(active_mask) ^ (BITS_PER_LONG - 1);

arch/s390/kvm/interrupt.c

2730

return swap ? (bit ^ (BITS_PER_LONG - 1)) : bit;

arch/s390/lib/find.c

23

while (size & ~(BITS_PER_LONG - 1)) {

arch/s390/lib/find.c

26

result += BITS_PER_LONG;

arch/s390/lib/find.c

27

size -= BITS_PER_LONG;

arch/s390/lib/find.c

31

tmp = (*p) & (~0UL << (BITS_PER_LONG - size));

arch/s390/lib/find.c

35

return result + (__fls(tmp) ^ (BITS_PER_LONG - 1));

arch/s390/lib/find.c

42

const unsigned long *p = addr + (offset / BITS_PER_LONG);

arch/s390/lib/find.c

43

unsigned long result = offset & ~(BITS_PER_LONG - 1);

arch/s390/lib/find.c

49

offset %= BITS_PER_LONG;

arch/s390/lib/find.c

53

if (size < BITS_PER_LONG)

arch/s390/lib/find.c

57

size -= BITS_PER_LONG;

arch/s390/lib/find.c

58

result += BITS_PER_LONG;

arch/s390/lib/find.c

60

while (size & ~(BITS_PER_LONG-1)) {

arch/s390/lib/find.c

63

result += BITS_PER_LONG;

arch/s390/lib/find.c

64

size -= BITS_PER_LONG;

arch/s390/lib/find.c

70

tmp &= (~0UL << (BITS_PER_LONG - size));

arch/s390/lib/find.c

74

return result + (__fls(tmp) ^ (BITS_PER_LONG - 1));

arch/sh/include/asm/bitops-op32.h

13

#define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7)

arch/sparc/include/asm/pgtable_32.h

394

#define MK_IOSPACE_PFN(space, pfn) (pfn | (space << (BITS_PER_LONG - 4)))

arch/sparc/include/asm/pgtable_32.h

395

#define GET_IOSPACE(pfn) (pfn >> (BITS_PER_LONG - 4))

arch/sparc/include/asm/pgtable_64.h

1047

#define MK_IOSPACE_PFN(space, pfn) (pfn | (space << (BITS_PER_LONG - 4)))

arch/sparc/include/asm/pgtable_64.h

1048

#define GET_IOSPACE(pfn) (pfn >> (BITS_PER_LONG - 4))

arch/sparc/kernel/iommu-common.c

117

align_mask = ~0ul >> (BITS_PER_LONG - align_order);

arch/x86/events/probe.c

27

if (cnt >= BITS_PER_LONG)

arch/x86/include/asm/bitops.h

201

return ((1UL << (nr & (BITS_PER_LONG-1))) &

arch/x86/include/asm/bitops.h

21

#if BITS_PER_LONG == 32

arch/x86/include/asm/bitops.h

23

#elif BITS_PER_LONG == 64

arch/x86/include/asm/bitops.h

287

return BITS_PER_LONG - 1 - __builtin_clzl(word);

arch/x86/include/asm/nospec-branch.h

146

add $(BITS_PER_LONG/8) * 2, %_ASM_SP; \

arch/x86/include/asm/nospec-branch.h

162

add $(BITS_PER_LONG/8) * nr, %_ASM_SP;

arch/x86/include/asm/nospec-branch.h

176

add $(BITS_PER_LONG/8), %_ASM_SP; \

arch/x86/include/asm/posted_intr.h

17

#define NR_PIR_WORDS (NR_PIR_VECTORS / BITS_PER_LONG)

arch/x86/include/asm/xen/page.h

43

#define FOREIGN_FRAME_BIT (1UL<<(BITS_PER_LONG-1))

arch/x86/include/asm/xen/page.h

44

#define IDENTITY_FRAME_BIT (1UL<<(BITS_PER_LONG-2))

arch/x86/kernel/apic/apic.c

1433

#define APIC_IR_MAPSIZE (APIC_IR_BITS / BITS_PER_LONG)

arch/x86/kernel/cpu/mtrr/cleanup.c

237

max_align = BITS_PER_LONG - 1;

arch/x86/kernel/kvm.c

516

#define KVM_IPI_CLUSTER_SIZE (2 * BITS_PER_LONG)

arch/x86/kernel/kvm.c

555

(unsigned long)(ipi_bitmap >> BITS_PER_LONG), min, icr);

arch/x86/kernel/kvm.c

566

(unsigned long)(ipi_bitmap >> BITS_PER_LONG), min, icr);

arch/x86/kernel/process.c

75

.sp0 = (1UL << (BITS_PER_LONG-1)) + 1,

arch/x86/kernel/unwind_frame.c

63

sp, BITS_PER_LONG/4, 0);

arch/x86/kernel/unwind_frame.c

68

sp, BITS_PER_LONG/4, word, (void *)word);

arch/x86/kernel/unwind_orc.c

72

printk_deferred("%0*lx: %0*lx (%pB)\n", BITS_PER_LONG/4,

arch/x86/kernel/unwind_orc.c

73

(unsigned long)sp, BITS_PER_LONG/4,

arch/x86/kvm/lapic.c

850

min((u32)BITS_PER_LONG, (map->max_apic_id - min + 1))) {

arch/x86/kvm/mmu/mmu.c

3818

BUILD_BUG_ON(KVM_MMU_NUM_PREV_ROOTS >= BITS_PER_LONG);

arch/x86/kvm/mmu/tdp_mmu.c

1726

gfn + BITS_PER_LONG) {

arch/x86/kvm/vmx/nested.c

588

for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {

arch/x86/kvm/vmx/nested.c

589

unsigned word = msr / BITS_PER_LONG;

arch/x86/kvm/vmx/nested.c

719

for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {

arch/x86/kvm/vmx/nested.c

720

unsigned word = msr / BITS_PER_LONG;

block/blk-iocost.c

1373

if (iocg->delay && shift < BITS_PER_LONG)

block/blk-iocost.c

2148

nr_cycles_shift = min_t(u64, nr_cycles, BITS_PER_LONG - 1);

crypto/fcrypt.c

304

#if BITS_PER_LONG == 64 /* the 64-bit version can also be used for 32-bit

crypto/lrw.c

61

BITS_PER_LONG

drivers/acpi/nfit/core.c

1894

for_each_set_bit(i, &dsm_mask, BITS_PER_LONG)

drivers/acpi/nfit/core.c

2163

for_each_set_bit(i, &dsm_mask, BITS_PER_LONG)

drivers/acpi/nfit/core.c

2171

for_each_set_bit(i, &dsm_mask, BITS_PER_LONG)

drivers/atm/fore200e.h

590

#if (BITS_PER_LONG == 32)

drivers/atm/lanai.c

1432

#if (NUM_VCI * BITS_PER_LONG) <= PAGE_SIZE

drivers/auxdisplay/ht16k33.c

352

for_each_set_bit(row, &bits_changed, BITS_PER_LONG) {

drivers/auxdisplay/img-ascii-lcd.c

59

#if BITS_PER_LONG == 64

drivers/auxdisplay/img-ascii-lcd.c

62

#elif BITS_PER_LONG == 32

drivers/block/drbd/drbd_bitmap.c

1484

changed += BITS_PER_LONG - bits;

drivers/block/drbd/drbd_bitmap.c

1512

unsigned long sl = ALIGN(s,BITS_PER_LONG);

drivers/block/drbd/drbd_bitmap.c

1513

unsigned long el = (e+1) & ~((unsigned long)BITS_PER_LONG-1);

drivers/block/drbd/drbd_bitmap.c

1520

if (e - s <= 3*BITS_PER_LONG) {

drivers/block/drbd/drbd_bitmap.c

1690

count += bitmap_weight(bm, n * BITS_PER_LONG);

drivers/block/drbd/drbd_bitmap.c

481

#define BITS_PER_LONG_MASK (BITS_PER_LONG - 1)

drivers/block/drbd/drbd_bitmap.c

498

bm = p_addr + (tmp/BITS_PER_LONG);

drivers/block/drbd/drbd_bitmap.c

509

if (BITS_PER_LONG == 32 && ((bm - p_addr) & 1) == 1) {

drivers/block/drbd/drbd_bitmap.c

534

bm = p_addr + (tmp/BITS_PER_LONG);

drivers/block/drbd/drbd_bitmap.c

544

if (BITS_PER_LONG == 32 && ((bm - p_addr) & 1) == 1) {

drivers/block/drbd/drbd_bitmap.c

571

bits += bitmap_weight(p_addr, last_word * BITS_PER_LONG);

drivers/block/drbd/drbd_bitmap.c

575

if (BITS_PER_LONG == 32 && (last_word & 1) == 0)

drivers/block/drbd/drbd_int.h

1145

#if BITS_PER_LONG == 32

drivers/block/drbd/drbd_int.h

1149

#elif BITS_PER_LONG == 64

drivers/block/drbd/drbd_int.h

1244

#if BITS_PER_LONG == 32

drivers/block/drbd/drbd_int.h

142

#if BITS_PER_LONG == 64

drivers/block/drbd/drbd_int.h

144

#elif BITS_PER_LONG == 32

drivers/block/drbd/drbd_main.c

1164

c->bit_offset = c->word_offset * BITS_PER_LONG;

drivers/block/drbd/drbd_main.c

1224

c->bit_offset = c->word_offset * BITS_PER_LONG;

drivers/block/drbd/drbd_receiver.c

4472

c->bit_offset = c->word_offset * BITS_PER_LONG;

drivers/block/ps3disk.c

407

BUILD_BUG_ON(PS3DISK_MAX_DISKS > BITS_PER_LONG);

drivers/block/xen-blkfront.c

462

nr_minors = BITS_TO_LONGS(end) * BITS_PER_LONG;

drivers/char/hpet.c

56

#if BITS_PER_LONG == 64

drivers/char/lp.c

734

if (BITS_PER_LONG == 32) {

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-prng.c

47

for (i = 0; i < SS_SEED_LEN / BITS_PER_LONG; i++)

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-prng.c

57

for (i = 0; i < SS_SEED_LEN / BITS_PER_LONG; i++) {

drivers/crypto/allwinner/sun4i-ss/sun4i-ss.h

155

u32 seed[SS_SEED_LEN / BITS_PER_LONG];

drivers/crypto/aspeed/aspeed-acry.c

270

nbits -= count_leading_zeros(src[0]) - (BITS_PER_LONG - 8);

drivers/crypto/cavium/nitrox/nitrox_isr.c

74

for_each_set_bit(i, &value, BITS_PER_LONG)

drivers/crypto/cavium/nitrox/nitrox_isr.c

97

for_each_set_bit(i, &value, BITS_PER_LONG)

drivers/crypto/intel/qat/qat_common/adf_cfg_services.c

39

static_assert(BITS_PER_LONG >= SVC_COUNT);

drivers/crypto/sa2ul.h

206

BITS_PER_LONG)];

drivers/dma/ioat/dma.c

110

for_each_set_bit(bit, &attnstatus, BITS_PER_LONG) {

drivers/dma/ste_dma40.c

1680

BITS_PER_LONG * il_size, chan + 1);

drivers/dma/ste_dma40.c

1683

if (chan == BITS_PER_LONG * il_size)

drivers/dma/ste_dma40.c

1686

row = chan / BITS_PER_LONG;

drivers/dma/ste_dma40.c

1687

idx = chan & (BITS_PER_LONG - 1);

drivers/firmware/efi/libstub/bitmap.c

13

bits_to_set = BITS_PER_LONG;

drivers/firmware/efi/libstub/bitmap.c

27

int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);

drivers/firmware/efi/libstub/bitmap.c

33

bits_to_clear = BITS_PER_LONG;

drivers/firmware/efi/libstub/bitmap.c

7

int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);

drivers/firmware/efi/libstub/find.c

21

idx = __start / BITS_PER_LONG; \

drivers/firmware/efi/libstub/find.c

24

if ((idx + 1) * BITS_PER_LONG >= sz) \

drivers/firmware/efi/libstub/find.c

29

sz = min(idx * BITS_PER_LONG + __ffs(MUNGE(tmp)), sz); \

drivers/firmware/qcom/qcom_qseecom_uefisecapp.c

291

return category << (BITS_PER_LONG - 32) | code;

drivers/gpio/gpio-mmio.c

487

#if BITS_PER_LONG >= 64

drivers/gpio/gpio-mmio.c

639

if (chip->bits > BITS_PER_LONG)

drivers/gpio/gpio-mmio.c

95

#if BITS_PER_LONG >= 64

drivers/gpio/gpio-pxa.c

451

for_each_set_bit(n, &gedr, BITS_PER_LONG) {

drivers/gpio/gpio-spacemit-k1.c

96

for_each_set_bit(n, &pending, BITS_PER_LONG)

drivers/gpio/gpio-winbond.c

357

for_each_set_bit(i, &params.gpios, BITS_PER_LONG) {

drivers/gpio/gpio-winbond.c

579

for_each_set_bit(i, &params.gpios, BITS_PER_LONG)

drivers/gpu/drm/amd/amdgpu/amdgpu.h

1483

#define BIT_MASK_UPPER(i) ((i) >= BITS_PER_LONG ? 0 : ~0UL << (i))

drivers/gpu/drm/amd/amdgpu/amdgpu.h

515

unsigned long used[DIV_ROUND_UP(AMDGPU_MAX_WB, BITS_PER_LONG)];

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

493

#define SMU_FEATURE_BITS_ELEM(bit) ((bit) / BITS_PER_LONG)

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

494

#define SMU_FEATURE_BITS_POS(bit) ((bit) % BITS_PER_LONG)

drivers/gpu/drm/display/drm_dp_tunnel.c

118

#if BITS_PER_LONG == 32

drivers/gpu/drm/drm_client_modeset.c

627

const int count = min_t(unsigned int, connector_count, BITS_PER_LONG);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

525

if (BITS_PER_LONG == 64 && size > MAX_LFS_FILESIZE)

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3579

engine->context_tag = GENMASK(BITS_PER_LONG - 2, 0);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

491

GEM_BUG_ON(ce->tag <= BITS_PER_LONG);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

497

GEM_BUG_ON(tag == 0 || tag >= BITS_PER_LONG);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

501

BUILD_BUG_ON(BITS_PER_LONG > GEN12_MAX_CONTEXT_HW_ID);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

507

GEM_BUG_ON(tag >= BITS_PER_LONG);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

511

BUILD_BUG_ON(BITS_PER_LONG > GEN12_MAX_CONTEXT_HW_ID);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

621

if (ccid < BITS_PER_LONG) {

drivers/gpu/drm/i915/gt/intel_reset_types.h

45

#define I915_WEDGED_ON_INIT (BITS_PER_LONG - 3)

drivers/gpu/drm/i915/gt/intel_reset_types.h

46

#define I915_WEDGED_ON_FINI (BITS_PER_LONG - 2)

drivers/gpu/drm/i915/gt/intel_reset_types.h

47

#define I915_WEDGED (BITS_PER_LONG - 1)

drivers/gpu/drm/i915/gt/sysfs_engines.c

105

GEM_BUG_ON(count > BITS_PER_LONG);

drivers/gpu/drm/i915/gt/sysfs_engines.c

108

for_each_set_bit(n, &caps, show_unknown ? BITS_PER_LONG : count) {

drivers/gpu/drm/i915/i915_mitigations.c

107

if (local & BIT(BITS_PER_LONG - 1)) {

drivers/gpu/drm/i915/i915_perf_types.h

505

#define FORMAT_MASK_SIZE DIV_ROUND_UP(I915_OA_FORMAT_MAX - 1, BITS_PER_LONG)

drivers/gpu/drm/i915/intel_wakeref.h

139

#define INTEL_WAKEREF_PUT_DELAY_MASK GENMASK(BITS_PER_LONG - 1, 1)

drivers/gpu/drm/i915/selftests/i915_vma.c

178

for_each_prime_number(num_ctx, 2 * BITS_PER_LONG) {

drivers/gpu/drm/omapdrm/tcm-sita.c

120

bitmap_set(mask, (*pos % BITS_PER_LONG), w);

drivers/gpu/drm/omapdrm/tcm-sita.c

127

index = *pos / BITS_PER_LONG + i * 8;

drivers/gpu/drm/omapdrm/tcm-sita.c

129

(*pos % BITS_PER_LONG) + w)) {

drivers/gpu/drm/panfrost/panfrost_device.h

90

unsigned long hw_features[64 / BITS_PER_LONG];

drivers/gpu/drm/panfrost/panfrost_device.h

91

unsigned long hw_issues[64 / BITS_PER_LONG];

drivers/gpu/drm/panthor/panthor_mmu.c

2883

if (va_bits > BITS_PER_LONG) {

drivers/gpu/drm/panthor/panthor_mmu.c

2885

ptdev->gpu_info.mmu_features |= BITS_PER_LONG;

drivers/gpu/drm/xe/xe_gt_sriov_pf_control.c

261

(int)BITS_PER_LONG, &state);

drivers/gpu/drm/xe/xe_gt_sriov_pf_control.c

262

for_each_set_bit(bit, &state, BITS_PER_LONG)

drivers/hwmon/ftsteutates.c

405

if (fan_source == FTS_FAN_SOURCE_INVALID || fan_source >= BITS_PER_LONG)

drivers/hwtracing/ptt/hisi_ptt.c

967

} else if (bitmap_subset(&val, &port_mask, BITS_PER_LONG)) {

drivers/i3c/master.c

388

status = bus->addrslots[bitpos / BITS_PER_LONG];

drivers/i3c/master.c

389

status >>= bitpos % BITS_PER_LONG;

drivers/i3c/master.c

409

ptr = bus->addrslots + (bitpos / BITS_PER_LONG);

drivers/i3c/master.c

410

*ptr &= ~((unsigned long)mask << (bitpos % BITS_PER_LONG));

drivers/i3c/master.c

411

*ptr |= ((unsigned long)status & mask) << (bitpos % BITS_PER_LONG);

drivers/iio/adc/ad7944.c

611

if (n_chain_dev > BITS_PER_LONG)

drivers/iio/common/cros_ec_sensors/cros_ec_activity.c

254

for_each_set_bit(i, &activities, BITS_PER_LONG) {

drivers/iio/proximity/sx_common.h

24

static_assert(SX_COMMON_MAX_NUM_CHANNELS < BITS_PER_LONG);

drivers/infiniband/core/cma.c

5405

find_first_bit(&supported_gids, BITS_PER_LONG);

drivers/infiniband/core/umem.c

114

GENMASK(BITS_PER_LONG - 1,

drivers/infiniband/hw/hfi1/fault.h

29

unsigned long opcodes[(1U << BITS_PER_BYTE) / BITS_PER_LONG];

drivers/infiniband/hw/hfi1/mad.c

2592

for_each_set_bit(vl, &vl_all_mask, BITS_PER_LONG) {

drivers/infiniband/hw/hfi1/mad.c

2800

for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {

drivers/infiniband/hw/hfi1/mad.c

2895

for_each_set_bit(vl, &vl_all_mask, BITS_PER_LONG) {

drivers/infiniband/hw/hfi1/mad.c

3027

for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {

drivers/infiniband/hw/hfi1/mad.c

3228

for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {

drivers/infiniband/hw/hfi1/mad.c

3533

for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {

drivers/infiniband/hw/mlx5/mlx5_ib.h

56

BITS_PER_LONG - 1);

drivers/infiniband/hw/mlx5/mlx5_ib.h

72

BITS_PER_LONG - 1);

drivers/infiniband/hw/mthca/mthca_doorbell.h

43

#if BITS_PER_LONG == 64

drivers/infiniband/hw/mthca/mthca_profile.c

272

if (mthca_is_memfree(dev) || BITS_PER_LONG == 64)

drivers/infiniband/sw/rdmavt/qp.c

167

wss->num_entries = table_bits / BITS_PER_LONG;

drivers/infiniband/sw/rdmavt/qp.c

248

u32 entry = page / BITS_PER_LONG; /* assumes this ends up a shift */

drivers/infiniband/sw/rdmavt/qp.c

249

u32 nr = page & (BITS_PER_LONG - 1);

drivers/input/keyboard/bcm-keypad.c

108

for_each_set_bit(bit_nr, &change, BITS_PER_LONG) {

drivers/input/keyboard/st-keyscan.c

52

for_each_set_bit(bit_nr, &change, BITS_PER_LONG)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

597

ebidx = Q_IDX(&llq, eprod) % BITS_PER_LONG;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

602

u32 limit = BITS_PER_LONG;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

605

sbidx = Q_IDX(&llq, llq.prod) % BITS_PER_LONG;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

398

#define CMDQ_BATCH_ENTRIES BITS_PER_LONG

drivers/iommu/io-pgtable-arm-selftests.c

111

for_each_set_bit(j, &cfg->pgsize_bitmap, BITS_PER_LONG) {

drivers/iommu/io-pgtable-arm-selftests.c

88

for_each_set_bit(j, &cfg->pgsize_bitmap, BITS_PER_LONG) {

drivers/iommu/io-pgtable-arm-v7s.c

853

for_each_set_bit(i, &cfg.pgsize_bitmap, BITS_PER_LONG) {

drivers/iommu/io-pgtable-arm-v7s.c

875

for_each_set_bit(i, &cfg.pgsize_bitmap, BITS_PER_LONG) {

drivers/iommu/iommufd/selftest.c

1740

tmp = kvzalloc(DIV_ROUND_UP(max, BITS_PER_LONG) * sizeof(unsigned long),

drivers/irqchip/irq-armada-370-xp.c

647

for_each_set_bit(i, &cause, BITS_PER_LONG)

drivers/irqchip/irq-loongson-eiointc.c

41

#define VEC_COUNT_PER_REG BITS_PER_LONG

drivers/irqchip/irq-loongson-eiointc.c

42

#define VEC_REG_COUNT (VEC_COUNT / BITS_PER_LONG)

drivers/irqchip/irq-mmp.c

174

for_each_set_bit(n, &status, BITS_PER_LONG) {

drivers/irqchip/irq-mvebu-pic.c

112

for_each_set_bit(irqn, &irqmap, BITS_PER_LONG)

drivers/irqchip/irq-riscv-imsic-state.c

71

isel = id / BITS_PER_LONG;

drivers/irqchip/irq-riscv-imsic-state.c

72

isel *= BITS_PER_LONG / IMSIC_EIPx_BITS;

drivers/irqchip/irq-riscv-imsic-state.c

721

i = BITS_PER_LONG - IMSIC_MMIO_PAGE_SHIFT;

drivers/irqchip/irq-riscv-imsic-state.c

728

i = BITS_PER_LONG - IMSIC_MMIO_PAGE_SHIFT - global->guest_index_bits;

drivers/irqchip/irq-riscv-imsic-state.c

735

i = BITS_PER_LONG - IMSIC_MMIO_PAGE_SHIFT -

drivers/irqchip/irq-riscv-imsic-state.c

744

if (i >= BITS_PER_LONG) {

drivers/irqchip/irq-riscv-imsic-state.c

95

isel = id / BITS_PER_LONG;

drivers/irqchip/irq-riscv-imsic-state.c

96

isel *= BITS_PER_LONG / IMSIC_EIPx_BITS;

drivers/irqchip/irq-riscv-intc.c

25

static unsigned int riscv_intc_nr_irqs __ro_after_init = BITS_PER_LONG;

drivers/irqchip/irq-riscv-intc.c

26

static unsigned int riscv_intc_custom_base __ro_after_init = BITS_PER_LONG;

drivers/irqchip/irq-riscv-intc.c

54

if (IS_ENABLED(CONFIG_32BIT) && d->hwirq >= BITS_PER_LONG)

drivers/irqchip/irq-riscv-intc.c

55

csr_clear(CSR_IEH, BIT(d->hwirq - BITS_PER_LONG));

drivers/irqchip/irq-riscv-intc.c

62

if (IS_ENABLED(CONFIG_32BIT) && d->hwirq >= BITS_PER_LONG)

drivers/irqchip/irq-riscv-intc.c

63

csr_set(CSR_IEH, BIT(d->hwirq - BITS_PER_LONG));

drivers/irqchip/irq-riscv-intc.c

75

unsigned int mask = BIT(d->hwirq % BITS_PER_LONG);

drivers/irqchip/irq-riscv-intc.c

85

unsigned int mask = BIT(d->hwirq % BITS_PER_LONG);

drivers/md/bcache/util.h

294

#if BITS_PER_LONG == 32

drivers/md/bcache/util.h

303

#if BITS_PER_LONG == 32

drivers/md/dm-cache-policy-internal.h

119

return sizeof(unsigned long) * dm_div_up(nr_entries, BITS_PER_LONG);

drivers/md/dm-clone-metadata.c

661

unsigned long index = word * BITS_PER_LONG;

drivers/md/dm-clone-metadata.c

662

unsigned long max_index = min(cmd->nr_regions, (word + 1) * BITS_PER_LONG);

drivers/md/dm-clone-metadata.c

845

word = region_nr / BITS_PER_LONG;

drivers/md/dm-clone-metadata.c

891

word = region_nr / BITS_PER_LONG;

drivers/md/dm-era-target.c

69

return sizeof(unsigned long) * dm_div_up(nr_bits, BITS_PER_LONG);

drivers/md/dm-integrity.c

114

#if BITS_PER_LONG == 64

drivers/md/dm-integrity.c

624

if (!(bit % BITS_PER_LONG) && this_end_bit >= bit + BITS_PER_LONG - 1) {

drivers/md/dm-integrity.c

626

if (data[bit / BITS_PER_LONG] != -1)

drivers/md/dm-integrity.c

628

bit += BITS_PER_LONG;

drivers/md/dm-integrity.c

629

} while (this_end_bit >= bit + BITS_PER_LONG - 1);

drivers/md/dm-integrity.c

638

if (!(bit % BITS_PER_LONG) && this_end_bit >= bit + BITS_PER_LONG - 1) {

drivers/md/dm-integrity.c

640

if (data[bit / BITS_PER_LONG] != 0)

drivers/md/dm-integrity.c

642

bit += BITS_PER_LONG;

drivers/md/dm-integrity.c

643

} while (this_end_bit >= bit + BITS_PER_LONG - 1);

drivers/md/dm-integrity.c

652

if (!(bit % BITS_PER_LONG) && this_end_bit >= bit + BITS_PER_LONG - 1) {

drivers/md/dm-integrity.c

654

data[bit / BITS_PER_LONG] = -1;

drivers/md/dm-integrity.c

655

bit += BITS_PER_LONG;

drivers/md/dm-integrity.c

656

} while (this_end_bit >= bit + BITS_PER_LONG - 1);

drivers/md/dm-integrity.c

667

if (!(bit % BITS_PER_LONG) && this_end_bit >= bit + BITS_PER_LONG - 1) {

drivers/md/dm-integrity.c

669

data[bit / BITS_PER_LONG] = 0;

drivers/md/dm-integrity.c

670

bit += BITS_PER_LONG;

drivers/md/dm-integrity.c

671

} while (this_end_bit >= bit + BITS_PER_LONG - 1);

drivers/md/dm-io.c

23

#define DM_IO_MAX_REGIONS BITS_PER_LONG

drivers/md/dm-log.c

422

bitset_size = dm_round_up(region_count, BITS_PER_LONG);

drivers/md/dm-log.c

623

for (i = lc->region_count; i % BITS_PER_LONG; i++)

drivers/md/dm-stats.c

585

#if BITS_PER_LONG == 32

drivers/md/dm-stats.c

627

#if BITS_PER_LONG == 32

drivers/md/dm-writecache.c

2565

wc->dirty_bitmap_size = (n_bitmap_bits + BITS_PER_LONG - 1) /

drivers/md/dm-writecache.c

2566

BITS_PER_LONG * sizeof(unsigned long);

drivers/md/dm-writecache.c

85

#if BITS_PER_LONG == 64

drivers/md/dm-zoned-metadata.c

2374

if (((bit & (BITS_PER_LONG - 1)) == 0) &&

drivers/md/dm-zoned-metadata.c

2375

((end - bit) >= BITS_PER_LONG)) {

drivers/md/dm-zoned-metadata.c

2380

n += BITS_PER_LONG;

drivers/md/dm-zoned-metadata.c

2381

bit += BITS_PER_LONG;

drivers/md/dm-zoned-metadata.c

2531

if (((bit & (BITS_PER_LONG - 1)) == 0) &&

drivers/md/dm-zoned-metadata.c

2532

((end - bit) >= BITS_PER_LONG)) {

drivers/md/dm-zoned-metadata.c

2537

n += BITS_PER_LONG;

drivers/md/dm-zoned-metadata.c

2538

bit += BITS_PER_LONG;

drivers/md/dm-zoned-metadata.c

2719

if (((bit & (BITS_PER_LONG - 1)) == 0) &&

drivers/md/dm-zoned-metadata.c

2720

((end - bit) >= BITS_PER_LONG)) {

drivers/md/dm-zoned-metadata.c

2723

n += BITS_PER_LONG;

drivers/md/dm-zoned-metadata.c

2724

bit += BITS_PER_LONG;

drivers/md/md-bitmap.c

2849

if (BITS_PER_LONG > 32 && csize >= (1ULL << (BITS_PER_BYTE *

drivers/media/mc/mc-entity.c

67

idx_max = ALIGN(mdev->entity_internal_idx_max + 1, BITS_PER_LONG);

drivers/memory/brcmstb_dpfe.c

50

(BITS_PER_LONG - DRAM_MSG_TYPE_OFFSET)) - 1)

drivers/mmc/host/renesas_sdhi.h

92

DECLARE_BITMAP(taps, BITS_PER_LONG);

drivers/mmc/host/renesas_sdhi.h

94

DECLARE_BITMAP(smpcmp, BITS_PER_LONG);

drivers/mtd/chips/cfi_util.c

107

#if BITS_PER_LONG >= 64

drivers/mtd/chips/cfi_util.c

163

#if BITS_PER_LONG >= 64

drivers/mtd/mtdoops.c

359

vmalloc_array(DIV_ROUND_UP(mtdoops_pages, BITS_PER_LONG),

drivers/mtd/nand/bbt.c

109

((entry * bits_per_block) / BITS_PER_LONG);

drivers/mtd/nand/bbt.c

110

unsigned int offs = (entry * bits_per_block) % BITS_PER_LONG;

drivers/mtd/nand/bbt.c

119

if (bits_per_block + offs > BITS_PER_LONG) {

drivers/mtd/nand/bbt.c

120

unsigned int rbits = bits_per_block + offs - BITS_PER_LONG;

drivers/mtd/nand/bbt.c

76

((entry * bits_per_block) / BITS_PER_LONG);

drivers/mtd/nand/bbt.c

77

unsigned int offs = (entry * bits_per_block) % BITS_PER_LONG;

drivers/mtd/nand/bbt.c

84

if (bits_per_block + offs > BITS_PER_LONG)

drivers/mtd/nand/bbt.c

85

status |= pos[1] << (BITS_PER_LONG - offs);

drivers/mtd/nand/core.c

54

bitflips += BITS_PER_LONG - weight;

drivers/mtd/tests/mtd_nandecctest.c

42

__change_bit((nr) ^ ((BITS_PER_LONG - 1) & ~0x7), addr)

drivers/net/ethernet/broadcom/bnge/bnge.h

112

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnge/bnge.h

235

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnge/bnge_core.c

316

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnge/bnge_txrx.h

21

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c

35

#if (BITS_PER_LONG == 64)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15369

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnxt/bnxt.h

2666

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnxt/bnxt.h

2840

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/bnxt/bnxt.h

2852

#if BITS_PER_LONG == 32

drivers/net/ethernet/broadcom/tg3.c

7736

#if defined(CONFIG_HIGHMEM) && (BITS_PER_LONG == 64)

drivers/net/ethernet/cavium/liquidio/octeon_main.h

28

#if BITS_PER_LONG == 32

drivers/net/ethernet/cavium/liquidio/octeon_main.h

30

#elif BITS_PER_LONG == 64

drivers/net/ethernet/chelsio/cxgb4/sge.c

4243

unsigned int id = __ffs(m) + i * BITS_PER_LONG;

drivers/net/ethernet/chelsio/cxgb4/sge.c

4279

unsigned long id = __ffs(m) + i * BITS_PER_LONG;

drivers/net/ethernet/chelsio/cxgb4vf/sge.c

2081

unsigned int id = __ffs(m) + i * BITS_PER_LONG;

drivers/net/ethernet/intel/ice/ice_adapter.c

47

#if BITS_PER_LONG == 64

drivers/net/ethernet/intel/igb/igb.h

287

#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)

drivers/net/ethernet/intel/igb/igb_main.c

5289

word = vid / BITS_PER_LONG;

drivers/net/ethernet/intel/igb/igb_main.c

5290

bits = vid % BITS_PER_LONG;

drivers/net/ethernet/intel/igc/igc.h

583

#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5088

word = vid / BITS_PER_LONG;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5089

bits = vid % BITS_PER_LONG;

drivers/net/ethernet/intel/ixgbevf/ixgbevf.h

48

#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.c

1902

if (mcam->lprio_count > BITS_PER_LONG)

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.c

1904

BITS_PER_LONG);

drivers/net/ethernet/sfc/bitfield.h

222

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/bitfield.h

348

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/bitfield.h

595

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/ef10.c

1742

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/falcon/bitfield.h

220

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/falcon/bitfield.h

328

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/falcon/bitfield.h

518

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/falcon/io.h

62

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/falcon/selftest.c

185

BUILD_BUG_ON(EF4_MAX_CHANNELS > BITS_PER_LONG);

drivers/net/ethernet/sfc/io.h

38

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/selftest.c

185

BUILD_BUG_ON(EFX_MAX_CHANNELS > BITS_PER_LONG);

drivers/net/ethernet/sfc/siena/bitfield.h

220

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/siena/bitfield.h

346

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/siena/bitfield.h

593

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/siena/io.h

62

#if BITS_PER_LONG == 64

drivers/net/ethernet/sfc/siena/selftest.c

186

BUILD_BUG_ON(EFX_MAX_CHANNELS > BITS_PER_LONG);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1455

} __aligned(BITS_PER_LONG / 8) keys;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1459

} __aligned(BITS_PER_LONG / 8) masks;

drivers/net/ethernet/tehuti/tehuti.h

79

#if BITS_PER_LONG == 64

drivers/net/ethernet/tehuti/tehuti.h

82

#elif BITS_PER_LONG == 32

drivers/net/ethernet/ti/davinci_cpdma.h

11

#define CPDMA_MAX_CHANNELS BITS_PER_LONG

drivers/net/ipa/gsi.c

1701

u32 event_bitmap = GENMASK(BITS_PER_LONG - 1, evt_ring_max);

drivers/net/wireguard/messages.h

36

COUNTER_REDUNDANT_BITS = BITS_PER_LONG,

drivers/net/wireguard/noise.h

21

unsigned long backtrack[COUNTER_BITS_TOTAL / BITS_PER_LONG];

drivers/net/wireguard/receive.c

312

index = their_counter >> ilog2(BITS_PER_LONG);

drivers/net/wireguard/receive.c

315

index_current = counter->counter >> ilog2(BITS_PER_LONG);

drivers/net/wireguard/receive.c

317

COUNTER_BITS_TOTAL / BITS_PER_LONG);

drivers/net/wireguard/receive.c

320

((COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1)] = 0;

drivers/net/wireguard/receive.c

324

index &= (COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1;

drivers/net/wireguard/receive.c

325

ret = !test_and_set_bit(their_counter & (BITS_PER_LONG - 1),

drivers/net/wireless/ath/ath10k/debug.c

328

if (num_vdevs >= BITS_PER_LONG) {

drivers/net/wireless/ath/ath10k/mac.c

3655

WARN_ON(reason >= BITS_PER_LONG);

drivers/net/wireless/ath/ath10k/mac.c

3666

WARN_ON(reason >= BITS_PER_LONG);

drivers/net/wireless/ath/ath10k/mac.c

5925

for (i = 0; i < BITS_PER_LONG; i++)

drivers/net/wireless/intel/iwlwifi/dvm/rs.c

2781

for_each_set_bit(i, &supp, BITS_PER_LONG)

drivers/net/wireless/intel/iwlwifi/dvm/rxon.c

929

for_each_set_bit(i, &basic, BITS_PER_LONG) {

drivers/net/wireless/intel/iwlwifi/mld/link.c

80

for_each_set_bit(i, &basic, BITS_PER_LONG) {

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

420

for_each_set_bit(i, &rates_bitmap, BITS_PER_LONG)

drivers/net/wireless/intel/iwlwifi/mld/tx.c

354

for_each_set_bit(i, &basic_rates, BITS_PER_LONG) {

drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c

340

for_each_set_bit(i, &basic, BITS_PER_LONG) {

drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c

899

for_each_set_bit(i, &basic, BITS_PER_LONG) {

drivers/net/wireless/intel/iwlwifi/mvm/rs-fw.c

382

for_each_set_bit(i, &tmp, BITS_PER_LONG)

drivers/net/wireless/intel/iwlwifi/mvm/rs.c

1216

return find_last_bit(&rate_mask, BITS_PER_LONG);

drivers/net/wireless/intel/iwlwifi/mvm/rs.c

1352

rate_idx = find_first_bit(&rate_mask, BITS_PER_LONG);

drivers/net/wireless/intel/iwlwifi/mvm/rs.c

2470

BITS_PER_LONG);

drivers/net/wireless/intel/iwlwifi/mvm/rs.c

2525

BITS_PER_LONG);

drivers/net/wireless/intel/iwlwifi/mvm/rs.c

2971

for_each_set_bit(i, &supp, BITS_PER_LONG)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

2501

for_each_set_bit(queue, &txqs, BITS_PER_LONG) {

drivers/net/wireless/mediatek/mt7601u/main.c

201

idx = i * BITS_PER_LONG + idx;

drivers/net/wireless/mediatek/mt7601u/main.c

250

dev->wcid_mask[idx / BITS_PER_LONG] &= ~BIT(idx % BITS_PER_LONG);

drivers/net/wireless/mediatek/mt7601u/main.c

62

if (dev->wcid_mask[wcid / BITS_PER_LONG] & BIT(wcid % BITS_PER_LONG))

drivers/net/wireless/mediatek/mt7601u/main.c

64

dev->wcid_mask[wcid / BITS_PER_LONG] |= BIT(wcid % BITS_PER_LONG);

drivers/net/wireless/mediatek/mt7601u/main.c

78

dev->wcid_mask[wcid / BITS_PER_LONG] &= ~BIT(wcid % BITS_PER_LONG);

drivers/net/wireless/mediatek/mt7601u/mt7601u.h

160

unsigned long wcid_mask[N_WCIDS / BITS_PER_LONG];

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie_ipc.h

49

#if BITS_PER_LONG == 64

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie_ipc.h

53

#elif BITS_PER_LONG == 32

drivers/nvdimm/core.c

286

for_each_set_bit(cmd, &nd_desc->cmd_mask, BITS_PER_LONG)

drivers/nvdimm/dimm_devs.c

285

for_each_set_bit(cmd, &nvdimm->cmd_mask, BITS_PER_LONG)

drivers/nvdimm/label.c

699

u32 nfree = ALIGN(nslot, BITS_PER_LONG);

drivers/parisc/ccio-dma.c

428

BUG_ON(pages_mapped > BITS_PER_LONG);

drivers/parisc/sba_iommu.c

205

__le64 *ptr = &(ioc->pdir_base[pide & (~0U * BITS_PER_LONG)]);

drivers/parisc/sba_iommu.c

211

rptr, pide & (BITS_PER_LONG - 1), *rptr);

drivers/parisc/sba_iommu.c

214

while (rcnt < BITS_PER_LONG) {

drivers/parisc/sba_iommu.c

216

(rcnt == (pide & (BITS_PER_LONG - 1)))

drivers/parisc/sba_iommu.c

320

#define RESMAP_MASK(n) (~0UL << (BITS_PER_LONG - (n)))

drivers/parisc/sba_iommu.c

360

if (bits_wanted > (BITS_PER_LONG/2)) {

drivers/parisc/sba_iommu.c

387

if (bitshiftcnt >= BITS_PER_LONG) {

drivers/parisc/sba_iommu.c

504

unsigned long m = RESMAP_MASK(bits_not_wanted) >> (pide & (BITS_PER_LONG - 1));

drivers/pci/controller/cadence/pcie-cadence-ep.c

192

r = find_first_zero_bit(&ep->ob_region_map, BITS_PER_LONG);

drivers/pci/controller/cadence/pcie-cadence-ep.c

588

last_fn = find_last_bit(&epc->function_num_map, BITS_PER_LONG);

drivers/pci/endpoint/pci-epc-core.c

727

BITS_PER_LONG);

drivers/pci/endpoint/pci-epc-core.c

728

if (func_no >= BITS_PER_LONG) {

drivers/pci/endpoint/pci-epc-mem.c

30

#if BITS_PER_LONG == 32

drivers/pci/endpoint/pci-epf-core.c

170

BITS_PER_LONG);

drivers/pci/endpoint/pci-epf-core.c

171

if (vfunc_no >= BITS_PER_LONG) {

drivers/pci/hotplug/ibmphp_res.c

2064

#if BITS_PER_LONG == 64

drivers/perf/riscv_pmu_sbi.c

1021

for_each_set_bit(idx, &cpu_hw_evt->used_hw_ctrs[i], BITS_PER_LONG)

drivers/perf/riscv_pmu_sbi.c

1023

cpu_hw_evt->snapshot_cval_shcopy[idx + i * BITS_PER_LONG];

drivers/perf/riscv_pmu_sbi.c

1025

sbi_ecall(SBI_EXT_PMU, SBI_EXT_PMU_COUNTER_START, idx * BITS_PER_LONG,

drivers/perf/riscv_pmu_sbi.c

1214

riscv_pmu_irq_mask = BIT(riscv_pmu_irq_num % BITS_PER_LONG);

drivers/perf/riscv_pmu_sbi.c

927

ret = sbi_ecall(SBI_EXT_PMU, SBI_EXT_PMU_COUNTER_STOP, i * BITS_PER_LONG,

drivers/perf/riscv_pmu_sbi.c

931

for_each_set_bit(idx, &cpu_hw_evt->used_hw_ctrs[i], BITS_PER_LONG)

drivers/perf/riscv_pmu_sbi.c

932

cpu_hw_evt->snapshot_cval_shcopy[i * BITS_PER_LONG + idx] =

drivers/perf/riscv_pmu_sbi.c

935

temp_ctr_overflow_mask |= sdata->ctr_overflow_mask << (i * BITS_PER_LONG);

drivers/perf/riscv_pmu_sbi.c

969

sbi_ecall(SBI_EXT_PMU, SBI_EXT_PMU_COUNTER_START, i * BITS_PER_LONG,

drivers/pinctrl/pinctrl-at91-pio4.c

309

for_each_set_bit(n, &isr, BITS_PER_LONG)

drivers/pinctrl/pinctrl-at91-pio4.c

358

#if ATMEL_PIO_NPINS_PER_BANK != BITS_PER_LONG

drivers/pinctrl/pinctrl-at91-pio4.c

360

offset = bank * ATMEL_PIO_NPINS_PER_BANK % BITS_PER_LONG;

drivers/pinctrl/pinctrl-at91-pio4.c

419

#if ATMEL_PIO_NPINS_PER_BANK != BITS_PER_LONG

drivers/pinctrl/pinctrl-at91-pio4.c

431

#if ATMEL_PIO_NPINS_PER_BANK != BITS_PER_LONG

drivers/pinctrl/pinctrl-at91.c

1716

for_each_set_bit(n, &isr, BITS_PER_LONG)

drivers/pinctrl/pinctrl-pic32.c

2082

for_each_set_bit(pin, &status, BITS_PER_LONG) {

drivers/pinctrl/pinctrl-pic32.c

2106

for_each_set_bit(pin, &pending, BITS_PER_LONG)

drivers/pinctrl/pinctrl-st.c

1416

for_each_set_bit(n, &active_irqs, BITS_PER_LONG) {

drivers/pinctrl/uniphier/pinctrl-uniphier.h

51

#if UNIPHIER_PIN_PULL_DIR_SHIFT + UNIPHIER_PIN_PULL_DIR_BITS > BITS_PER_LONG

drivers/platform/x86/dell/alienware-wmi-wmax.c

1173

bitmap_copy(&fan_data->auto_channels_temp, gather, BITS_PER_LONG);

drivers/platform/x86/fujitsu-laptop.c

1077

for_each_set_bit(i, &flags, BITS_PER_LONG)

drivers/ps3/ps3-vuart.c

888

port = (BITS_PER_LONG - 1) - __ilog2(bus_priv->bmp->status);

drivers/ps3/ps3-vuart.c

890

if (port == BITS_PER_LONG)

drivers/ras/amd/atl/internal.h

315

WARN_ON_ONCE(num_bits >= BITS_PER_LONG);

drivers/ras/amd/atl/internal.h

319

WARN_ON_ONCE(bit_num >= BITS_PER_LONG);

drivers/ras/amd/atl/internal.h

340

WARN_ON_ONCE(high_bit >= BITS_PER_LONG);

drivers/ras/amd/atl/internal.h

341

WARN_ON_ONCE(low_bit >= BITS_PER_LONG);

drivers/reset/reset-zynq.c

114

priv->rcdev.nr_resets = resource_size(res) / 4 * BITS_PER_LONG;

drivers/reset/reset-zynq.c

34

int bank = id / BITS_PER_LONG;

drivers/reset/reset-zynq.c

35

int offset = id % BITS_PER_LONG;

drivers/reset/reset-zynq.c

51

int bank = id / BITS_PER_LONG;

drivers/reset/reset-zynq.c

52

int offset = id % BITS_PER_LONG;

drivers/reset/reset-zynq.c

68

int bank = id / BITS_PER_LONG;

drivers/reset/reset-zynq.c

69

int offset = id % BITS_PER_LONG;

drivers/rtc/class.c

75

#if BITS_PER_LONG == 32

drivers/scsi/arcmsr/arcmsr.h

1002

#if BITS_PER_LONG == 64

drivers/scsi/hpsa.c

5118

#if BITS_PER_LONG == 32

drivers/scsi/hpsa.c

5207

#if BITS_PER_LONG == 32

drivers/scsi/hpsa.c

5298

#if BITS_PER_LONG == 32

drivers/scsi/hpsa.c

5317

#if BITS_PER_LONG == 32

drivers/scsi/hpsa.c

5334

#if BITS_PER_LONG == 32

drivers/scsi/lpfc/lpfc_disc.h

75

#define XRI_BITMAP_ULONGS (LPFC_SLI4_MAX_XRI / BITS_PER_LONG)

drivers/scsi/lpfc/lpfc_init.c

8345

longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG;

drivers/scsi/lpfc/lpfc_mem.c

81

bytes = ((BITS_PER_LONG - 1 + max_xri) / BITS_PER_LONG) *

drivers/scsi/lpfc/lpfc_sli.c

5752

longs = (phba->max_vpi + BITS_PER_LONG) / BITS_PER_LONG;

drivers/scsi/lpfc/lpfc_sli.c

6483

longs = ((rsrc_cnt * rsrc_size) + BITS_PER_LONG - 1) / BITS_PER_LONG;

drivers/scsi/lpfc/lpfc_sli.c

7257

longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;

drivers/scsi/lpfc/lpfc_sli.c

7285

longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;

drivers/scsi/lpfc/lpfc_sli.c

7312

longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;

drivers/scsi/lpfc/lpfc_sli.c

7341

longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;

drivers/scsi/megaraid.h

479

#if BITS_PER_LONG == 32

drivers/scsi/megaraid.h

483

#if BITS_PER_LONG == 64

drivers/scsi/megaraid.h

491

#if BITS_PER_LONG == 32

drivers/scsi/megaraid.h

495

#if BITS_PER_LONG == 64

drivers/scsi/megaraid/megaraid_mm.h

71

#if BITS_PER_LONG == 32

drivers/scsi/megaraid/megaraid_mm.h

75

#if BITS_PER_LONG == 64

drivers/scsi/megaraid/megaraid_mm.h

85

#if BITS_PER_LONG == 32

drivers/scsi/megaraid/megaraid_mm.h

89

#if BITS_PER_LONG == 64

drivers/scsi/megaraid/megaraid_sas_base.c

6041

instance->bar = find_first_bit(&bar_list, BITS_PER_LONG);

drivers/scsi/mvumi.c

885

BITS_PER_LONG);

drivers/scsi/mvumi.c

888

BITS_PER_LONG);

drivers/scsi/ncr53c8xx.c

860

#if BITS_PER_LONG == 32

drivers/scsi/qedi/qedi.h

331

unsigned long task_idx_map[MAX_ISCSI_TASK_ENTRIES / BITS_PER_LONG];

drivers/scsi/qla4xxx/ql4_def.h

792

unsigned long ddb_idx_map[MAX_DDB_ENTRIES / BITS_PER_LONG];

drivers/scsi/scsi_debug.c

274

#define SDEBUG_CANQUEUE (SDEBUG_CANQUEUE_WORDS * BITS_PER_LONG)

drivers/scsi/scsi_debugfs.c

24

for_each_set_bit(i, &flags, BITS_PER_LONG) {

drivers/scsi/smartpqi/smartpqi_init.c

2761

#if BITS_PER_LONG == 32

drivers/scsi/smartpqi/smartpqi_init.c

2782

#if BITS_PER_LONG == 32

drivers/scsi/smartpqi/smartpqi_init.c

2828

#if BITS_PER_LONG == 32

drivers/scsi/smartpqi/smartpqi_init.c

2838

#if BITS_PER_LONG == 32

drivers/scsi/smartpqi/smartpqi_init.c

2857

#if BITS_PER_LONG == 32

drivers/scsi/smartpqi/smartpqi_init.c

2874

#if BITS_PER_LONG == 32

drivers/scsi/smartpqi/smartpqi_init.c

2938

#if BITS_PER_LONG == 32

drivers/scsi/sr.c

106

static unsigned long sr_index_bits[SR_DISKS / BITS_PER_LONG];

drivers/soc/fsl/qbman/qman.c

1144

#if BITS_PER_LONG == 64

drivers/soc/fsl/qbman/qman.c

1153

#if BITS_PER_LONG == 64

drivers/soc/ti/knav_qmss_queue.c

1253

for_each_set_bit(bit, &mask, BITS_PER_LONG)

drivers/tty/tty_ldsem.c

37

#if BITS_PER_LONG == 64

drivers/usb/dwc2/hcd.h

193

BITS_PER_LONG)

drivers/usb/host/xhci-hub.c

1955

BITS_PER_LONG) {

drivers/usb/host/xhci-hub.c

1964

for_each_set_bit(port_index, &bus_state->bus_suspended, BITS_PER_LONG) {

drivers/vfio/vfio_iommu_type1.c

1278

unsigned long copy_offset = bit_offset / BITS_PER_LONG;

drivers/vfio/vfio_iommu_type1.c

1279

unsigned long shift = bit_offset % BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2557

#if BITS_PER_LONG == 32

drivers/video/fbdev/amifb.c

2560

#elif BITS_PER_LONG == 64

drivers/video/fbdev/amifb.c

2604

last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));

drivers/video/fbdev/amifb.c

2609

if (dst_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2621

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

2625

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2647

right = shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

2648

left = -shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

2650

if (dst_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2657

} else if (src_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2675

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

2683

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

2687

m = n % BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2688

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2742

dst += (n - 1) / BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2743

src += (n - 1) / BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2744

if ((n - 1) % BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2745

dst_idx += (n - 1) % BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2747

dst_idx &= BITS_PER_LONG - 1;

drivers/video/fbdev/amifb.c

2748

src_idx += (n - 1) % BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2750

src_idx &= BITS_PER_LONG - 1;

drivers/video/fbdev/amifb.c

2754

first = ~0UL << (BITS_PER_LONG - 1 - dst_idx);

drivers/video/fbdev/amifb.c

2755

last = ~(~0UL << (BITS_PER_LONG - 1 - ((dst_idx - n) % BITS_PER_LONG)));

drivers/video/fbdev/amifb.c

2776

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2798

right = shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

2799

left = -shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

2838

m = n % BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2839

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2896

last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));

drivers/video/fbdev/amifb.c

2901

if (dst_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2913

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

2917

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2939

right = shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

2940

left = -shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

2942

if (dst_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2949

} else if (src_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

2967

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

2975

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

2979

m = n % BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2980

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

3031

#if BITS_PER_LONG == 64

drivers/video/fbdev/amifb.c

3036

last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));

drivers/video/fbdev/amifb.c

3038

if (dst_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

3049

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

3053

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

3087

#if BITS_PER_LONG == 64

drivers/video/fbdev/amifb.c

3092

last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));

drivers/video/fbdev/amifb.c

3094

if (dst_idx + n <= BITS_PER_LONG) {

drivers/video/fbdev/amifb.c

3105

n -= BITS_PER_LONG - dst_idx;

drivers/video/fbdev/amifb.c

3109

n /= BITS_PER_LONG;

drivers/video/fbdev/amifb.c

3132

dst_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

3147

dst_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

3206

dst_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

3208

src_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

3223

dst_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

3225

src_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/amifb.c

3308

dst_idx &= (BITS_PER_LONG - 1);

drivers/video/fbdev/core/cfbmem.h

20

ptr.address = PTR_ALIGN_DOWN(base, BITS_PER_LONG / BITS_PER_BYTE);

drivers/video/fbdev/core/cfbmem.h

28

#if BITS_PER_LONG == 32

drivers/video/fbdev/core/cfbmem.h

29

fb_writel(val, dst->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

31

fb_writeq(val, dst->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

38

#if BITS_PER_LONG == 32

drivers/video/fbdev/core/cfbmem.h

39

return fb_readl(src->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

41

return fb_readq(src->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/fb_copyarea.h

103

last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), reverse);

drivers/video/fbdev/core/fb_copyarea.h

105

if (end <= BITS_PER_LONG) {

drivers/video/fbdev/core/fb_copyarea.h

118

end /= BITS_PER_LONG;

drivers/video/fbdev/core/fb_copyarea.h

170

last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), reverse);

drivers/video/fbdev/core/fb_copyarea.h

173

right = shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/core/fb_copyarea.h

174

left = -shift & (BITS_PER_LONG - 1);

drivers/video/fbdev/core/fb_copyarea.h

176

if (end <= BITS_PER_LONG) {

drivers/video/fbdev/core/fb_copyarea.h

181

if (src->bits + width > BITS_PER_LONG)

drivers/video/fbdev/core/fb_copyarea.h

211

end /= BITS_PER_LONG;

drivers/video/fbdev/core/fb_copyarea.h

245

> offset * BITS_PER_LONG + ((shift < 0) ? BITS_PER_LONG : 0))

drivers/video/fbdev/core/fb_copyarea.h

264

last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), reverse);

drivers/video/fbdev/core/fb_copyarea.h

267

right = shift & (BITS_PER_LONG-1);

drivers/video/fbdev/core/fb_copyarea.h

268

left = -shift & (BITS_PER_LONG-1);

drivers/video/fbdev/core/fb_copyarea.h

270

if (end <= BITS_PER_LONG) {

drivers/video/fbdev/core/fb_copyarea.h

282

if (src->bits + end - dst->bits > BITS_PER_LONG)

drivers/video/fbdev/core/fb_copyarea.h

293

end /= BITS_PER_LONG;

drivers/video/fbdev/core/fb_copyarea.h

57

last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), reverse);

drivers/video/fbdev/core/fb_copyarea.h

60

if (end <= BITS_PER_LONG) {

drivers/video/fbdev/core/fb_copyarea.h

78

end /= BITS_PER_LONG;

drivers/video/fbdev/core/fb_draw.h

105

#if defined(CONFIG_HAVE_ARCH_BITREVERSE) && BITS_PER_LONG == 32

drivers/video/fbdev/core/fb_draw.h

11

#define swab_long _swab_long(BITS_PER_LONG)

drivers/video/fbdev/core/fb_draw.h

18

adr->address += offset * (BITS_PER_LONG / BITS_PER_BYTE);

drivers/video/fbdev/core/fb_draw.h

26

adr->bits = bits & (BITS_PER_LONG - 1u);

drivers/video/fbdev/core/fb_draw.h

27

adr->address += (bits & ~(BITS_PER_LONG - 1u)) / BITS_PER_BYTE;

drivers/video/fbdev/core/fb_draw.h

35

adr->bits = bits & (BITS_PER_LONG - 1);

drivers/video/fbdev/core/fb_fillrect.h

115

last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), pattern->reverse);

drivers/video/fbdev/core/fb_fillrect.h

117

if (end <= BITS_PER_LONG) {

drivers/video/fbdev/core/fb_fillrect.h

131

end /= BITS_PER_LONG;

drivers/video/fbdev/core/fb_fillrect.h

164

last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), pattern->reverse);

drivers/video/fbdev/core/fb_fillrect.h

166

if (end <= BITS_PER_LONG) {

drivers/video/fbdev/core/fb_fillrect.h

179

end /= BITS_PER_LONG;

drivers/video/fbdev/core/fb_fillrect.h

268

pattern.left = BITS_PER_LONG % bpp;

drivers/video/fbdev/core/fb_fillrect.h

66

#define FB_PAT(i) (((1UL<<(BITS_PER_LONG-1)/(i)*(i))/((1<<(i))-1)<<(i))|1)

drivers/video/fbdev/core/fb_fillrect.h

71

static const unsigned long mulconst[BITS_PER_LONG/4] = {

drivers/video/fbdev/core/fb_fillrect.h

74

#if BITS_PER_LONG == 64

drivers/video/fbdev/core/fb_fillrect.h

82

case 0 ... BITS_PER_LONG/4-1:

drivers/video/fbdev/core/fb_fillrect.h

85

case BITS_PER_LONG/4 ... BITS_PER_LONG/2-1:

drivers/video/fbdev/core/fb_fillrect.h

90

case BITS_PER_LONG/2 ... BITS_PER_LONG-1:

drivers/video/fbdev/core/fb_fillrect.h

98

pattern <<= (BITS_PER_LONG % bpp);

drivers/video/fbdev/core/fb_imageblit.h

121

*pixels <<= BITS_PER_LONG - *bits;

drivers/video/fbdev/core/fb_imageblit.h

149

if (shift < BITS_PER_LONG)

drivers/video/fbdev/core/fb_imageblit.h

154

shift &= BITS_PER_LONG - 1;

drivers/video/fbdev/core/fb_imageblit.h

185

iter.shift = BITS_PER_LONG - BITS_PER_BYTE;

drivers/video/fbdev/core/fb_imageblit.h

187

iter.shift = BITS_PER_LONG - bpp;

drivers/video/fbdev/core/fb_imageblit.h

266

iter.colors[0] <<= BITS_PER_LONG - bpp;

drivers/video/fbdev/core/fb_imageblit.h

267

iter.colors[1] <<= BITS_PER_LONG - bpp;

drivers/video/fbdev/core/fb_imageblit.h

347

tab[0] = fb_pack(bgcolor, bgcolor, BITS_PER_LONG/2);

drivers/video/fbdev/core/fb_imageblit.h

348

tab[1] = fb_pack(bgcolor, fgcolor, BITS_PER_LONG/2);

drivers/video/fbdev/core/fb_imageblit.h

349

tab[2] = fb_pack(fgcolor, bgcolor, BITS_PER_LONG/2);

drivers/video/fbdev/core/fb_imageblit.h

350

tab[3] = fb_pack(fgcolor, fgcolor, BITS_PER_LONG/2);

drivers/video/fbdev/core/fb_imageblit.h

383

#define FB_PATP(a, b) (((a)<<((b)*BITS_PER_LONG/4))*((1UL<<BITS_PER_LONG/4)-1UL))

drivers/video/fbdev/core/fb_imageblit.h

410

fgcolor = fgcolor | fgcolor << BITS_PER_LONG/4;

drivers/video/fbdev/core/fb_imageblit.h

411

bgcolor = bgcolor | bgcolor << BITS_PER_LONG/4;

drivers/video/fbdev/core/fb_imageblit.h

412

fgcolor = fgcolor | fgcolor << BITS_PER_LONG/2;

drivers/video/fbdev/core/fb_imageblit.h

413

bgcolor = bgcolor | bgcolor << BITS_PER_LONG/2;

drivers/video/fbdev/core/fb_imageblit.h

416

if (BITS_PER_LONG/4 > BITS_PER_BYTE && reverse.byte) {

drivers/video/fbdev/core/fb_imageblit.h

455

if (!dst->bits && !(bits_per_line & (BITS_PER_LONG-1))) {

drivers/video/fbdev/core/fb_imageblit.h

456

if (bpp == BITS_PER_LONG && BITS_PER_LONG == 32) {

drivers/video/fbdev/core/fb_imageblit.h

458

bits_per_line / BITS_PER_LONG, reverse);

drivers/video/fbdev/core/fb_imageblit.h

461

if (bpp == BITS_PER_LONG/2 && !(image->width & 1)) {

drivers/video/fbdev/core/fb_imageblit.h

463

bits_per_line / BITS_PER_LONG, reverse);

drivers/video/fbdev/core/fb_imageblit.h

466

if (bpp == BITS_PER_LONG/4 && !(image->width & 3)) {

drivers/video/fbdev/core/fb_imageblit.h

468

bits_per_line / BITS_PER_LONG, reverse);

drivers/video/fbdev/core/fb_imageblit.h

476

else if (bpp > BITS_PER_BYTE && bpp <= BITS_PER_LONG)

drivers/video/fbdev/core/fb_info.c

24

#define BYTES_PER_LONG (BITS_PER_LONG/8)

drivers/video/fbdev/core/sysmem.h

20

ptr.address = PTR_ALIGN_DOWN(base, BITS_PER_LONG / BITS_PER_BYTE);

drivers/video/fbdev/via/viafbdev.c

1730

viafb_par_length = ALIGN(sizeof(struct viafb_par), BITS_PER_LONG/8);

drivers/video/fbdev/via/viafbdev.c

1736

ALIGN(sizeof(struct viafb_shared), BITS_PER_LONG/8),

drivers/xen/events/events_2l.c

179

word_idx = evtchn / BITS_PER_LONG;

drivers/xen/events/events_2l.c

180

bit_idx = evtchn % BITS_PER_LONG;

drivers/xen/events/events_fifo.c

72

#if BITS_PER_LONG > 32

drivers/xen/grant-table.c

1034

#if BITS_PER_LONG < 64

drivers/xen/grant-table.c

868

#if BITS_PER_LONG < 64

drivers/xen/time.c

32

if (BITS_PER_LONG < 64) {

drivers/xen/xenbus/xenbus_probe.c

1053

#if BITS_PER_LONG == 32

fs/9p/v9fs_vfs.h

47

#if (BITS_PER_LONG == 32)

fs/btrfs/btrfs_inode.h

131

#if BITS_PER_LONG == 32

fs/btrfs/btrfs_inode.h

368

#if BITS_PER_LONG == 32

fs/btrfs/btrfs_inode.h

375

#if BITS_PER_LONG == 32

fs/btrfs/btrfs_inode.h

409

#if BITS_PER_LONG == 32

fs/btrfs/delayed-ref.c

833

#if BITS_PER_LONG == 32

fs/btrfs/disk-io.c

3415

fs_info->block_max_order = ilog2((BITS_PER_LONG << fs_info->sectorsize_bits) >> PAGE_SHIFT);

fs/btrfs/extent_io.c

3420

#if BITS_PER_LONG == 32

fs/btrfs/fs.h

225

#if BITS_PER_LONG == 32

fs/btrfs/messages.c

247

#if BITS_PER_LONG == 32

fs/btrfs/messages.h

194

#if BITS_PER_LONG == 32

fs/btrfs/qgroup.c

2017

#if BITS_PER_LONG == 32

fs/btrfs/raid56.c

1084

ASSERT(stripe_nsectors <= BITS_PER_LONG);

fs/btrfs/scrub.c

1759

ASSERT(BITS_PER_LONG >= BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

287

ASSERT(nr_blocks > 0 && nr_blocks <= BITS_PER_LONG, \

fs/btrfs/scrub.c

289

nr_blocks, BITS_PER_LONG); \

fs/btrfs/subpage.c

670

ASSERT(__bpf <= BITS_PER_LONG); \

fs/btrfs/ulist.h

62

#if BITS_PER_LONG == 32

fs/btrfs/volumes.c

7278

#if BITS_PER_LONG == 32

fs/btrfs/volumes.c

7361

#if BITS_PER_LONG == 32

fs/btrfs/volumes.h

247

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

fs/btrfs/volumes.h

271

#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)

fs/btrfs/volumes.h

96

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

fs/ceph/mds_client.c

569

#if BITS_PER_LONG == 64

fs/erofs/decompressor.c

58

BITS_PER_LONG)] = { 0 };

fs/erofs/internal.h

264

#define EROFS_I_BL_XATTR_BIT (BITS_PER_LONG - 1)

fs/erofs/internal.h

265

#define EROFS_I_BL_Z_BIT (BITS_PER_LONG - 2)

fs/exfat/balloc.c

15

#if BITS_PER_LONG == 32

fs/exfat/balloc.c

19

#elif BITS_PER_LONG == 64

fs/exfat/balloc.c

261

ent_idx = ALIGN_DOWN(CLUSTER_TO_BITMAP_ENT(clu), BITS_PER_LONG);

fs/exfat/balloc.c

269

i += BITS_PER_LONG) {

fs/exfat/balloc.c

281

clu_base += BITS_PER_LONG;

fs/exfat/balloc.c

303

unsigned int last_mask = total_clus & (BITS_PER_LONG - 1);

fs/exfat/balloc.c

307

for (i = 0; i < total_clus; i += BITS_PER_LONG) {

fs/exfat/balloc.c

52

bit_offset = b % BITS_PER_LONG;

fs/exfat/balloc.c

54

(unsigned int)(BITS_PER_LONG - bit_offset));

fs/exfat/balloc.c

57

if (bits_to_check >= BITS_PER_LONG)

fs/exfat/balloc.c

61

word = lel_to_cpu(bitmap_le[b / BITS_PER_LONG]);

fs/ext4/dir.c

333

return (BITS_PER_LONG == 32);

fs/ext4/ext4.h

1045

#if (BITS_PER_LONG < 64)

fs/ext4/ext4.h

2006

#if (BITS_PER_LONG < 64)

fs/ext4/fast_commit.c

1078

#if (BITS_PER_LONG < 64)

fs/ext4/fast_commit.c

1334

#if (BITS_PER_LONG < 64)

fs/ext4/fast_commit.c

265

#if (BITS_PER_LONG < 64)

fs/ext4/fast_commit.c

580

#if (BITS_PER_LONG < 64)

fs/ext4/mballoc.c

466

#if BITS_PER_LONG == 64

fs/ext4/mballoc.c

469

#elif BITS_PER_LONG == 32

fs/f2fs/segment.c

108

size -= (offset & ~(BITS_PER_LONG - 1));

fs/f2fs/segment.c

109

offset %= BITS_PER_LONG;

fs/f2fs/segment.c

118

if (size < BITS_PER_LONG)

fs/f2fs/segment.c

119

tmp &= (~0UL << (BITS_PER_LONG - size));

fs/f2fs/segment.c

123

if (size <= BITS_PER_LONG)

fs/f2fs/segment.c

125

size -= BITS_PER_LONG;

fs/f2fs/segment.c

144

size -= (offset & ~(BITS_PER_LONG - 1));

fs/f2fs/segment.c

145

offset %= BITS_PER_LONG;

fs/f2fs/segment.c

154

tmp |= ~0UL << (BITS_PER_LONG - offset);

fs/f2fs/segment.c

155

if (size < BITS_PER_LONG)

fs/f2fs/segment.c

160

if (size <= BITS_PER_LONG)

fs/f2fs/segment.c

162

size -= BITS_PER_LONG;

fs/f2fs/segment.c

40

#if BITS_PER_LONG == 64

fs/f2fs/segment.c

58

#if BITS_PER_LONG == 64

fs/fat/fat.h

266

#if BITS_PER_LONG == 32

fs/fat/fat.h

270

#if BITS_PER_LONG == 32

fs/fcntl.c

479

#if BITS_PER_LONG != 32

fs/fcntl.c

490

#if BITS_PER_LONG != 32

fs/fcntl.c

607

#if BITS_PER_LONG == 32

fs/file.c

101

__const_min(INT_MAX, ~(size_t)0/sizeof(void *)) & -BITS_PER_LONG;

fs/file.c

118

#define fdt_words(fdt) ((fdt)->max_fds / BITS_PER_LONG) // words in ->open_fds

fs/file.c

130

copy_words * BITS_PER_LONG, nwords * BITS_PER_LONG);

fs/file.c

132

copy_words * BITS_PER_LONG, nwords * BITS_PER_LONG);

fs/file.c

195

nr = round_down(sysctl_nr_open, BITS_PER_LONG);

fs/file.c

337

fd /= BITS_PER_LONG;

fs/file.c

345

fd /= BITS_PER_LONG;

fs/file.c

375

return ALIGN(last + 1, BITS_PER_LONG);

fs/file.c

436

copy_fd_bitmaps(new_fdt, old_fdt, open_files / BITS_PER_LONG);

fs/file.c

486

i = j * BITS_PER_LONG;

fs/file.c

547

unsigned int maxbit = maxfd / BITS_PER_LONG;

fs/file.c

548

unsigned int bitbit = start / BITS_PER_LONG;

fs/file.c

554

bit = find_next_zero_bit(&fdt->open_fds[bitbit], BITS_PER_LONG,

fs/file.c

555

start & (BITS_PER_LONG - 1));

fs/file.c

556

if (bit < BITS_PER_LONG)

fs/file.c

557

return bit + bitbit * BITS_PER_LONG;

fs/file.c

559

bitbit = find_next_zero_bit(fdt->full_fds_bits, maxbit, bitbit) * BITS_PER_LONG;

fs/file.c

900

unsigned fd = i * BITS_PER_LONG;

fs/file.c

97

unsigned int sysctl_nr_open_min = BITS_PER_LONG;

fs/fuse/ioctl.c

238

#if BITS_PER_LONG == 32

fs/fuse/ioctl.c

451

#if BITS_PER_LONG == 32

fs/gfs2/glock.c

1311

max_shift = BITS_PER_LONG - 2 - __fls(GL_GLOCK_HOLD_INCR);

fs/hugetlbfs/inode.c

97

(((1UL << (PAGE_SHIFT + 1)) - 1) << (BITS_PER_LONG - (PAGE_SHIFT + 1)))

fs/locks.c

2322

#if BITS_PER_LONG == 32

fs/locks.c

2340

#if BITS_PER_LONG == 32

fs/locks.c

2559

#if BITS_PER_LONG == 32

fs/namei.c

2502

#define LAST_WORD_IS_DOT (0x2eul << (BITS_PER_LONG-8))

fs/namei.c

2503

#define LAST_WORD_IS_DOTDOT (0x2e2eul << (BITS_PER_LONG-16))

fs/nfs/dir.c

467

return (BITS_PER_LONG == 32);

fs/nfs/nfs4session.h

38

#define SLOT_TABLE_SZ DIV_ROUND_UP(NFS4_MAX_SLOT_TABLE, BITS_PER_LONG)

fs/nilfs2/alloc.c

43

return 1UL << (BITS_PER_LONG - (inode->i_blkbits + 3 /* log2(8) */));

fs/nilfs2/bmap.h

90

#define NILFS_BMAP_KEY_BIT BITS_PER_LONG

fs/nilfs2/bmap.h

91

#define NILFS_BMAP_NEW_PTR_INIT (1UL << (BITS_PER_LONG - 1))

fs/ntfs3/bitmap.c

1499

#if BITS_PER_LONG == 64

fs/ntfs3/bitmap.c

1513

int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);

fs/ntfs3/bitmap.c

1519

bits_to_set = BITS_PER_LONG;

fs/ntfs3/bitmap.c

1533

int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);

fs/ntfs3/bitmap.c

1539

bits_to_clear = BITS_PER_LONG;

fs/ntfs3/bitmap.c

1552

unsigned int k, lim = bits / BITS_PER_LONG;

fs/ntfs3/bitmap.c

1558

if (bits % BITS_PER_LONG) {

fs/ntfs3/super.c

1161

#elif BITS_PER_LONG < 64

fs/ocfs2/cluster/masklog.h

111

unsigned long words[MLOG_MAX_BITS / BITS_PER_LONG];

fs/ocfs2/cluster/masklog.h

116

#if BITS_PER_LONG == 32

fs/ocfs2/ocfs2.h

948

#if BITS_PER_LONG == 64

fs/ocfs2/ocfs2.h

951

#elif BITS_PER_LONG == 32

fs/ocfs2/super.c

583

#if BITS_PER_LONG == 32

fs/open.c

224

#if BITS_PER_LONG == 32

fs/orangefs/orangefs-bufmap.c

161

#define N DIV_ROUND_UP(ORANGEFS_READDIR_DEFAULT_DESC_COUNT, BITS_PER_LONG)

fs/overlayfs/super.c

1420

ofs->xino_mode = BITS_PER_LONG - 32;

fs/pidfs.c

97

#if BITS_PER_LONG == 32

fs/proc/task_mmu.c

1147

static const char mnemonics[BITS_PER_LONG][3] = {

fs/proc/task_mmu.c

1151

[0 ... (BITS_PER_LONG-1)] = "??",

fs/proc/task_mmu.c

1222

for (i = 0; i < BITS_PER_LONG; i++) {

fs/read_write.c

1118

#define HALF_LONG_BITS (BITS_PER_LONG / 2)

fs/select.c

425

set = ~(~0UL << (n & (BITS_PER_LONG-1)));

fs/select.c

426

n /= BITS_PER_LONG;

fs/select.c

453

max += n * BITS_PER_LONG;

fs/select.c

527

i += BITS_PER_LONG;

fs/select.c

531

for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {

fs/smb/server/vfs_cache.h

125

#define KSMBD_NR_OPEN_DEFAULT BITS_PER_LONG

fs/stat.c

409

#if BITS_PER_LONG == 32

fs/stat.c

474

#if BITS_PER_LONG == 32

fs/xfs/xfs_handle.c

255

#if BITS_PER_LONG != 32

fs/xfs/xfs_trans_priv.h

146

#if BITS_PER_LONG != 64

include/acpi/platform/aclinux.h

107

#define ACPI_MACHINE_WIDTH BITS_PER_LONG

include/asm-generic/bitops/__ffs.h

17

#if BITS_PER_LONG == 64

include/asm-generic/bitops/__fls.h

15

unsigned int num = BITS_PER_LONG - 1;

include/asm-generic/bitops/__fls.h

17

#if BITS_PER_LONG == 64

include/asm-generic/bitops/__fls.h

23

if (!(word & (~0ul << (BITS_PER_LONG-16)))) {

include/asm-generic/bitops/__fls.h

27

if (!(word & (~0ul << (BITS_PER_LONG-8)))) {

include/asm-generic/bitops/__fls.h

31

if (!(word & (~0ul << (BITS_PER_LONG-4)))) {

include/asm-generic/bitops/__fls.h

35

if (!(word & (~0ul << (BITS_PER_LONG-2)))) {

include/asm-generic/bitops/__fls.h

39

if (!(word & (~0ul << (BITS_PER_LONG-1))))

include/asm-generic/bitops/fls64.h

18

#if BITS_PER_LONG == 32

include/asm-generic/bitops/fls64.h

26

#elif BITS_PER_LONG == 64

include/asm-generic/bitops/generic-non-atomic.h

128

return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));

include/asm-generic/bitops/generic-non-atomic.h

140

return 1UL & (smp_load_acquire(p) >> (nr & (BITS_PER_LONG-1)));

include/asm-generic/bitops/le.h

14

#define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7)

include/asm-generic/bitops/sched.h

15

#if BITS_PER_LONG == 64

include/asm-generic/bitops/sched.h

19

#elif BITS_PER_LONG == 32

include/asm-generic/bitsperlong.h

18

#if 0 && BITS_PER_LONG != __BITS_PER_LONG

include/asm-generic/bitsperlong.h

36

(__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG && (nbits) > 0)

include/asm-generic/div64.h

29

#if BITS_PER_LONG == 64

include/asm-generic/div64.h

53

#elif BITS_PER_LONG == 32

include/asm-generic/fprobe.h

18

#define FPROBE_HEADER_MSB_SIZE_SHIFT (BITS_PER_LONG - FPROBE_DATA_SIZE_BITS)

include/asm-generic/fprobe.h

28

GENMASK(BITS_PER_LONG - 1, FPROBE_HEADER_MSB_SIZE_SHIFT)

include/asm-generic/getorder.h

33

return BITS_PER_LONG - PAGE_SHIFT;

include/asm-generic/getorder.h

43

#if BITS_PER_LONG == 32

include/asm-generic/local64.h

20

#if BITS_PER_LONG == 64

include/drm/drm_vma_manager.h

36

#if BITS_PER_LONG == 64

include/linux/assoc_array.h

17

#define ASSOC_ARRAY_KEY_CHUNK_SIZE BITS_PER_LONG /* Key data retrieved in chunks of this size */

include/linux/assoc_array_priv.h

22

#define ASSOC_ARRAY_KEY_CHUNK_SHIFT (ilog2(BITS_PER_LONG))

include/linux/bitmap.h

229

#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))

include/linux/bitmap.h

230

#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))

include/linux/bitmap.h

232

#define bitmap_size(nbits) (ALIGN(nbits, BITS_PER_LONG) / BITS_PER_BYTE)

include/linux/bitmap.h

272

if (nbits % BITS_PER_LONG)

include/linux/bitmap.h

273

dst[nbits / BITS_PER_LONG] &= BITMAP_LAST_WORD_MASK(nbits);

include/linux/bitmap.h

283

if (count % BITS_PER_LONG)

include/linux/bitmap.h

296

#if BITS_PER_LONG == 64

include/linux/bitmap.h

314

#if BITS_PER_LONG == 32

include/linux/bitmap.h

785

unsigned long offset = start % BITS_PER_LONG;

include/linux/bitmap.h

786

unsigned long space = BITS_PER_LONG - offset;

include/linux/bitmap.h

789

if (unlikely(!nbits || nbits > BITS_PER_LONG))

include/linux/bitmap.h

825

if (unlikely(!nbits || nbits > BITS_PER_LONG))

include/linux/bitmap.h

830

offset = start % BITS_PER_LONG;

include/linux/bitmap.h

831

space = BITS_PER_LONG - offset;

include/linux/bitops.h

272

#if BITS_PER_LONG == 32

include/linux/bitops.h

275

#elif BITS_PER_LONG != 64

include/linux/bitops.h

291

return word ? __ffs(word) : BITS_PER_LONG;

include/linux/bits.h

8

#define BIT_MASK(nr) (UL(1) << ((nr) % BITS_PER_LONG))

include/linux/bits.h

9

#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)

include/linux/btree-type.h

37

#if (BITS_PER_LONG > BTREE_TYPE_BITS)

include/linux/btree.h

211

#define BTREE_TYPE_BITS BITS_PER_LONG

include/linux/count_zeros.h

26

return BITS_PER_LONG - fls(x);

include/linux/count_zeros.h

28

return BITS_PER_LONG - fls64(x);

include/linux/count_zeros.h

31

#define COUNT_LEADING_ZEROS_0 BITS_PER_LONG

include/linux/cpufreq.h

567

#if BITS_PER_LONG == 32

include/linux/cpufreq.h

572

#elif BITS_PER_LONG == 64

include/linux/cpumask.h

1195

cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)];

include/linux/cpumask.h

1199

const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG];

include/linux/cpumask.h

1200

p -= cpu / BITS_PER_LONG;

include/linux/cpumask.h

1301

#if NR_CPUS <= BITS_PER_LONG

include/linux/cpumask.h

1379

#if NR_CPUS <= BITS_PER_LONG

include/linux/cpumask.h

68

#if NR_CPUS <= BITS_PER_LONG

include/linux/cpumask.h

71

#elif NR_CPUS <= 4*BITS_PER_LONG

include/linux/dynamic_queue_limits.h

103

if (now_hi * BITS_PER_LONG ==

include/linux/dynamic_queue_limits.h

104

(dql->history_head + i) * BITS_PER_LONG)

include/linux/dynamic_queue_limits.h

93

now_hi = now / BITS_PER_LONG;

include/linux/efi.h

33

#define EFI_LOAD_ERROR ( 1 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

34

#define EFI_INVALID_PARAMETER ( 2 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

35

#define EFI_UNSUPPORTED ( 3 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

36

#define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

37

#define EFI_BUFFER_TOO_SMALL ( 5 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

38

#define EFI_NOT_READY ( 6 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

39

#define EFI_DEVICE_ERROR ( 7 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

40

#define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

41

#define EFI_OUT_OF_RESOURCES ( 9 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

42

#define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

43

#define EFI_ACCESS_DENIED (15 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

44

#define EFI_TIMEOUT (18 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

45

#define EFI_ABORTED (21 | (1UL << (BITS_PER_LONG-1)))

include/linux/efi.h

46

#define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG-1)))

include/linux/etherdevice.h

146

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/linux/etherdevice.h

384

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/linux/etherdevice.h

571

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/linux/fcntl.h

28

#if BITS_PER_LONG == 32

include/linux/fdtable.h

24

#define NR_OPEN_DEFAULT BITS_PER_LONG

include/linux/filelock.h

155

#if BITS_PER_LONG == 32

include/linux/filelock.h

268

#if BITS_PER_LONG == 32

include/linux/filter.h

636

#if BITS_PER_LONG == 64

include/linux/folio_queue.h

37

#if PAGEVEC_SIZE > BITS_PER_LONG

include/linux/fs.h

1129

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

include/linux/fs.h

1138

#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)

include/linux/fs.h

1158

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

include/linux/fs.h

1164

#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)

include/linux/fs.h

1324

#if BITS_PER_LONG==32

include/linux/fs.h

1326

#elif BITS_PER_LONG==64

include/linux/fs.h

597

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

include/linux/generic-radix-tree.h

57

DIV_ROUND_UP(BITS_PER_LONG - GENRADIX_NODE_SHIFT, GENRADIX_ARY_SHIFT)

include/linux/gfp.h

124

#if 16 * GFP_ZONES_SHIFT > BITS_PER_LONG

include/linux/hash.h

14

#if BITS_PER_LONG == 32

include/linux/hash.h

17

#elif BITS_PER_LONG == 64

include/linux/hash.h

76

#if BITS_PER_LONG == 64

include/linux/hash.h

95

#if BITS_PER_LONG == 64

include/linux/hmm.h

40

HMM_PFN_VALID = 1UL << (BITS_PER_LONG - 1),

include/linux/hmm.h

41

HMM_PFN_WRITE = 1UL << (BITS_PER_LONG - 2),

include/linux/hmm.h

42

HMM_PFN_ERROR = 1UL << (BITS_PER_LONG - 3),

include/linux/hmm.h

47

HMM_PFN_DMA_MAPPED = 1UL << (BITS_PER_LONG - 4),

include/linux/hmm.h

48

HMM_PFN_P2PDMA = 1UL << (BITS_PER_LONG - 5),

include/linux/hmm.h

49

HMM_PFN_P2PDMA_BUS = 1UL << (BITS_PER_LONG - 6),

include/linux/hmm.h

51

HMM_PFN_ORDER_SHIFT = (BITS_PER_LONG - 11),

include/linux/hugetlb.h

764

if (page_size_log < BITS_PER_LONG)

include/linux/i3c/master.h

368

unsigned long addrslots[((I2C_MAX_ADDR + 1) * I3C_ADDR_SLOT_STATUS_BITS) / BITS_PER_LONG];

include/linux/jiffies.h

425

#if BITS_PER_LONG < 64

include/linux/jiffies.h

88

#if (BITS_PER_LONG < 64)

include/linux/joystick.h

14

#if BITS_PER_LONG == 64

include/linux/joystick.h

16

#elif BITS_PER_LONG == 32

include/linux/kallsyms.h

21

2*(BITS_PER_LONG*3/10) + (MODULE_NAME_LEN - 1) + \

include/linux/ktime.h

126

#if BITS_PER_LONG < 64

include/linux/kvm_host.h

630

return ALIGN(memslot->npages, BITS_PER_LONG) / 8;

include/linux/math.h

218

#if BITS_PER_LONG < 64

include/linux/math.h

57

#if BITS_PER_LONG == 32

include/linux/math64.h

10

#if BITS_PER_LONG == 64

include/linux/math64.h

84

#elif BITS_PER_LONG == 32

include/linux/memcontrol.h

1597

#if BITS_PER_LONG < 64

include/linux/memcontrol.h

256

#if BITS_PER_LONG < 64

include/linux/mlx4/doorbell.h

44

#if BITS_PER_LONG == 64

include/linux/mlx5/doorbell.h

52

#if BITS_PER_LONG == 64

include/linux/mm.h

145

#if BITS_PER_LONG == 64

include/linux/mm.h

2090

pid_bit = hash_32(current->pid, ilog2(BITS_PER_LONG));

include/linux/mm.h

949

if (NUM_VMA_FLAG_BITS > BITS_PER_LONG) {

include/linux/mm.h

952

bitmap_zero(&bitmap[1], NUM_VMA_FLAG_BITS - BITS_PER_LONG);

include/linux/mm_types.h

866

#define NUM_VMA_FLAG_BITS BITS_PER_LONG

include/linux/mm_types_task.h

20

#define ALLOC_SPLIT_PTLOCKS (SPINLOCK_SIZE > BITS_PER_LONG/8)

include/linux/mm_types_task.h

38

#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)

include/linux/mm_types_task.h

58

#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) && (BITS_PER_LONG <= 32)

include/linux/mmzone.h

468

#define MIN_LRU_BATCH BITS_PER_LONG

include/linux/mod_devicetable.h

371

kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

372

kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

373

kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

374

kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

375

kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

376

kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

377

kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

378

kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

379

kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];

include/linux/mod_devicetable.h

380

kernel_ulong_t propbit[INPUT_DEVICE_ID_PROP_MAX / BITS_PER_LONG + 1];

include/linux/mpi.h

23

#define BYTES_PER_MPI_LIMB (BITS_PER_LONG / 8)

include/linux/mpi.h

24

#define BITS_PER_MPI_LIMB BITS_PER_LONG

include/linux/mtd/map.h

116

# define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)

include/linux/mtd/map.h

168

#define MAX_MAP_LONGS (((MAX_MAP_BANKWIDTH * 8) + BITS_PER_LONG - 1) / BITS_PER_LONG)

include/linux/mtd/map.h

333

#if BITS_PER_LONG >= 64

include/linux/mtd/map.h

369

#if BITS_PER_LONG < 64

include/linux/mtd/map.h

401

#if BITS_PER_LONG >= 64

include/linux/mtd/map.h

421

#if BITS_PER_LONG >= 64

include/linux/mtd/map.h

73

# if BITS_PER_LONG < 64

include/linux/mtd/map.h

75

# define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)

include/linux/mtd/map.h

81

# define map_bankwidth_is_large(map) (BITS_PER_LONG < 64)

include/linux/mtd/map.h

96

# define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)

include/linux/netfilter.h

38

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/linux/netfilter.h

55

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/linux/nodemask.h

301

#if MAX_NUMNODES <= BITS_PER_LONG

include/linux/nospec.h

37

return ~(long)(index | (size - 1UL - index)) >> (BITS_PER_LONG - 1);

include/linux/page-flags-layout.h

107

KASAN_TAG_WIDTH + LAST_CPUPID_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS

include/linux/page-flags-layout.h

112

#define LRU_REFS_WIDTH min(__LRU_REFS_WIDTH, BITS_PER_LONG - NR_PAGEFLAGS - \

include/linux/page-flags-layout.h

120

#define NR_UNUSED_PAGEFLAG_BITS (BITS_PER_LONG - \

include/linux/page-flags-layout.h

59

<= BITS_PER_LONG - NR_PAGEFLAGS

include/linux/page-flags-layout.h

96

KASAN_TAG_WIDTH + LAST_CPUPID_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS

include/linux/page_counter.h

46

#if BITS_PER_LONG == 32

include/linux/percpu.h

69

#if BITS_PER_LONG > 32

include/linux/random.h

46

#if BITS_PER_LONG == 64

include/linux/sbitmap.h

343

int shift = ilog2(BITS_PER_LONG);

include/linux/shrinker.h

10

#define SHRINKER_UNIT_BITS BITS_PER_LONG

include/linux/signal.h

410

#if SIGRTMIN > BITS_PER_LONG

include/linux/skbuff.h

4527

BITS_PER_LONG != 64)

include/linux/skbuff.h

718

#if BITS_PER_LONG > 32

include/linux/string.h

238

if (BITS_PER_LONG == 32)

include/linux/string.h

246

if (BITS_PER_LONG == 32)

include/linux/syscalls.h

398

#if BITS_PER_LONG == 32

include/linux/syscalls.h

445

#if BITS_PER_LONG == 32

include/linux/trace_events.h

30

#if BITS_PER_LONG == 32

include/linux/u64_stats_sync.h

65

#if BITS_PER_LONG == 32

include/linux/u64_stats_sync.h

70

#if BITS_PER_LONG == 64

include/linux/wordpart.h

54

# define aligned_byte_mask(n) (~0xffUL << (BITS_PER_LONG - 8 - 8*(n)))

include/linux/workqueue.h

72

WORK_OFFQ_LEFT = BITS_PER_LONG - WORK_OFFQ_POOL_SHIFT,

include/linux/xarray.h

1677

xas->xa_index = order < BITS_PER_LONG ? (index >> order) << order : 0;

include/linux/xarray.h

1750

if (XA_CHUNK_SIZE == BITS_PER_LONG) {

include/linux/xarray.h

49

#define BITS_PER_XA_VALUE (BITS_PER_LONG - 1)

include/linux/xxhash.h

126

#if BITS_PER_LONG == 64

include/net/addrconf.h

495

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/addrconf.h

507

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/addrconf.h

524

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/addrconf.h

539

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/flow.h

155

} __attribute__((__aligned__(BITS_PER_LONG/8)));

include/net/flow.h

174

} __attribute__((__aligned__(BITS_PER_LONG/8)));

include/net/flow.h

94

} __attribute__((__aligned__(BITS_PER_LONG/8)));

include/net/ip.h

311

#if BITS_PER_LONG==32

include/net/ipv6.h

511

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

558

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

586

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

599

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

648

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

660

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

680

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

697

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

786

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/ipv6.h

806

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

include/net/netfilter/nf_flow_table.h

39

} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */

include/net/netfilter/nf_tables.h

1632

#define NFT_SET_ELEM_DEAD_BIT (BITS_PER_LONG - BITS_PER_BYTE + 2)

include/net/netfilter/nf_tables.h

752

} __aligned(BITS_PER_LONG / 8);

include/net/netfilter/nf_tables_offload.h

56

} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */

include/net/sctp/constants.h

250

#define SCTP_TSN_MAP_INITIAL BITS_PER_LONG

include/net/snmp.h

153

#if BITS_PER_LONG==32

include/net/sock.h

2794

#if BITS_PER_LONG==32

include/net/sock.h

2811

#if BITS_PER_LONG==32

include/net/sock.h

547

#if BITS_PER_LONG==32

include/net/udp.h

469

#if BITS_PER_LONG == 64

include/net/udp.h

486

#if BITS_PER_LONG == 64

include/trace/events/napi.h

60

__entry->hist_head = hist_head * BITS_PER_LONG;

include/trace/stages/stage3_trace_output.h

84

#if BITS_PER_LONG == 32

include/trace/stages/stage5_get_offsets.h

107

(__bitmask_size_in_longs(nr_bits) * (BITS_PER_LONG / 8))

include/trace/stages/stage5_get_offsets.h

99

((BITS_PER_LONG / 8) - 1)) / (BITS_PER_LONG / 8))

include/xen/grant_table.h

287

#if BITS_PER_LONG < 64

include/xen/grant_table.h

290

BUILD_BUG_ON(sizeof(struct xen_page_foreign) > BITS_PER_LONG);

io_uring/io-wq.c

72

#if BITS_PER_LONG == 64

ipc/sem.c

2014

unsigned long mask = 1ULL << ((sop->sem_num) % BITS_PER_LONG);

ipc/shm.c

161

#if BITS_PER_LONG <= 32

ipc/shm.c

1851

#if BITS_PER_LONG <= 32

kernel/bpf/bloom_filter.c

137

if (nr_bits <= BITS_PER_LONG)

kernel/bpf/bloom_filter.c

138

nr_bits = BITS_PER_LONG;

kernel/bpf/hashtab.c

1070

return is_fd_htab(htab) && BITS_PER_LONG == 64;

kernel/bpf/helpers.c

3254

#if (BITS_PER_LONG == 32) && defined(__BIG_ENDIAN)

kernel/bpf/verifier.c

23918

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

24014

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

24191

prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

24246

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

8176

if (BPF_SIZE(insn->code) == BPF_DW && BITS_PER_LONG != 64) {

kernel/bpf/verifier.c

8183

if (BPF_SIZE(insn->code) == BPF_DW && BITS_PER_LONG != 64) {

kernel/cpu.c

3067

const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {

kernel/cpu.c

3071

#if BITS_PER_LONG > 32

kernel/debug/kdb/kdb_private.h

40

#if BITS_PER_LONG == 32

kernel/debug/kdb/kdb_private.h

52

#elif BITS_PER_LONG == 64

kernel/gcov/gcov.h

32

#if BITS_PER_LONG >= 64

kernel/kcsan/encoding.h

43

#define WATCHPOINT_ADDR_BITS (BITS_PER_LONG-1 - WATCHPOINT_SIZE_BITS)

kernel/kcsan/encoding.h

46

#define WATCHPOINT_WRITE_MASK BIT(BITS_PER_LONG-1)

kernel/kcsan/encoding.h

47

#define WATCHPOINT_SIZE_MASK GENMASK(BITS_PER_LONG-2, WATCHPOINT_ADDR_BITS)

kernel/locking/rwsem.c

121

#define RWSEM_FLAG_READFAIL (1UL << (BITS_PER_LONG - 1))

kernel/module/internal.h

28

#define SH_ENTSIZE_TYPE_SHIFT (BITS_PER_LONG - SH_ENTSIZE_TYPE_BITS)

kernel/module/internal.h

30

#define SH_ENTSIZE_OFFSET_MASK ((1UL << (BITS_PER_LONG - SH_ENTSIZE_TYPE_BITS)) - 1)

kernel/module/sysfs.c

27

#define MODULE_SECT_READ_SIZE (3 /* "0x", "\n" */ + (BITS_PER_LONG / 4))

kernel/power/snapshot.c

2191

#define ENCODED_PFN_ZERO_FLAG ((unsigned long)1 << (BITS_PER_LONG - 1))

kernel/power/snapshot.c

424

#if BITS_PER_LONG == 32

kernel/printk/printk_ringbuffer.h

131

#define DESC_SV_BITS BITS_PER_LONG

kernel/profile.c

64

prof_shift = clamp(par, 0, BITS_PER_LONG - 1);

kernel/profile.c

74

prof_shift = clamp(par, 0, BITS_PER_LONG - 1);

kernel/rcu/rcu.h

435

((rnp)->grplo + find_next_bit(&(mask), BITS_PER_LONG, (cpu)))

kernel/rcu/tree.c

4809

if (rcu_fanout_leaf < 2 || rcu_fanout_leaf > BITS_PER_LONG) {

kernel/sched/clock.c

333

#if BITS_PER_LONG != 64

kernel/sched/fair.c

240

if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))

kernel/sched/fair.c

3333

if (test_bit(hash_32(current->pid, ilog2(BITS_PER_LONG)), &pids))

kernel/sched/sched.h

1084

unsigned long tasks : BITS_PER_LONG - bits_per(SCHED_CAPACITY_SCALE);

kernel/sched/wait_bit.c

17

const int shift = BITS_PER_LONG == 32 ? 5 : 6;

kernel/sys.c

1675

#if BITS_PER_LONG < 64

kernel/time/hrtimer.c

320

#if BITS_PER_LONG < 64

kernel/time/itimer.c

300

#if BITS_PER_LONG < 64

kernel/time/jiffies.c

47

#if (BITS_PER_LONG < 64)

kernel/time/sched_clock.c

258

sched_clock_register(jiffy_sched_clock_read, BITS_PER_LONG, HZ);

kernel/time/time.c

380

# if BITS_PER_LONG == 32

kernel/time/time.c

406

#if BITS_PER_LONG == 32

kernel/time/timekeeping.c

2647

if ((txc->modes & ADJ_FREQUENCY) && (BITS_PER_LONG == 64)) {

kernel/time/timekeeping.c

2828

for_each_set_bit(id, &active, BITS_PER_LONG) {

kernel/time/timekeeping.c

2848

for_each_set_bit(id, &active, BITS_PER_LONG) {

kernel/trace/pid_list.h

51

#define LOWER_SIZE (LOWER_MAX / BITS_PER_LONG)

kernel/trace/trace_events_user.c

2419

#if BITS_PER_LONG >= 64

kernel/trace/trace_events_user.c

904

#if BITS_PER_LONG >= 64

kernel/trace/trace_output.c

132

#if BITS_PER_LONG == 32

kernel/trace/trace_probe.h

183

#define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)

kernel/trace/trace_probe.h

188

#define ADDR_FETCH_TYPE _ADDR_FETCH_TYPE(BITS_PER_LONG)

lib/bitmap.c

111

upper <<= (BITS_PER_LONG - rem);

lib/bitmap.c

142

unsigned int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;

lib/bitmap.c

151

lower = src[k - 1] >> (BITS_PER_LONG - rem);

lib/bitmap.c

206

if (first % BITS_PER_LONG) {

lib/bitmap.c

207

keep = src[first / BITS_PER_LONG] &

lib/bitmap.c

208

(~0UL >> (BITS_PER_LONG - first % BITS_PER_LONG));

lib/bitmap.c

214

for (i = first / BITS_PER_LONG; i < len; i++) {

lib/bitmap.c

220

dst[i] = (dst[i] >> 1) | (carry << (BITS_PER_LONG - 1));

lib/bitmap.c

224

dst[first / BITS_PER_LONG] &= ~0UL << (first % BITS_PER_LONG);

lib/bitmap.c

225

dst[first / BITS_PER_LONG] |= keep;

lib/bitmap.c

233

unsigned int lim = bits/BITS_PER_LONG;

lib/bitmap.c

238

if (bits % BITS_PER_LONG)

lib/bitmap.c

271

unsigned int lim = bits/BITS_PER_LONG;

lib/bitmap.c

276

if (bits % BITS_PER_LONG)

lib/bitmap.c

298

unsigned int k, lim = bits/BITS_PER_LONG;

lib/bitmap.c

303

if (bits % BITS_PER_LONG)

lib/bitmap.c

313

unsigned int k, lim = bits/BITS_PER_LONG;

lib/bitmap.c

318

if (bits % BITS_PER_LONG)

lib/bitmap.c

329

for (idx = 0; idx < __bits / BITS_PER_LONG; idx++) \

lib/bitmap.c

332

if (__bits % BITS_PER_LONG) \

lib/bitmap.c

368

int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);

lib/bitmap.c

374

bits_to_set = BITS_PER_LONG;

lib/bitmap.c

389

int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);

lib/bitmap.c

395

bits_to_clear = BITS_PER_LONG;

lib/bitmap.c

40

unsigned int k, lim = bits/BITS_PER_LONG;

lib/bitmap.c

45

if (bits % BITS_PER_LONG)

lib/bitmap.c

58

unsigned int k, lim = bits / BITS_PER_LONG;

lib/bitmap.c

66

if (!(bits % BITS_PER_LONG))

lib/bitmap.c

787

#if BITS_PER_LONG == 64

lib/bitmap.c

806

if (nbits % BITS_PER_LONG)

lib/bitmap.c

829

if (nbits % BITS_PER_LONG)

lib/bitmap.c

835

#if BITS_PER_LONG == 32

lib/bitmap.c

861

if (nbits % BITS_PER_LONG)

lib/bitmap.c

96

unsigned off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;

lib/btree.c

61

#define LONG_PER_U64 (64 / BITS_PER_LONG)

lib/crc/riscv/crc-clmul-template.h

169

msgpoly = (unsigned long)p[0] << (BITS_PER_LONG - 8);

lib/crc/riscv/crc-clmul-template.h

171

msgpoly = (msgpoly >> 8) ^ ((unsigned long)p[i] << (BITS_PER_LONG - 8));

lib/crc/riscv/crc-clmul-template.h

180

msgpoly ^= (unsigned long)crc << (BITS_PER_LONG - 8*len);

lib/crc/riscv/crc-clmul-template.h

187

msgpoly ^= (unsigned long)crc << (BITS_PER_LONG - 8*len);

lib/crc/riscv/crc-clmul-template.h

82

return msgpoly ^ ((unsigned long)crc << (BITS_PER_LONG - CRC_BITS));

lib/crypto/mpi/mpicoder.c

378

nbits -= count_leading_zeros(*buff) - (BITS_PER_LONG - 8);

lib/crypto/mpi/mpicoder.c

55

nbits -= count_leading_zeros(buffer[0]) - (BITS_PER_LONG - 8);

lib/dynamic_queue_limits.c

204

dql->history_head = jiffies / BITS_PER_LONG;

lib/dynamic_queue_limits.c

42

start = (hist_head - DQL_HIST_LEN + 1) * BITS_PER_LONG;

lib/dynamic_queue_limits.c

49

end = hist_head * BITS_PER_LONG + (BITS_PER_LONG - 1);

lib/dynamic_queue_limits.c

59

if (test_bit(t % (DQL_HIST_LEN * BITS_PER_LONG),

lib/find_bit.c

232

unsigned long idx = (size-1) / BITS_PER_LONG;

lib/find_bit.c

237

return idx * BITS_PER_LONG + __fls(val);

lib/find_bit.c

33

for (idx = 0; idx * BITS_PER_LONG < sz; idx++) { \

lib/find_bit.c

36

sz = min(idx * BITS_PER_LONG + __ffs(MUNGE(val)), sz); \

lib/find_bit.c

59

idx = __start / BITS_PER_LONG; \

lib/find_bit.c

62

if ((idx + 1) * BITS_PER_LONG >= sz) \

lib/find_bit.c

67

sz = min(idx * BITS_PER_LONG + __ffs(MUNGE(tmp)), sz); \

lib/find_bit.c

76

for (idx = 0; (idx + 1) * BITS_PER_LONG <= sz; idx++) { \

lib/find_bit.c

77

if (idx * BITS_PER_LONG + nr >= sz) \

lib/find_bit.c

88

if (sz % BITS_PER_LONG) \

lib/find_bit.c

91

sz = idx * BITS_PER_LONG + fns(tmp, nr); \

lib/flex_proportions.c

125

if (period - pl->period < BITS_PER_LONG) {

lib/genalloc.c

125

int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);

lib/genalloc.c

132

bits_to_clear = BITS_PER_LONG;

lib/genalloc.c

89

int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);

lib/genalloc.c

96

bits_to_set = BITS_PER_LONG;

lib/hweight.c

49

#if BITS_PER_LONG == 32

lib/hweight.c

52

#elif BITS_PER_LONG == 64

lib/idr.c

648

xa_dump_index(index * IDA_BITMAP_BITS, ilog2(BITS_PER_LONG));

lib/lz4/lz4defs.h

191

return (BITS_PER_LONG - 1 - __fls(val)) >> 3;

lib/math/div64.c

29

#if BITS_PER_LONG == 32

lib/math/int_sqrt.c

43

#if BITS_PER_LONG < 64

lib/math/prime_numbers.c

10

#if BITS_PER_LONG == 64

lib/math/prime_numbers.c

136

sz = round_up(sz, BITS_PER_LONG);

lib/math/prime_numbers.c

35

#elif BITS_PER_LONG == 32

lib/memweight.c

23

BUG_ON(longs >= INT_MAX / BITS_PER_LONG);

lib/memweight.c

25

longs * BITS_PER_LONG);

lib/percpu-refcount.c

37

#define PERCPU_COUNT_BIAS (1LU << (BITS_PER_LONG - 1))

lib/radix-tree.c

1115

unsigned tag_long = offset / BITS_PER_LONG;

lib/radix-tree.c

1116

unsigned tag_bit = offset % BITS_PER_LONG;

lib/radix-tree.c

1130

(BITS_PER_LONG - tag_bit);

lib/radix-tree.c

1132

iter->next_index = __radix_tree_iter_add(iter, BITS_PER_LONG);

lib/radix-tree.c

188

addr += offset / BITS_PER_LONG;

lib/radix-tree.c

189

tmp = *addr >> (offset % BITS_PER_LONG);

lib/radix-tree.c

192

offset = (offset + BITS_PER_LONG) & ~(BITS_PER_LONG - 1);

lib/radix-tree.c

197

offset += BITS_PER_LONG;

lib/radix-tree.c

444

BUG_ON(shift > BITS_PER_LONG);

lib/sbitmap.c

112

if (bits_per_word > BITS_PER_LONG)

lib/sbitmap.c

74

word_mask = (~0UL) >> (BITS_PER_LONG - depth);

lib/siphash.c

15

#if defined(CONFIG_DCACHE_WORD_ACCESS) && BITS_PER_LONG == 64

lib/siphash.c

229

#if BITS_PER_LONG == 64

lib/siphash.c

259

#if defined(CONFIG_DCACHE_WORD_ACCESS) && BITS_PER_LONG == 64

lib/siphash.c

292

#if defined(CONFIG_DCACHE_WORD_ACCESS) && BITS_PER_LONG == 64

lib/siphash.c

59

#if defined(CONFIG_DCACHE_WORD_ACCESS) && BITS_PER_LONG == 64

lib/siphash.c

92

#if defined(CONFIG_DCACHE_WORD_ACCESS) && BITS_PER_LONG == 64

lib/string.c

848

#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64

lib/test_bitmap.c

1032

{ BITS_PER_LONG, BITS_PER_LONG, BITS_PER_LONG,

lib/test_bitmap.c

1036

{ 1, BITS_PER_LONG - 1, BITS_PER_LONG,

lib/test_bitmap.c

1041

{ 0, BITS_PER_LONG * 2, BITS_PER_LONG * 2 + 1,

lib/test_bitmap.c

1045

{ 16, BITS_PER_LONG * 2 + 1, BITS_PER_LONG * 2 + 1 + 16,

lib/test_bitmap.c

1206

DECLARE_BITMAP(bitmap, BITS_PER_LONG);

lib/test_bitmap.c

1221

bitmap_clear(bitmap, 0, BITS_PER_LONG);

lib/test_bitmap.c

1227

bitmap_shift_right(&bitopvar, &bitopvar, 11, BITS_PER_LONG);

lib/test_bitmap.c

1254

bitmap_complement(&var, &var, BITS_PER_LONG);

lib/test_bitmap.c

1258

res = bitmap_full(&var, BITS_PER_LONG);

lib/test_bitmap.c

1309

for (nbits = BITS_PER_LONG; nbits >= 1; nbits--) {

lib/test_bitmap.c

1312

w >>= (BITS_PER_LONG - nbits);

lib/test_bitmap.c

1330

unsigned long zero_bits = 0, bits_per_long = BITS_PER_LONG;

lib/test_bitmap.c

1385

for (nbits = 1; nbits <= BITS_PER_LONG; nbits++) {

lib/test_bitmap.c

1411

for (nbits = 1; nbits <= BITS_PER_LONG; nbits++) {

lib/test_bitmap.c

333

unsigned int nlongs = DIV_ROUND_UP(nbits, BITS_PER_LONG);

lib/test_bitmap.c

659

round_up(nbits, BITS_PER_LONG), nbits);

lib/test_bitmap.c

660

if (next_bit < round_up(nbits, BITS_PER_LONG)) {

lib/test_bitmap.c

687

next_bit = find_next_bit(bmap2, round_up(nbits, BITS_PER_LONG), nbits);

lib/test_bitmap.c

688

if (next_bit < round_up(nbits, BITS_PER_LONG)) {

lib/test_bitops.c

69

for (n = 0; n < BITS_PER_LONG; n++)

lib/test_ida.c

133

IDA_BUG_ON(ida, ida_alloc_min(ida, i + BITS_PER_LONG,

lib/test_ida.c

134

GFP_KERNEL) != i + BITS_PER_LONG);

lib/test_ida.c

136

ida_free(ida, i + BITS_PER_LONG);

lib/test_ida.c

146

for (i = 0; i < IDA_BITMAP_BITS + BITS_PER_LONG - 4; i++)

lib/test_ida.c

148

for (i = IDA_BITMAP_BITS + BITS_PER_LONG - 4; i > 0; i--)

lib/test_vmalloc.c

122

for (i = 0; i < BITS_PER_LONG; i++) {

lib/test_xarray.c

16

IS_ENABLED(CONFIG_XARRAY_MULTI) ? BITS_PER_LONG : 1;

lib/test_xarray.c

384

for (i = 10; i < BITS_PER_LONG; i++) {

lib/test_xarray.c

474

xa_store_order(xa, 0, BITS_PER_LONG - 1, NULL, GFP_KERNEL);

lib/test_xarray.c

689

xa_store_order(xa, 0, BITS_PER_LONG - 1, NULL, GFP_KERNEL);

lib/tests/ffs_kunit.c

158

KUNIT_EXPECT_LE(test, ffs_result, BITS_PER_LONG);

lib/tests/ffs_kunit.c

160

KUNIT_EXPECT_LE(test, fls_result, BITS_PER_LONG);

lib/tests/ffs_kunit.c

419

KUNIT_EXPECT_LT(test, ffz_result, BITS_PER_LONG);

lib/tests/ffs_kunit.c

427

if (ffz_result < BITS_PER_LONG - 1) {

lib/tests/overflow_kunit.c

1037

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

1061

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

1104

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

1158

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

1164

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

42

BITS_PER_LONG != 64

lib/tests/overflow_kunit.c

834

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

864

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

895

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

912

#if BITS_PER_LONG == 64

lib/tests/overflow_kunit.c

931

#if BITS_PER_LONG == 64

lib/tests/printf_kunit.c

216

#if BITS_PER_LONG == 64

lib/tests/scanf_kunit.c

461

#if BITS_PER_LONG == 64

lib/tests/siphash_kunit.c

55

#if BITS_PER_LONG == 64

lib/tests/usercopy_kunit.c

25

#if BITS_PER_LONG == 64 || (!(defined(CONFIG_ARM) && !defined(MMU)) && \

lib/ubsan.c

116

#if (BITS_PER_LONG == 64) && defined(__BIG_ENDIAN)

lib/vsprintf.c

1256

word = i / BITS_PER_LONG;

lib/vsprintf.c

1257

bit = i % BITS_PER_LONG;

lib/vsprintf.c

283

#if BITS_PER_LONG == 64 && BITS_PER_LONG_LONG == 64

lib/vsprintf.c

322

#elif BITS_PER_LONG == 32 && BITS_PER_LONG_LONG == 64

lib/xarray.c

1885

unsigned int order = BITS_PER_LONG;

lib/xarray.c

2430

else if (shift >= BITS_PER_LONG)

lib/xarray.c

391

XA_NODE_BUG_ON(node, shift > BITS_PER_LONG);

lib/xarray.c

589

XA_NODE_BUG_ON(node, shift > BITS_PER_LONG);

mm/compaction.c

1409

unsigned short shift = BITS_PER_LONG - 1;

mm/kasan/kasan_test_c.c

1777

kasan_bitops_modify(test, BITS_PER_LONG, bits);

mm/kasan/kasan_test_c.c

1782

kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);

mm/kasan/kasan_test_c.c

1799

kasan_bitops_modify(test, BITS_PER_LONG, (void *)bits + 48);

mm/kasan/kasan_test_c.c

1800

kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, (void *)bits + 48);

mm/kasan/report.c

432

return 3 + (BITS_PER_LONG / 8) * 2 +

mm/kasan/report.c

447

char buffer[4 + (BITS_PER_LONG / 8) * 2];

mm/memcontrol.c

3797

#if BITS_PER_LONG < 64

mm/mempolicy.c

1651

if (maxnode % BITS_PER_LONG)

mm/mempolicy.c

1652

mask[nlongs - 1] &= (1UL << (maxnode % BITS_PER_LONG)) - 1;

mm/mempolicy.c

1674

unsigned long bits = min_t(unsigned long, maxnode, BITS_PER_LONG);

mm/mempolicy.c

1677

if (get_bitmap(&t, &nmask[(maxnode - 1) / BITS_PER_LONG], bits))

mm/mempolicy.c

1684

t &= ~((1UL << (MAX_NUMNODES % BITS_PER_LONG)) - 1);

mm/mempool.c

45

const int start = max_t(int, byte - (BITS_PER_LONG / 8), 0);

mm/mempool.c

46

const int end = min_t(int, byte + (BITS_PER_LONG / 8), size);

mm/mm_init.c

102

shift = BITS_PER_LONG;

mm/mm_init.c

1484

usemapsize = round_up(usemapsize, BITS_PER_LONG);

mm/page-writeback.c

1465

if (shift < BITS_PER_LONG)

mm/page_alloc.c

405

word_bitidx = *bitidx / BITS_PER_LONG;

mm/page_alloc.c

406

*bitidx &= (BITS_PER_LONG - 1);

mm/percpu.c

289

(index * PCPU_BITMAP_BLOCK_BITS / BITS_PER_LONG);

mm/slab_common.c

434

BUILD_BUG_ON(ARRAY_SIZE(kmalloc_caches[KMALLOC_NORMAL]) > BITS_PER_LONG);

mm/sparse-vmemmap.c

129

nr_align = 1UL << find_first_bit(&nr_pfns, BITS_PER_LONG);

mm/vmalloc.c

2564

#if BITS_PER_LONG == 32

mm/vmalloc.c

2571

#define VMAP_MAX_ALLOC BITS_PER_LONG /* 256K with 4K pages */

mm/vmalloc.c

5351

#if BITS_PER_LONG == 64

mm/vmalloc.c

54

static unsigned int __ro_after_init ioremap_max_page_shift = BITS_PER_LONG - 1;

mm/workingset.c

184

#define EVICTION_SHIFT ((BITS_PER_LONG - BITS_PER_XA_VALUE) + \

mm/workingset.c

247

BUILD_BUG_ON(LRU_GEN_WIDTH + LRU_REFS_WIDTH > BITS_PER_LONG - EVICTION_SHIFT);

mm/workingset.c

788

BUILD_BUG_ON(BITS_PER_LONG < EVICTION_SHIFT);

mm/workingset.c

796

timestamp_bits = BITS_PER_LONG - EVICTION_SHIFT;

mm/zsmalloc.c

73

#define MAX_POSSIBLE_PHYSMEM_BITS BITS_PER_LONG

mm/zsmalloc.c

91

#define OBJ_INDEX_BITS (BITS_PER_LONG - _PFN_BITS)

net/bridge/br.c

354

opt_id = find_next_bit(&bitmap, BITS_PER_LONG, BR_BOOLOPT_MAX);

net/bridge/br.c

355

if (opt_id != BITS_PER_LONG) {

net/bridge/br_private.h

37

#define BR_HWDOM_MAX BITS_PER_LONG

net/ceph/osdmap.c

587

#if BITS_PER_LONG == 32

net/core/net-sysfs.c

1108

#if BITS_PER_LONG > 32

net/core/net-sysfs.c

1613

if (value && (value < 4 || value > 4 / 2 * BITS_PER_LONG))

net/core/sock.c

3741

#if BITS_PER_LONG==32

net/dsa/dsa.c

32

#define DSA_MAX_NUM_OFFLOADING_BRIDGES BITS_PER_LONG

net/ethtool/bitset.c

725

#if BITS_PER_LONG == 64 && defined(__BIG_ENDIAN)

net/ethtool/features.c

142

dest[i] = (unsigned long)(val >> (i * BITS_PER_LONG));

net/ethtool/features.c

153

ret |= (netdev_features_t)(src[i]) << (i * BITS_PER_LONG);

net/ethtool/ioctl.c

3612

} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */

net/ipv4/af_inet.c

1671

#if BITS_PER_LONG==32

net/ipv4/fib_trie.c

1554

if ((BITS_PER_LONG > KEYLENGTH) || (fa->fa_slen < KEYLENGTH)) {

net/ipv4/fib_trie.c

225

if ((BITS_PER_LONG <= KEYLENGTH) && (KEYLENGTH == kv->pos))

net/ipv4/udp.c

1596

#if BITS_PER_LONG == 64

net/ipv4/udp.c

1613

#if BITS_PER_LONG == 64

net/ipv6/addrconf_core.c

223

const struct in6_addr in6addr_loopback __aligned(BITS_PER_LONG/8)

net/ipv6/addrconf_core.c

226

const struct in6_addr in6addr_any __aligned(BITS_PER_LONG/8)

net/ipv6/addrconf_core.c

229

const struct in6_addr in6addr_linklocal_allnodes __aligned(BITS_PER_LONG/8)

net/ipv6/addrconf_core.c

232

const struct in6_addr in6addr_linklocal_allrouters __aligned(BITS_PER_LONG/8)

net/ipv6/addrconf_core.c

235

const struct in6_addr in6addr_interfacelocal_allnodes __aligned(BITS_PER_LONG/8)

net/ipv6/addrconf_core.c

238

const struct in6_addr in6addr_interfacelocal_allrouters __aligned(BITS_PER_LONG/8)

net/ipv6/addrconf_core.c

241

const struct in6_addr in6addr_sitelocal_allrouters __aligned(BITS_PER_LONG/8)

net/mac80211/ieee80211_i.h

763

unsigned long mbss_changed[64 / BITS_PER_LONG];

net/mpls/internal.h

32

#if BITS_PER_LONG == 32

net/netfilter/ipvs/ip_vs_conn.c

1491

#if BITS_PER_LONG > 32

net/netfilter/nf_conntrack_core.c

2648

if (BITS_PER_LONG >= 64 &&

net/netfilter/nft_set_pipapo.c

1656

f->bsize * BITS_PER_LONG);

net/netfilter/nft_set_pipapo.c

375

int i = k * BITS_PER_LONG + r;

net/netfilter/nft_set_pipapo.c

722

new_bucket_size = DIV_ROUND_UP(rules, BITS_PER_LONG);

net/netfilter/nft_set_pipapo.h

203

f->bsize * BITS_PER_LONG);

net/netfilter/nft_set_pipapo.h

208

f->bsize * BITS_PER_LONG);

net/netfilter/nft_set_pipapo.h

228

f->bsize * BITS_PER_LONG);

net/netfilter/nft_set_pipapo.h

58

#if BITS_PER_LONG == 64

net/netfilter/nft_set_pipapo.h

61

#define NFT_PIPAPO_MAP_TOBITS (BITS_PER_LONG - NFT_PIPAPO_MAP_NBITS)

net/netfilter/nft_set_pipapo.h

91

#if BITS_PER_LONG == 64

net/netfilter/nft_set_pipapo_avx2.c

101

int offset = start % BITS_PER_LONG;

net/netfilter/nft_set_pipapo_avx2.c

104

data += start / BITS_PER_LONG;

net/netfilter/nft_set_pipapo_avx2.c

111

if (likely(len < BITS_PER_LONG || offset)) {

net/netfilter/nft_set_pipapo_avx2.c

112

if (likely(len + offset <= BITS_PER_LONG)) {

net/netfilter/nft_set_pipapo_avx2.c

118

len -= BITS_PER_LONG - offset;

net/netfilter/nft_set_pipapo_avx2.c

121

if (len <= BITS_PER_LONG) {

net/netfilter/nft_set_pipapo_avx2.c

122

mask = ~0UL >> (BITS_PER_LONG - len);

net/netfilter/nft_set_pipapo_avx2.c

129

data += len / BITS_PER_LONG;

net/netfilter/nft_set_pipapo_avx2.c

131

len %= BITS_PER_LONG;

net/netfilter/nft_set_pipapo_avx2.c

133

*data |= ~0UL >> (BITS_PER_LONG - len);

net/netfilter/nft_set_pipapo_avx2.c

162

int i = (offset + (x)) * BITS_PER_LONG + r; \

net/netfilter/nft_set_pipapo_avx2.c

27

#define NFT_PIPAPO_LONGS_PER_M256 (XSAVE_YMM_SIZE / BITS_PER_LONG)

net/netlabel/netlabel_kapi.c

734

if ((off & (BITS_PER_LONG - 1)) != 0)

net/netlabel/netlabel_kapi.c

815

if (((spot & (BITS_PER_LONG - 1)) == 0) &&

net/netlabel/netlabel_kapi.c

816

((end - spot) > BITS_PER_LONG)) {

net/netlabel/netlabel_kapi.c

821

spot += BITS_PER_LONG;

net/netlabel/netlabel_kapi.c

851

if ((offset & (BITS_PER_LONG - 1)) != 0)

net/netlink/af_netlink.c

996

if (nlk->ngroups < BITS_PER_LONG)

net/netlink/genetlink.c

410

BITS_PER_LONG);

net/netlink/genetlink.c

413

mc_groups_longs * BITS_PER_LONG,

net/netlink/genetlink.c

419

mc_groups_longs * BITS_PER_LONG);

net/netlink/genetlink.c

428

if (id + n_groups > mc_groups_longs * BITS_PER_LONG) {

net/netlink/genetlink.c

512

mc_groups_longs * BITS_PER_LONG);

net/netlink/genetlink.c

527

mc_groups_longs * BITS_PER_LONG);

net/openvswitch/flow.h

167

} __aligned(BITS_PER_LONG/8); /* Ensure that we can do comparisons as longs. */

net/rds/threads.c

272

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64

net/rxrpc/ar-internal.h

963

#define RXRPC_NR_TXQUEUE BITS_PER_LONG

net/sched/cls_flow.c

64

return (a & 0xFFFFFFFF) ^ (BITS_PER_LONG > 32 ? a >> 32 : 0);

net/sched/cls_flower.c

88

} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */

net/sctp/tsnmap.c

350

inc = ALIGN((size - map->len), BITS_PER_LONG) + SCTP_TSN_MAP_INCREMENT;

net/sunrpc/auth_gss/svcauth_gss.c

364

unsigned long sd_win[GSS_SEQ_WIN/BITS_PER_LONG];

net/unix/af_unix.c

3445

#define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)

scripts/mod/file2alias.c

660

if (get_unaligned_native(arr + i / BITS_PER_LONG) &

scripts/mod/file2alias.c

661

(1ULL << (i % BITS_PER_LONG)))

security/selinux/hooks.c

4095

#if BITS_PER_LONG == 32

security/selinux/ss/ebitmap.h

30

#define EBITMAP_UNIT_SIZE BITS_PER_LONG

security/tomoyo/common.h

688

unsigned long group[TOMOYO_MAX_ACL_GROUPS / BITS_PER_LONG];

sound/core/oss/pcm_oss.c

586

#if BITS_PER_LONG >= 64

sound/hda/controllers/intel.c

1859

#if BITS_PER_LONG != 64

sound/pci/ctxfi/cthw20k1.c

1898

const unsigned int dma_bits = BITS_PER_LONG;

sound/pci/ctxfi/cthw20k2.c

2063

const unsigned int dma_bits = BITS_PER_LONG;

sound/pci/lx6464es/lx_core.h

212

#if BITS_PER_LONG == 32

tools/include/asm-generic/bitops/__fls.h

15

unsigned int num = BITS_PER_LONG - 1;

tools/include/asm-generic/bitops/__fls.h

17

#if BITS_PER_LONG == 64

tools/include/asm-generic/bitops/__fls.h

23

if (!(word & (~0ul << (BITS_PER_LONG-16)))) {

tools/include/asm-generic/bitops/__fls.h

27

if (!(word & (~0ul << (BITS_PER_LONG-8)))) {

tools/include/asm-generic/bitops/__fls.h

31

if (!(word & (~0ul << (BITS_PER_LONG-4)))) {

tools/include/asm-generic/bitops/__fls.h

35

if (!(word & (~0ul << (BITS_PER_LONG-2)))) {

tools/include/asm-generic/bitops/__fls.h

39

if (!(word & (~0ul << (BITS_PER_LONG-1))))

tools/include/asm-generic/bitops/fls64.h

18

#if BITS_PER_LONG == 32

tools/include/asm-generic/bitops/fls64.h

26

#elif BITS_PER_LONG == 64

tools/include/asm-generic/bitops/non-atomic.h

112

return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));

tools/include/asm-generic/bitsperlong.h

13

#if BITS_PER_LONG != __BITS_PER_LONG

tools/include/asm-generic/bitsperlong.h

22

(__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG && (nbits) > 0)

tools/include/linux/bitmap.h

32

#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))

tools/include/linux/bitmap.h

33

#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))

tools/include/linux/bitmap.h

35

#define bitmap_size(nbits) (ALIGN(nbits, BITS_PER_LONG) / BITS_PER_BYTE)

tools/include/linux/bitops.h

11

#ifndef BITS_PER_LONG

tools/include/linux/bits.h

8

#define BIT_MASK(nr) (UL(1) << ((nr) % BITS_PER_LONG))

tools/include/linux/bits.h

9

#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)

tools/include/linux/hash.h

14

#if BITS_PER_LONG == 32

tools/include/linux/hash.h

17

#elif BITS_PER_LONG == 64

tools/include/linux/hash.h

76

#if BITS_PER_LONG == 64

tools/include/linux/hash.h

95

#if BITS_PER_LONG == 64

tools/lib/bitmap.c

10

unsigned int k, w = 0, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

108

int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);

tools/lib/bitmap.c

114

bits_to_set = BITS_PER_LONG;

tools/lib/bitmap.c

128

int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);

tools/lib/bitmap.c

134

bits_to_clear = BITS_PER_LONG;

tools/lib/bitmap.c

148

unsigned int lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

15

if (bits % BITS_PER_LONG)

tools/lib/bitmap.c

153

if (bits % BITS_PER_LONG)

tools/lib/bitmap.c

162

unsigned int k, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

167

if (bits % BITS_PER_LONG)

tools/lib/bitmap.c

64

unsigned int lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

69

if (bits % BITS_PER_LONG)

tools/lib/bitmap.c

78

unsigned int k, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

83

if (bits % BITS_PER_LONG)

tools/lib/bitmap.c

93

unsigned int k, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

98

if (bits % BITS_PER_LONG)

tools/lib/find_bit.c

31

for (idx = 0; idx * BITS_PER_LONG < sz; idx++) { \

tools/lib/find_bit.c

34

sz = min(idx * BITS_PER_LONG + __ffs(MUNGE(val)), sz); \

tools/lib/find_bit.c

57

idx = __start / BITS_PER_LONG; \

tools/lib/find_bit.c

60

if ((idx + 1) * BITS_PER_LONG >= sz) \

tools/lib/find_bit.c

65

sz = min(idx * BITS_PER_LONG + __ffs(MUNGE(tmp)), sz); \

tools/lib/hweight.c

45

#if BITS_PER_LONG == 32

tools/lib/hweight.c

48

#elif BITS_PER_LONG == 64

tools/perf/ui/browsers/hists.c

2508

snprintf(name, sizeof(name), "%.*" PRIx64, BITS_PER_LONG / 4, addr);

tools/perf/ui/browsers/map.c

119

char tmp[BITS_PER_LONG / 4];

tools/perf/ui/hist.c

1060

ret += 3 + BITS_PER_LONG / 4;

tools/perf/util/annotate.c

1198

printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2,

tools/perf/util/annotate.c

1201

printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->nr_samples", h->nr_samples);

tools/perf/util/annotate.c

1603

notes->src->widths.target = BITS_PER_LONG / 4;

tools/perf/util/auxtrace.c

401

} else if (BITS_PER_LONG == 32 &&

tools/perf/util/auxtrace.h

466

#if BITS_PER_LONG == 32

tools/perf/util/auxtrace.h

482

#if BITS_PER_LONG == 32

tools/perf/util/hist.c

102

symlen += BITS_PER_LONG / 4 + 2 + 3;

tools/perf/util/hist.c

126

symlen += BITS_PER_LONG / 4 + 2 + 3;

tools/perf/util/hist.c

141

symlen += BITS_PER_LONG / 4 + 2 + 3;

tools/perf/util/hist.c

226

hists__new_col_len(hists, HISTC_ADDR, BITS_PER_LONG / 4 + 2);

tools/perf/util/hist.c

78

const unsigned int unresolved_col_width = BITS_PER_LONG / 4;

tools/perf/util/hist.c

88

const unsigned int unresolved_col_width = BITS_PER_LONG / 4;

tools/perf/util/intel-pt-decoder/intel-pt-decoder.c

1032

if (ret == INTEL_PT_NEED_MORE_BYTES && BITS_PER_LONG == 32 &&

tools/perf/util/scripting-engines/trace-event-python.c

1094

#if BITS_PER_LONG == 64

tools/perf/util/scripting-engines/trace-event-python.c

1097

#if BITS_PER_LONG == 32

tools/perf/util/scripting-engines/trace-event-python.c

1110

#if BITS_PER_LONG == 64

tools/perf/util/scripting-engines/trace-event-python.c

1113

#if BITS_PER_LONG == 32

tools/perf/util/session.c

2246

#if BITS_PER_LONG == 64

tools/perf/util/sort.c

1374

size_t len = BITS_PER_LONG / 4;

tools/perf/util/sort.c

2026

size_t len = BITS_PER_LONG / 4;

tools/perf/util/sort.c

409

BITS_PER_LONG / 4 + 2, rip, o);

tools/perf/util/sort.c

427

size_t len = BITS_PER_LONG / 4;

tools/perf/util/vdso.c

117

#if BITS_PER_LONG == 64

tools/perf/util/vdso.c

171

#if BITS_PER_LONG == 64

tools/perf/util/vdso.c

348

#if BITS_PER_LONG == 64

tools/perf/util/vdso.c

41

#if BITS_PER_LONG == 64

tools/perf/util/vdso.c

54

#if BITS_PER_LONG == 64

tools/testing/radix-tree/test.c

50

assert(item->order < BITS_PER_LONG);

tools/testing/selftests/iommu/iommufd_utils.h

44

return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG - 1)));

tools/testing/selftests/kvm/dirty_log_test.c

48

# define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7)

tools/testing/selftests/kvm/include/s390/facility.h

24

return test_bit(nr ^ (BITS_PER_LONG - 1), ptr);

tools/testing/selftests/kvm/x86/hwcr_msr_test.c

41

for (bit = 0; bit < BITS_PER_LONG; bit++)

tools/testing/selftests/powerpc/primitives/asm/ppc_asm.h

17

#define SZL (BITS_PER_LONG/8)

tools/testing/selftests/powerpc/primitives/linux/wordpart.h

54

# define aligned_byte_mask(n) (~0xffUL << (BITS_PER_LONG - 8 - 8*(n)))

tools/testing/selftests/user_events/abi_test.c

283

#if BITS_PER_LONG == 8

tools/testing/vma/tests/vma.c

110

for (i = 0; i < sizeof(flags) / BITS_PER_LONG; i++) {

tools/testing/vma/tests/vma.c

12

for (i = 1; i < NUM_VMA_FLAGS / BITS_PER_LONG; i++) {

tools/testing/vma/tests/vma.c

68

for (bit = 0; bit < BITS_PER_LONG; bit++) {

tools/testing/vma/tests/vma.c

8

#if NUM_VMA_FLAGS > BITS_PER_LONG

virt/kvm/dirty_ring.c

167

if (delta >= 0 && delta < BITS_PER_LONG) {

virt/kvm/dirty_ring.c

173

if (delta > -BITS_PER_LONG && delta < 0 &&

virt/kvm/kvm_main.c

2284

offset = i * BITS_PER_LONG;

virt/kvm/kvm_main.c

2369

n = ALIGN(log->num_pages, BITS_PER_LONG) / 8;

virt/kvm/kvm_main.c

2384

for (offset = log->first_page, i = offset / BITS_PER_LONG,

virt/kvm/kvm_main.c

2385

n = DIV_ROUND_UP(log->num_pages, BITS_PER_LONG); n--;

virt/kvm/kvm_main.c

2386

i++, offset += BITS_PER_LONG) {