lib/libc/gen/vis.c

322

shft = i * NBBY;

lib/libc/gen/vis.c

628

shft = i * NBBY;

lib/libc/stdlib/malloc.c

406

if ((((~(1UL << ((sizeof(size_t) * NBBY) - 1)) / sizeof(*page_dir)) + 1)

lib/libossaudio/oss_dsp.c

104

rerrors /= ((tmpinfo.record.precision / NBBY) *

lib/libossaudio/oss_dsp.c

356

((tmpinfo.record.precision / NBBY) *

lib/libossaudio/oss_dsp.c

359

((tmpinfo.record.precision / NBBY) *

lib/libossaudio/oss_dsp.c

379

((tmpinfo.play.precision / NBBY) *

lib/libossaudio/oss_dsp.c

382

((tmpinfo.play.precision / NBBY) *

lib/libossaudio/oss_dsp.c

97

perrors /= ((tmpinfo.play.precision / NBBY) *

libexec/ftpd/ftpcmd.y

1053

cmd_bytesz = NBBY;

libexec/ftpd/ftpcmd.y

363

#if NBBY == 8

libexec/ftpd/ftpcmd.y

371

UNIMPLEMENTED for NBBY != 8

libexec/ftpd/ftpcmd.y

691

reply(215, "UNIX Type: L%d", NBBY);

libexec/ftpd/ftpcmd.y

693

reply(215, "UNIX Type: L%d Version: %s", NBBY,

libexec/ftpd/ftpd.c

2605

#if NBBY == 8

libexec/ftpd/ftpd.c

2606

cprintf(stdout, " %d", NBBY);

sbin/cgdconfig/utils.c

371

if (nbits > (len - sizeof(*tmp)) * NBBY) {

sbin/dump/dump.h

101

map[(u_int)((ino) - 1) / NBBY] |= 1 << ((u_int)((ino) - 1) % NBBY)

sbin/dump/dump.h

103

map[(u_int)((ino) - 1) / NBBY] &= ~(1 << ((u_int)((ino) - 1) % NBBY))

sbin/dump/dump.h

105

(map[(u_int)((ino) - 1) / NBBY] & (1 << ((u_int)((ino) - 1) % NBBY)))

sbin/dump/main.c

563

mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);

sbin/dump/main.c

652

if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */

sbin/dump/main.c

671

if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */

sbin/dump/traverse.c

287

if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */

sbin/fsck_ext2fs/pass5.c

172

for (i = fs->e2fs.e2fs_ipg / NBBY; i < (uint32_t)fs->e2fs_bsize; i++)

sbin/fsck_ext2fs/setup.c

250

bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/fsck_ext2fs/setup.c

527

fs->e2fs.e2fs_bpg = fs->e2fs_bsize * NBBY;

sbin/fsck_ffs/pass5.c

178

mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -

sbin/fsck_ffs/pass5.c

180

blkmapsize = howmany(fs->fs_fpg, NBBY);

sbin/fsck_ffs/pass5.c

397

if ((i & (NBBY - 1)) != (NBBY - 1)) {

sbin/fsck_ffs/pass5.c

451

for (k = 0; k < NBBY; k++) {

sbin/fsck_ffs/pass5.c

465

for (k = 0; k < NBBY; k++) {

sbin/fsck_ffs/quota2.c

360

quotamap[i] = calloc(roundup(howmany(nq2e, NBBY),

sbin/fsck_ffs/setup.c

498

bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/fsck_lfs/setup.c

442

bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/ifconfig/util.c

191

if (plen < 0 || (size_t)plen > addrlen * NBBY) {

sbin/ifconfig/util.c

197

plen = addrlen * NBBY;

sbin/ifconfig/util.c

199

memset(addr, 0xff, (plen + NBBY - 1) / NBBY);

sbin/ifconfig/util.c

201

nbit = plen % NBBY;

sbin/ifconfig/util.c

203

addr[plen / NBBY] &= ~((uint8_t)0xff >> nbit);

sbin/ifconfig/util.c

276

iflr.prefixlen = sdl->sdl_alen * NBBY;

sbin/newfs/mkfs.c

402

inodeblks = ((1ull << 31) - NBBY) / FFS_INOPB(&sblock);

sbin/newfs/mkfs.c

433

sblock.fs_fpg = roundup(sblock.fs_fpg, NBBY);

sbin/newfs/mkfs.c

438

sblock.fs_fpg -= (i - sblock.fs_bsize) * NBBY;

sbin/newfs_ext2fs/mke2fs.c

1275

len = sblock.e2fs.e2fs_bpg / NBBY;

sbin/newfs_ext2fs/mke2fs.c

1280

bno = loc * NBBY;

sbin/newfs_ext2fs/mke2fs.c

1293

bno = loc * NBBY;

sbin/newfs_ext2fs/mke2fs.c

1294

for (i = 0; i < NBBY; i++, bno++) {

sbin/newfs_ext2fs/mke2fs.c

292

blocks_per_cg = sblock.e2fs_bsize * NBBY;

sbin/newfs_ext2fs/mke2fs.c

578

pblock += pbsize[i] * NBBY; /* next bg */

sbin/newfs_ext2fs/mke2fs.c

726

for (i = nblcg; i < roundup(nblcg, NBBY); i++)

sbin/newfs_ext2fs/mke2fs.c

728

memset(&buf[i / NBBY], ~0U, sblock.e2fs.e2fs_bpg - i);

sbin/newfs_ext2fs/mke2fs.c

731

for (i = 0; i < cgoverhead(cylno) / NBBY; i++)

sbin/newfs_ext2fs/mke2fs.c

733

i = i * NBBY;

sbin/newfs_ext2fs/mke2fs.c

746

i = sblock.e2fs.e2fs_ipg / NBBY;

sbin/resize_ffs/resize_ffs.c

1895

howmany(newsb->fs_fpg / NSPB(newsb), NBBY));

sbin/resize_ffs/resize_ffs.c

1899

NSPB(newsb), NBBY));

sbin/resize_ffs/resize_ffs.c

1994

memset(&cg_inosused(cg, 0)[0], 0, howmany(newsb->fs_ipg, NBBY));

sbin/resize_ffs/resize_ffs.c

529

cg->cg_freeoff = cg->cg_iusedoff + howmany(newsb->fs_ipg, NBBY);

sbin/resize_ffs/resize_ffs.c

533

howmany(newsb->fs_fpg, NBBY) - sizeof(int32_t);

sbin/resize_ffs/resize_ffs.c

539

howmany(ffs_fragstoblks(newsb,newsb->fs_fpg), NBBY);

sbin/resize_ffs/resize_ffs.c

548

howmany(newsb->fs_fpg, NBBY);

sbin/restore/restore.h

160

(map[(u_int)((ino) - 1) / NBBY] & (1 << ((u_int)((ino) - 1) % NBBY)))

sbin/restore/restore.h

162

map[(u_int)((ino) - 1) / NBBY] |= 1 << ((u_int)((ino) - 1) % NBBY)

sbin/restore/tape.c

1029

maxino = mapsize * NBBY + 1;

sbin/restore/tape.c

1030

else if (maxino != mapsize * NBBY + 1)

sbin/rndctl/rndctl.c

193

MIN(sizeof(buf), UINT32_MAX/NBBY)*NBBY);

sbin/rndctl/rndctl.c

194

extraentropy = MIN(extraentropy, MIN(nextra, UINT32_MAX/NBBY)*NBBY);

sbin/rndctl/rndctl.c

196

MIN(sizeof(rs.data), UINT32_MAX/NBBY)*NBBY);

sbin/rndctl/rndctl.c

354

if (howmany(rs.entropy, NBBY) > sizeof(rs.data)) {

sbin/rndctl/rndctl.c

356

if (howmany(rs.entropy, NBBY) > sizeof(rs.data)) {

sys/arch/aarch64/aarch64/aarch64_tlb.c

110

memset(mapp, 0xff, (asid_max + 1) / NBBY);

sys/arch/aarch64/aarch64/cpu.c

630

size_t nbits = nbytes*NBBY;

sys/arch/amd64/amd64/machdep.c

862

roundup(max_paddr / (PAGE_SIZE * NBBY), PAGE_SIZE),

sys/arch/amd64/amd64/machdep.c

880

roundup(max_paddr / (PAGE_SIZE * NBBY), PAGE_SIZE));

sys/arch/amiga/dev/aucc.c

410

blk = rounddown(blk, param->channels * param->precision / NBBY);

sys/arch/arm/amlogic/meson_rng.c

117

sizeof(data) * NBBY);

sys/arch/arm/arm/cpu_subr.c

68

#define CPUINDEX_DIVISOR (sizeof(u_long) * NBBY)

sys/arch/arm/broadcom/bcm2835_rng.c

144

(cnt * 4 * NBBY));

sys/arch/arm/cortex/gicv3.c

719

const bus_size_t lpipend_sz = (8192 + sc->sc_lpi.pic_maxsources) / NBBY;

sys/arch/arm/nvidia/tegra124_car.c

938

nbytes * NBBY);

sys/arch/arm/rockchip/rk_v1crypto.c

277

uint32_t entropybits = NBBY*sizeof(buf)/2; /* be conservative */

sys/arch/arm/rockchip/rk_v1crypto.c

280

size_t nbits = NBBY*nbytes;

sys/arch/arm/sunxi/sun6i_dma.c

318

IL2B(req->dreq_mem_opt.opt_bus_width/NBBY)) == 0)

sys/arch/arm/sunxi/sun6i_dma.c

321

IL2B(req->dreq_dev_opt.opt_bus_width/NBBY)) == 0)

sys/arch/arm/sunxi/sun8i_crypto.c

1442

CTASSERT(SUN8I_CRYPTO_RNGBYTES <= UINT32_MAX/NBBY);

sys/arch/arm/sunxi/sun8i_crypto.c

1443

entropybits = (NBBY*SUN8I_CRYPTO_RNGBYTES)/SUN8I_CRYPTO_RNGENTROPY;

sys/arch/arm/ti/ti_rng.c

139

sizeof(buf) * NBBY);

sys/arch/atari/dev/grfabs_et.c

335

bm->bytes_per_row = (mode->size.width * depth) / NBBY;

sys/arch/atari/dev/grfabs_fal.c

567

bm_size = m68k_round_page((width * height * depth) / NBBY);

sys/arch/atari/dev/grfabs_fal.c

577

bm->bytes_per_row = (width * depth) / NBBY;

sys/arch/atari/dev/grfabs_fal.c

580

bm->phys_mappable = (depth * width * height) / NBBY;

sys/arch/atari/dev/grfabs_tt.c

339

bm_size = m68k_round_page((width * height * depth) / NBBY);

sys/arch/atari/dev/grfabs_tt.c

349

bm->bytes_per_row = (width * depth) / NBBY;

sys/arch/atari/dev/grfabs_tt.c

355

bm->phys_mappable = (depth * width * height) / NBBY;

sys/arch/cesfic/cesfic/pmap_bootstrap.c

246

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/emips/ebus/ace_ebus.c

1734

(bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {

sys/arch/emips/ebus/flash_ebus.c

1659

(bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {

sys/arch/evbppc/nintendo/dev/wiifb.c

592

rgb_size = rgb_size * WIIFB_RGB_BPP / NBBY;

sys/arch/evbppc/nintendo/dev/wiiufb.c

283

for (i = 0; i < WIIUFB_CURMAX * NBBY; i++) {

sys/arch/evbppc/nintendo/dev/wiiufb.c

57

#define WIIUFB_STRIDE ((wiiufb_drc ? 896 : 1280) * WIIUFB_BPP / NBBY)

sys/arch/evbppc/nintendo/dev/wiiufb.c

63

#define WIIUFB_CURSOR_BITS (WIIUFB_CURMAX * WIIUFB_CURMAX / NBBY)

sys/arch/hp300/hp300/pmap_bootstrap.c

247

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/hpc/hpc/debug_subr.c

55

n = len * NBBY - 1;

sys/arch/hpcarm/dev/epsonlcd.c

194

fb->hf_bytes_per_line = (vc->vc_fbwidth * vc->vc_fbdepth) / NBBY;

sys/arch/hpcarm/dev/epsonlcd.c

255

vc->vc_fbdepth = (bootinfo->fb_line_bytes / bootinfo->fb_width) * NBBY;

sys/arch/hpcmips/dev/plumvideo.c

256

fb->hf_bytes_per_line = (width * depth) / NBBY;

sys/arch/hpcmips/dev/plumvideo.c

365

vram_pitch = bootinfo->fb_line_bytes = (width * bpp) / NBBY;

sys/arch/hpcmips/dev/plumvideo.c

401

vram_size = (width * height * bpp) / NBBY;

sys/arch/hpcmips/tx/tx3912video.c

259

/ NBBY;

sys/arch/hpcmips/tx/tx3912video.c

350

bootinfo->fb_line_bytes = (chip->vc_fbwidth * fbdepth) / NBBY;

sys/arch/hpcmips/tx/tx3912video.c

367

NBBY;

sys/arch/hpcmips/vr/vrkiu.c

245

for (i = 0, n = 0; i < NBBY; i++)

sys/arch/hpcsh/dev/hd64461/hd64461video.c

1025

vc->vc_fbsize = (width * height * depth) / NBBY;

sys/arch/hpcsh/dev/hd64461/hd64461video.c

246

NBBY;

sys/arch/hpcsh/dev/hd64461/hd64461video.c

353

fb->hf_bytes_per_line = (width * depth) / NBBY;

sys/arch/hpcsh/dev/hd64461/hd64461video.c

891

sc->sc_font.c = (w * bpp) / NBBY;

sys/arch/hpcsh/dev/hd64461/hd64461video.c

893

sc->sc_font.cstep = ((w * h * bpp) / NBBY) * sc->sc_font.cw;

sys/arch/hpcsh/dev/hd64461/hd64461video.c

929

n = (w * h) / NBBY;

sys/arch/i386/i386/dumpsys.c

341

roundup(max_paddr / (PAGE_SIZE * NBBY), PAGE_SIZE),

sys/arch/i386/i386/dumpsys.c

357

roundup(max_paddr / (PAGE_SIZE * NBBY), PAGE_SIZE));

sys/arch/i386/pci/glxsb.c

283

sizeof(value) * NBBY);

sys/arch/ia64/ia64/pmap.c

734

idx = field * sizeof(inuse) * NBBY + bit;

sys/arch/ia64/ia64/pmap.c

817

field = idx / (sizeof(u_long) * NBBY);

sys/arch/ia64/ia64/pmap.c

818

bit = idx % (sizeof(u_long) * NBBY);

sys/arch/ia64/ia64/pmap.c

886

idx = field * sizeof(pc->pc_map[field]) * NBBY + bit;

sys/arch/luna68k/luna68k/pmap_bootstrap.c

229

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/m68k/m68k/db_disasm.c

3058

static char buf[sizeof(long) * NBBY / 3 + 2];

sys/arch/m68k/m68k/db_disasm.c

3093

static char buf[sizeof(long) * NBBY / 3 + 2];

sys/arch/m68k/m68k/linux_bootinfo.c

531

rnd->data_length * NBBY);

sys/arch/m68k/m68k/pmap_motorola.c

610

for (rv = MAXUL2SIZE; rv < sizeof(protostfree)*NBBY; rv++)

sys/arch/mac68k/mac68k/pmap_bootstrap.c

249

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/mips/cavium/dev/octeon_rnm.c

226

size_t needed = NBBY*nbytes;

sys/arch/mips/cavium/dev/octeon_rnm.c

258

sizeof sc->sc_sample, NBBY*sizeof(sc->sc_sample)/BPB);

sys/arch/mips/cavium/dev/octeon_rnm.c

259

needed -= MIN(needed, MAX(1, NBBY*sizeof(sc->sc_sample)/BPB));

sys/arch/mips/cavium/octeon_cpunode.c

87

CTASSERT(MAXCPUS <= sizeof(uint64_t) * NBBY);

sys/arch/mips/ingenic/ingenic_rng.c

114

sizeof(data) * NBBY);

sys/arch/mvme68k/mvme68k/pmap_bootstrap.c

246

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/news68k/news68k/pmap_bootstrap.c

244

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/next68k/next68k/pmap_bootstrap.c

254

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/riscv/dev/plicreg.h

43

#define PLIC_ENABLE_SIZE (PLIC_NIRQ / NBBY)

sys/arch/riscv/include/types.h

42

#define XLEN (sizeof(long) * NBBY)

sys/arch/riscv/riscv/cpu_subr.c

74

#define CPUINDEX_DIVISOR (sizeof(u_long) * NBBY)

sys/arch/riscv/riscv/cpu_subr.c

93

KASSERT(hartid < sizeof(unsigned long) * NBBY);

sys/arch/riscv/riscv/interrupt.c

186

KASSERT(hartid < sizeof(unsigned long) * NBBY);

sys/arch/riscv/riscv/riscv_machdep.c

1013

size_t topbit = sizeof(long) * NBBY - 1;

sys/arch/riscv/riscv/riscv_tlb.c

136

KASSERT(hartid < sizeof(unsigned long) * NBBY);

sys/arch/riscv/riscv/riscv_tlb.c

161

memset(ptr, 0xff, PMAP_TLB_NUM_PIDS / NBBY);

sys/arch/riscv/riscv/riscv_tlb.c

97

KASSERT(hartid < sizeof(unsigned long) * NBBY);

sys/arch/riscv/starfive/jh7100_pinctrl.c

394

const uint32_t mask = pin_no % (sizeof(bank) * NBBY);

sys/arch/riscv/starfive/jh7110_pinctrl.c

666

const u_int bits_per_bank = banksz * NBBY;

sys/arch/riscv/starfive/jh7110_trng.c

191

sizeof(data), sizeof(data) * NBBY);

sys/arch/vax/vsa/gpx.c

1013

ss->ss_gpr = MIN(GPX_WIDTH / (NBBY * font->stride), font->numchars);

sys/arch/vax/vsa/gpx.c

536

sx = (uc % ss->ss_gpr) * font->stride * NBBY;

sys/arch/virt68k/virt68k/pmap_bootstrap.c

252

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/x68k/x68k/pmap_bootstrap.c

239

for (i = MAXKL2SIZE; i < sizeof(stfree) * NBBY; i++)

sys/arch/x86/pci/fwhrng.c

234

sc->sc_rnd_ax = (sc->sc_rnd_ax << NBBY) |

sys/arch/x86/pci/fwhrng.c

240

sizeof(sc->sc_rnd_ax) * NBBY);

sys/arch/x86/x86/cpu_rng.c

137

return sizeof(lo) * NBBY;

sys/arch/x86/x86/cpu_rng.c

143

return sizeof(*out) * NBBY;

sys/arch/x86/x86/cpu_rng.c

178

return sizeof(*out) * NBBY;

sys/arch/x86/x86/cpu_rng.c

243

return nbytes * NBBY/2;

sys/arch/x86/x86/cpu_topology.c

201

if (smt_bits + core_bits < sizeof(apic_id) * NBBY)

sys/dev/acpi/acpi.c

592

rnd_add_data(&hvrs, hostrnd, hrlen, hrlen * NBBY);

sys/dev/acpi/acpi_i2c.c

335

cmdlen = bit_width / NBBY;

sys/dev/acpi/acpi_i2c.c

339

cmdlen = bit_width / NBBY;

sys/dev/acpi/acpi_i2c.c

343

cmdlen = bit_width / NBBY;

sys/dev/acpi/acpi_i2c.c

347

cmdlen = bit_width / NBBY;

sys/dev/acpi/apei_mapreg.c

153

unsigned chunkbits = NBBY*(1 << (reg->AccessWidth - 1));

sys/dev/acpi/apei_mapreg.c

181

NBBY*(1 << (reg->AccessWidth - 1)));

sys/dev/acpi/apei_mapreg.c

224

unsigned chunkbits = NBBY*(1 << (reg->AccessWidth - 1));

sys/dev/acpi/apei_mapreg.c

251

NBBY*(1 << (reg->AccessWidth - 1)));

sys/dev/ata/wd.c

2209

(1 << NBBY)) {

sys/dev/audio/audio.c

2526

hwbuf->fmt.channels * hwbuf->fmt.stride / NBBY);

sys/dev/audio/audio.c

2545

hwbuf->fmt.channels * hwbuf->fmt.stride / NBBY);

sys/dev/audio/audio.c

5227

else if (fmt->stride % NBBY != 0) {

sys/dev/audio/audio.c

5290

if ((rounded * NBBY) % (mixer->hwbuf.fmt.stride *

sys/dev/audio/audio.c

5304

mixer->frames_per_block = blksize * NBBY /

sys/dev/audio/audio.c

5398

mixer->mixfmt.stride / NBBY;

sys/dev/audio/audio.c

5407

mixer->mixfmt.stride / NBBY;

sys/dev/audio/audio.c

8327

KASSERTMSG(fmt->stride % NBBY == 0,

sys/dev/audio/audio.c

9247

bps = fmt->stride / NBBY;

sys/dev/audio/audiodef.h

294

return frames * fmt->channels * fmt->stride / NBBY;

sys/dev/audio/audiodef.h

343

KASSERTMSG(ring->fmt.stride == sizeof(aint_t) * NBBY,

sys/dev/audio/audiodef.h

345

ring->fmt.stride, sizeof(aint_t) * NBBY);

sys/dev/audio/audiodef.h

358

KASSERTMSG(ring->fmt.stride == sizeof(aint_t) * NBBY,

sys/dev/audio/audiodef.h

360

ring->fmt.stride, sizeof(aint_t) * NBBY);

sys/dev/audio/audiodef.h

374

ring->head * ring->fmt.channels * ring->fmt.stride / NBBY;

sys/dev/audio/audiodef.h

387

auring_tail(ring) * ring->fmt.channels * ring->fmt.stride / NBBY;

sys/dev/fdt/fdt_boot.c

329

MIN(256, efirng_size*NBBY/2));

sys/dev/fss.c

549

kmem_zalloc(howmany(sc->sc_clcount, NBBY), KM_SLEEP);

sys/dev/fss.c

560

kmem_zalloc(howmany(sc->sc_indir_size, NBBY), KM_SLEEP);

sys/dev/fss.c

601

kmem_free(sc->sc_copied, howmany(sc->sc_clcount, NBBY));

sys/dev/fss.c

617

kmem_free(sc->sc_indir_valid, howmany(sc->sc_indir_size, NBBY));

sys/dev/fss.c

739

bits = sizeof(sc->sc_bs_bshift)*NBBY;

sys/dev/hid/hid.c

454

if (data < (1UL << (hsize - 1)) || hsize == sizeof(data) * NBBY)

sys/dev/hid/hid.c

478

if (hsize < sizeof(data) * NBBY)

sys/dev/ic/amdccp.c

92

rnd_add_data_sync(&sc->sc_rndsource, buf, cntby, cntby * NBBY);

sys/dev/ic/ath.c

1675

keyix = i*NBBY;

sys/dev/ic/ath.c

1687

if (keyix == (i+1)*NBBY) {

sys/dev/ic/ath.c

1730

keyix = i*NBBY;

sys/dev/ic/ath.c

1739

if (keyix == (i+1)*NBBY) {

sys/dev/ic/ath.c

1776

keyix = i*NBBY;

sys/dev/ic/athvar.h

87

#define ATH_KEYBYTES (ATH_KEYMAX/NBBY) /* storage space in bytes */

sys/dev/ic/bt485.c

351

icount = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;

sys/dev/ic/bt485.c

383

count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;

sys/dev/ic/bt485.c

431

count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;

sys/dev/ic/bt485.c

513

count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;

sys/dev/ic/bwi.c

9435

pkt_bitlen = pkt_len * NBBY;

sys/dev/ic/bwi.c

9447

if (pkt_bitlen1 - pkt_bitlen >= NBBY)

sys/dev/ic/bwi.c

9553

((frmlen) * NBBY) + \

sys/dev/ic/bwi.c

9571

#define IEEE80211_CCK_NBITS(frmlen) ((frmlen) * NBBY)

sys/dev/ic/cac.c

192

if (sc->sc_nunits > sizeof(sc->sc_unitmask) * NBBY)

sys/dev/ic/cac.c

193

sc->sc_nunits = sizeof(sc->sc_unitmask) * NBBY;

sys/dev/ic/igsfb.c

1196

howmany(dc->dc_depth, NBBY) - 1);

sys/dev/ic/igsfb.c

371

howmany(dc->dc_depth, NBBY) - 1);

sys/dev/ic/igsfb.c

637

*(int *)data = dc->dc_width * howmany(dc->dc_maxdepth, NBBY);

sys/dev/ic/igsfb_subr.c

513

bytes_per_pixel = howmany(depth, NBBY);

sys/dev/ic/igsfb_subr.c

662

dc->dc_stride = dc->dc_width * howmany(depth, NBBY);

sys/dev/ic/rng200.c

96

sizeof(data), sizeof(data) * NBBY);

sys/dev/ic/tpm.c

610

CTASSERT(sizeof(response.bytes) <= UINT_MAX/(NBBY/2));

sys/dev/ic/tpm.c

611

entropybits = (NBBY/2)*nbytes;

sys/dev/ic/tpm.c

748

CTASSERT(sizeof(response.bytes) <= UINT_MAX/(NBBY/2));

sys/dev/ic/tpm.c

749

entropybits = (NBBY/2)*nbytes;

sys/dev/ic/tpm.c

779

for (; nbytes; nbytes -= MIN(nbytes, MAX(1, entropybits/NBBY))) {

sys/dev/ic/tpm.c

816

if (atomic_swap_uint(&sc->sc_rndpending, MIN(nbytes, UINT_MAX/NBBY))

sys/dev/marvell/if_mvgbe.c

2148

for (byte = *data++, bit = NBBY-1; bit >= 0; bit--)

sys/dev/marvell/if_mvxpe.c

2683

for (byte = *data++, bit = NBBY-1; bit >= 0; bit--)

sys/dev/mca/ed_mca.c

224

(bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {

sys/dev/pad/pad.c

594

framesize = PADCHAN * (PADPREC / NBBY) * PADFREQ;

sys/dev/pad/pad.c

761

switch (howmany(bits, NBBY)) {

sys/dev/pci/amdpm.c

229

sizeof(rngreg), sizeof(rngreg) * NBBY);

sys/dev/pci/amdpm.c

233

for (i = 0; i < sizeof(rngreg); i++, rngreg >>= NBBY)

sys/dev/pci/auixp.c

429

bs = rounddown(bs, param->channels * param->precision / NBBY);

sys/dev/pci/eso.c

1660

sc->sc_pdrain = (blksize * NBBY * hz) /

sys/dev/pci/eso.c

1738

sc->sc_rdrain = (blksize * NBBY * hz) /

sys/dev/pci/gcscaudio.c

555

blk = rounddown(blk, param->channels * param->precision / NBBY);

sys/dev/pci/hifn7751.c

549

sc->sc_rng_needbits = MAX(sc->sc_rng_needbits, NBBY*bytes);

sys/dev/pci/hifn7751.c

657

entropybits = NBBY*sizeof(num)/HIFN_RNG_BITSPER;

sys/dev/pci/hifn7751.c

695

entropybits = NBBY*sizeof(num)/HIFN_RNG_BITSPER;

sys/dev/pci/hifn7751var.h

170

uint8_t sc_sessions[2048/NBBY];

sys/dev/pci/if_iwmvar.h

440

uint8_t sc_ucode_api[howmany(IWM_NUM_UCODE_TLV_API, NBBY)];

sys/dev/pci/if_iwmvar.h

441

uint8_t sc_enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];

sys/dev/pci/if_mcx.c

3778

CTASSERT(MCX_ISSI < NBBY);

sys/dev/pci/if_mcx.c

8638

for (i = 0; i < sizeof(map) * NBBY; i++) {

sys/dev/pci/tga.c

816

count = (cursorp->size.y * 64 * 2) / NBBY;

sys/dev/pci/tga.c

843

count = ((64 * 2) / NBBY) * cursorp->size.y;

sys/dev/pci/tga.c

871

count = (cursorp->size.y * 64 * 2) / NBBY;

sys/dev/pci/ubsec.c

1942

rnd_add_data_intr(&sc->sc_rnd_source, (char *)p, i, i * NBBY);

sys/dev/pci/viornd.c

250

VIORND_BUFSIZE * NBBY);

sys/dev/raidframe/raidframevar.h

621

#define RF_PARITYMAP_NBYTE howmany(RF_PARITYMAP_NREG, NBBY)

sys/dev/raidframe/rf_paritymap.c

198

for (j = 0; j < NBBY; j++)

sys/dev/raidframe/rf_paritymap.c

199

if (pm->current->state[i * NBBY + j] != 0)

sys/dev/random.c

282

rnd_add_data(&user_rndsource, buf, n, privileged ? n*NBBY : 0);

sys/dev/sun/cgsix.c

738

count = cc->cc_size.y * 32 / NBBY;

sys/dev/sun/cgsix.c

780

count = p->size.y * 32 / NBBY;

sys/dev/sun/cgsix.c

805

count = p->size.y * 32 / NBBY;

sys/dev/usb/ehcivar.h

238

return (val >> ((offset & 3) * NBBY)) & 0xff;

sys/dev/usb/ehcivar.h

251

return (val >> ((offset & 3) * NBBY)) & 0xffff;

sys/dev/usb/ehcivar.h

261

const uint32_t mask = 0xffU << ((offset & 3) * NBBY);

sys/dev/usb/ehcivar.h

277

const uint32_t mask = 0xffffU << ((offset & 3) * NBBY);

sys/dev/usb/ualea.c

264

rnd_add_data(&sc->sc_rnd, pkt, pktsize, NBBY*pktsize);

sys/dev/usb/ukbd.c

92

uint8_t keys[MAXKEYS/NBBY];

sys/dev/usb/uxrcom.c

88

#define XR_UART_BLOCK(sc) (((sc)->sc_ctl_iface_no / 2) << NBBY)

sys/dev/usb/xhci.c

1274

sc->sc_ctlrportbus[cp / NBBY] |=

sys/dev/usb/xhci.c

1275

bus == 0 ? 0 : __BIT(cp % NBBY);

sys/dev/usb/xhci.c

1476

howmany(sc->sc_maxports * sizeof(uint8_t), NBBY), KM_SLEEP);

sys/dev/usb/xhci.c

2404

p[rhp / NBBY] |= 1 << (rhp % NBBY);

sys/dev/usb/xhci.c

294

return (val >> ((offset & 3) * NBBY)) & 0xff;

sys/dev/usb/xhci.c

306

return (val >> ((offset & 3) * NBBY)) & 0xffff;

sys/dev/usb/xhci.c

323

const uint32_t mask = 0xffU << ((offset & 3) * NBBY);

sys/dev/usb/xhci.c

591

const uint8_t bit = __BIT(port % NBBY);

sys/dev/usb/xhci.c

593

return __SHIFTOUT(sc->sc_ctlrportbus[port / NBBY], bit);

sys/dev/usb/xhci.c

677

howmany(sc->sc_maxports * sizeof(uint8_t), NBBY));

sys/fs/ptyfs/ptyfs_subr.c

201

if (pty >= pmnt->pmnt_bitmap_size * NBBY) {

sys/fs/ptyfs/ptyfs_subr.c

205

nsize = roundup(howmany(pty + 1, NBBY), 64);

sys/fs/ptyfs/ptyfs_subr.c

208

if (pty < pmnt->pmnt_bitmap_size * NBBY) {

sys/fs/ptyfs/ptyfs_subr.c

240

if (pty >= 0 && pty < pmnt->pmnt_bitmap_size * NBBY)

sys/fs/ptyfs/ptyfs_subr.c

256

while (pty < pmnt->pmnt_bitmap_size * NBBY) {

sys/kern/kern_clock.c

158

atomic_store_relaxed(&C->needed, 2*NBBY*needed);

sys/kern/kern_entropy.c

129

#define MINENTROPYBITS (MINENTROPYBYTES*NBBY)

sys/kern/kern_entropy.c

1609

unsigned cost = MIN(len, ENTROPY_CAPACITY)*NBBY;

sys/kern/kern_entropy.c

2150

KASSERTMSG(howmany(entropybits, NBBY) <= len,

sys/kern/kern_entropy.c

2198

KASSERTMSG(howmany(entropybits, NBBY) <= len,

sys/kern/kern_entropy.c

2562

pstat->threshold = MINENTROPYBITS/NBBY; /* bytes */

sys/kern/kern_entropy.c

2563

pstat->maxentropy = ENTROPY_CAPACITY*NBBY; /* bits */

sys/kern/kern_entropy.c

2780

if (rdata->len > MIN(sizeof(rdata->data), UINT32_MAX/NBBY))

sys/kern/kern_entropy.c

2800

MIN(rdata->len, ENTROPY_CAPACITY)*NBBY);

sys/kern/kern_entropy.c

610

if (howmany(seed->entropy, NBBY) > sizeof(seed->data)) {

sys/kern/kern_entropy.c

612

if (howmany(seed->entropy, NBBY) > sizeof(seed->data))

sys/kern/kern_entropy.c

927

KASSERTMSG(howmany(nbits, NBBY) <= len,

sys/kern/kern_entropy.c

998

KASSERTMSG(howmany(nbits, NBBY) <= len,

sys/kern/kern_pax.c

101

#define PAX_ASLR_DELTA_MMAP_LEN ((sizeof(void *) * NBBY) / 2)

sys/kern/kern_pax.c

104

#define PAX_ASLR_DELTA_MMAP_LEN32 ((sizeof(uint32_t) * NBBY) / 2)

sys/kern/kern_pax.c

110

#define PAX_ASLR_DELTA_STACK_LEN ((sizeof(void *) * NBBY) / 4)

sys/kern/kern_pax.c

113

#define PAX_ASLR_DELTA_STACK_LEN32 ((sizeof(uint32_t) * NBBY) / 4)

sys/kern/subr_hash.c

102

#define MAXELEMENTS (1U << ((sizeof(elements) * NBBY) - 1))

sys/kern/tty_subr.c

304

scp = cp + off / NBBY;

sys/kern/tty_subr.c

305

sbi = off % NBBY;

sys/kern/tty_subr.c

306

end = off + len + NBBY - 1;

sys/kern/tty_subr.c

307

ecp = cp + end / NBBY - 1;

sys/kern/tty_subr.c

308

ebi = end % NBBY + 1;

sys/kern/tty_subr.c

57

#define QMEM(n) ((((n)-1)/NBBY)+1)

sys/lib/libsa/subr_prf.c

314

char *p, buf[(sizeof(INTMAX_T) * NBBY / 3) + 1 + 2 /* ALT + SIGN */];

sys/net/bpf.h

370

__CTASSERT(BPF_MEMWORDS + 2 <= sizeof(bpf_memword_init_t) * NBBY);

sys/net/bpf.h

379

__CTASSERT(BPF_MAX_MEMWORDS + 2 <= sizeof(bpf_memword_init_t) * NBBY);

sys/net/if_wg.c

4322

offsetof(struct sockaddr_in, sin_addr) * NBBY);

sys/net/if_wg.c

4329

offsetof(struct sockaddr_in6, sin6_addr) * NBBY);

sys/net/if_wg.c

433

#define SLIWIN_BPW (NBBY*sizeof(SLIWIN_TYPE))

sys/net/if_wg.c

435

#define SLIWIN_NPKT (SLIWIN_BITS - NBBY*sizeof(SLIWIN_TYPE))

sys/net/link_proto.c

167

else if (iflr->prefixlen != NBBY * ifp->if_addrlen)

sys/net/toeplitz.c

134

#define NBSK (NBBY * sizeof(stoeplitz_key))

sys/net/toeplitz.c

150

uint16_t column[NBBY];

sys/net/toeplitz.c

156

for (b = 0; b < NBBY; ++b)

sys/net/toeplitz.c

163

for (b = 0; b < NBBY; ++b) {

sys/net/toeplitz.c

164

shift = NBBY - b - 1;

sys/net80211/ieee80211.c

112

ic->ic_vap += NBBY;

sys/net80211/ieee80211.c

130

IASSERT(ic->ic_vap < sizeof(ieee80211_vapmap)*NBBY,

sys/net80211/ieee80211_crypto_ccmp.c

131

if (k->wk_keylen != (128/NBBY)) {

sys/net80211/ieee80211_crypto_ccmp.c

134

__func__, k->wk_keylen, 128/NBBY);

sys/net80211/ieee80211_crypto_tkip.c

144

if (k->wk_keylen != (128/NBBY)) {

sys/net80211/ieee80211_crypto_tkip.c

148

__func__, k->wk_keylen, 128/NBBY);

sys/net80211/ieee80211_crypto_wep.c

120

return k->wk_keylen >= 40/NBBY;

sys/net80211/ieee80211_input.c

1590

*keylen = 40 / NBBY;

sys/net80211/ieee80211_input.c

1594

*keylen = 104 / NBBY;

sys/net80211/ieee80211_input.c

1759

*keylen = 40 / NBBY;

sys/net80211/ieee80211_input.c

1763

*keylen = 104 / NBBY;

sys/net80211/ieee80211_node.c

170

rsn->rsn_ucastkeylen = 104 / NBBY;

sys/net80211/ieee80211_node.c

177

rsn->rsn_mcastkeylen = 128 / NBBY;

sys/netinet/in.c

1018

if (sizeof(struct in_addr) * NBBY < iflr->prefixlen)

sys/netinet/in.c

374

for (y = 0; y < NBBY; y++) {

sys/netinet/in.c

379

return x * NBBY + y;

sys/netinet/in.c

390

for (i = 0; i < len / NBBY; i++)

sys/netinet/in.c

392

if (len % NBBY)

sys/netinet/in.c

393

p[i] = (0xff00 >> (len % NBBY)) & 0xff;

sys/netinet/tcp_vtw.h

166

#define FATP_NXT_WIDTH (sizeof(fatp_word_t) * NBBY - FATP_NTAGS)

sys/netinet6/in6.c

1608

if (sizeof(struct in6_addr) * NBBY < iflr->prefixlen)

sys/netinet6/in6.c

2089

match += NBBY;

sys/netinet6/in6.c

2096

static const u_char maskarray[NBBY] = {0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};

sys/netinet6/in6.c

2107

bytelen = len / NBBY;

sys/netinet6/in6.c

2108

bitlen = len % NBBY;

sys/netinet6/in6.c

376

for (y = 0; y < NBBY; y++) {

sys/netinet6/in6.c

394

return x * NBBY + y;

sys/netinet6/in6.c

656

(time_t)~(1ULL << ((sizeof(maxexpire) * NBBY) - 1));

sys/netinet6/in6.c

677

(time_t)~(1ULL << ((sizeof(maxexpire) * NBBY) - 1));

sys/netinet6/in6.c

989

32 / NBBY)) {

sys/netinet6/ip6_mroute.h

83

#define NIFBITS (sizeof(if_mask) * NBBY) /* bits per mask */

sys/rump/librump/rumpkern/hyperentropy.c

57

rnd_add_data_sync(&rndsrc, rnddata, n, NBBY*n);

sys/sys/bitops.h

301

#define __BITMAP_BITS(__t) (sizeof(__t) * NBBY)

sys/sys/kprintf.h

49

#define KPRINTF_BUFSIZE (sizeof(quad_t) * NBBY / 3 + 2)

sys/sys/param.h

424

#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))

sys/sys/param.h

425

#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))

sys/sys/param.h

426

#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))

sys/sys/param.h

427

#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)

sys/sys/rngtest.h

37

#define FIPS140_RNG_TEST_BYTES (FIPS140_RNG_TEST_BITS / NBBY)

sys/ufs/ext2fs/ext2fs_alloc.c

388

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

391

end = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;

sys/ufs/ext2fs/ext2fs_alloc.c

394

bno = loc * NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

400

bno = loc * NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

478

start = ipref / NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

479

len = howmany(fs->e2fs.e2fs_ipg - ipref, NBBY);

sys/ufs/ext2fs/ext2fs_alloc.c

498

ipref = i * NBBY + ffs(map) - 1;

sys/ufs/ext2fs/ext2fs_alloc.c

626

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ext2fs/ext2fs_alloc.c

629

len = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;

sys/ufs/ext2fs/ext2fs_alloc.c

648

return i * NBBY + ffs(map) - 1;

sys/ufs/ffs/ffs_alloc.c

1352

start = irotor / NBBY;

sys/ufs/ffs/ffs_alloc.c

1353

len = howmany(maxiblk - irotor, NBBY);

sys/ufs/ffs/ffs_alloc.c

1372

ipref = i * NBBY + ffs(map) - 1;

sys/ufs/ffs/ffs_alloc.c

2176

start = dtogd(fs, bpref) / NBBY;

sys/ufs/ffs/ffs_alloc.c

2178

start = ufs_rw32(cgp->cg_frotor, needswap) / NBBY;

sys/ufs/ffs/ffs_alloc.c

2180

len = howmany(fs->fs_fpg, NBBY) - start;

sys/ufs/ffs/ffs_alloc.c

2186

(1 << (allocsiz - 1 + (fs->fs_frag & (NBBY - 1)))));

sys/ufs/ffs/ffs_alloc.c

2193

(1 << (allocsiz - 1 + (fs->fs_frag & (NBBY - 1)))));

sys/ufs/ffs/ffs_alloc.c

2203

bno = (start + len - loc) * NBBY;

sys/ufs/ffs/ffs_alloc.c

2209

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

sys/ufs/ffs/ffs_snapshot.c

926

fs->fs_active = malloc(howmany(fs->fs_ncg, NBBY),

sys/ufs/ffs/ffs_subr.c

154

if ((inblk & (1 << (siz + (fs->fs_frag & (NBBY - 1))))) == 0)

sys/ufs/ffs/ffs_subr.c

314

mapp = &freemapp[start / NBBY];

sys/ufs/ffs/ffs_subr.c

316

bit = 1U << ((unsigned int)start % NBBY);

sys/ufs/ffs/ffs_subr.c

320

if ((i & (NBBY - 1)) != (NBBY - 1)) {

sys/ufs/ffs/ffs_subr.c

335

mapp = &freemapp[start / NBBY];

sys/ufs/ffs/ffs_subr.c

337

bit = 1U << ((unsigned int)start % NBBY);

sys/ufs/ffs/ffs_subr.c

341

if ((i & (NBBY - 1)) != 0) {

sys/ufs/ffs/ffs_subr.c

345

bit = 1U << (NBBY - 1);

sys/ufs/ffs/fs.h

483

/* inode map */ howmany((ipg), NBBY) + \

sys/ufs/ffs/fs.h

484

/* block map */ howmany((fpg), NBBY) +\

sys/ufs/ffs/fs.h

487

/* cluster map */ howmany(ffs_fragstoblks(fs, (fpg)), NBBY)))

sys/ufs/ffs/fs.h

668

(((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))

sys/uvm/pmap/pmap_tlb.c

852

const size_t nbpw = NBBY * sizeof(ti->ti_asid_bitmap._b[0]);

sys/uvm/uvm_mmap.c

922

if (align >= sizeof(vaddr_t) * NBBY)

sys/uvm/uvm_mremap.c

149

if (alignshift >= sizeof(vaddr_t) * NBBY)

tests/modules/t_ufetchstore.c

331

#define test_cell_val8 ((unsigned long)test_pattern8 << (index8 * NBBY))

tests/modules/t_ufetchstore.c

332

#define test_cell_val16 ((unsigned long)test_pattern16 << (index16 * NBBY*2))

tests/modules/t_ufetchstore.c

333

#define test_cell_val32 ((unsigned long)test_pattern32 << (index32 * NBBY*4))

tests/modules/t_ufetchstore.c

341

#define test_cell_val8 ((unsigned long)test_pattern8 << (56-(index8 * NBBY)))

tests/modules/t_ufetchstore.c

342

#define test_cell_val16 ((unsigned long)test_pattern16 << (48-(index16 * NBBY*2)))

tests/modules/t_ufetchstore.c

343

#define test_cell_val32 ((unsigned long)test_pattern32 << (32-(index32 * NBBY*4)))

tests/modules/t_ufetchstore.c

346

#define test_cell_val8 ((unsigned long)test_pattern8 << (24-(index8 * NBBY)))

tests/modules/t_ufetchstore.c

347

#define test_cell_val16 ((unsigned long)test_pattern16 << (16-(index16 * NBBY*2)))

tests/modules/ufetchstore/t_ufetchstore.c

331

#define test_cell_val8 ((unsigned long)test_pattern8 << (index8 * NBBY))

tests/modules/ufetchstore/t_ufetchstore.c

332

#define test_cell_val16 ((unsigned long)test_pattern16 << (index16 * NBBY*2))

tests/modules/ufetchstore/t_ufetchstore.c

333

#define test_cell_val32 ((unsigned long)test_pattern32 << (index32 * NBBY*4))

tests/modules/ufetchstore/t_ufetchstore.c

341

#define test_cell_val8 ((unsigned long)test_pattern8 << (56-(index8 * NBBY)))

tests/modules/ufetchstore/t_ufetchstore.c

342

#define test_cell_val16 ((unsigned long)test_pattern16 << (48-(index16 * NBBY*2)))

tests/modules/ufetchstore/t_ufetchstore.c

343

#define test_cell_val32 ((unsigned long)test_pattern32 << (32-(index32 * NBBY*4)))

tests/modules/ufetchstore/t_ufetchstore.c

346

#define test_cell_val8 ((unsigned long)test_pattern8 << (24-(index8 * NBBY)))

tests/modules/ufetchstore/t_ufetchstore.c

347

#define test_cell_val16 ((unsigned long)test_pattern16 << (16-(index16 * NBBY*2)))

tools/compat/compat_defs.h

1298

#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))

tools/compat/compat_defs.h

1299

#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))

tools/compat/compat_defs.h

1300

#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))

tools/compat/compat_defs.h

1301

#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)

tools/compat/compat_defs.h

1397

#ifndef NBBY

tools/compat/compat_defs.h

226

#define __type_min_s(t) ((t)((1ULL << (sizeof(t) * NBBY - 1))))

tools/compat/compat_defs.h

228

#define __type_max_s(t) ((t)~((1ULL << (sizeof(t) * NBBY - 1))))

usr.bin/vndcompress/common.h

46

(~((1ULL << (sizeof(t) * NBBY)) - 1)) : 0ULL)

usr.bin/vndcompress/common.h

51

#define __type_min_s(t) ((t)((1ULL << (sizeof(t) * NBBY - 1))))

usr.bin/vndcompress/common.h

52

#define __type_max_s(t) ((t)~((1ULL << (sizeof(t) * NBBY - 1))))

usr.sbin/makefs/ffs/ffs_alloc.c

575

start = dtogd(fs, bpref) / NBBY;

usr.sbin/makefs/ffs/ffs_alloc.c

577

start = ufs_rw32(cgp->cg_frotor, needswap) / NBBY;

usr.sbin/makefs/ffs/ffs_alloc.c

578

len = howmany(fs->fs_fpg, NBBY) - start;

usr.sbin/makefs/ffs/ffs_alloc.c

584

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

591

(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));

usr.sbin/makefs/ffs/ffs_alloc.c

600

bno = (start + len - loc) * NBBY;

usr.sbin/makefs/ffs/ffs_alloc.c

606

for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {

usr.sbin/timed/timed/correct.c

146

~((1 << ((sizeof(long) * NBBY) - smoother))