NBBY
shft = i * NBBY;
shft = i * NBBY;
pa = (idx * sizeof(*base) * NBBY + bit) * PAGE_SIZE;
#define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
cp = &cg_inosused(&cgrp)[(sblock.fs_ipg - 1) / NBBY];
for ( ; inosused > 0; inosused -= NBBY, cp--) {
for (i = 1 << (NBBY - 1); i > 0; i >>= 1) {
mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -
blkmapsize = howmany(fs->fs_fpg, NBBY);
newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);
howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY);
howmany(fs->fs_cpg * fs->fs_spc / NSPB(fs), NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
for (k = 0; k < NBBY; k++) {
c * fs->fs_ipg + i * NBBY + k);
for (k = 0; k < NBBY; k++) {
c * fs->fs_fpg + i * NBBY + k);
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
e=howmany((sb->fs_cpg * sb->fs_spc / NSPF(sb)), NBBY);
e=howmany(sb->fs_cpg * sb->fs_spc / NSPB(sb), NBBY);
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
howmany(sblock.fs_cpg* sblock.fs_spc/ NSPF(&sblock), NBBY);
(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -
(sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
uint8_t afmask[howmany(AF_MAX, NBBY)];
uint8_t afmask[howmany(AF_MAX, NBBY)];
#define MAXIPG(fs) roundup((fs)->fs_bsize * NBBY / 3, INOPB(fs))
sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY);
(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -
(sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1;
map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
#define ACTIVECGNUM(fs, cg) ((fs)->fs_active[(cg) / (NBBY * sizeof(int))])
#define ACTIVECGOFF(cg) (1 << ((cg) % (NBBY * sizeof(int))))
/* inode map */ howmany((fs)->fs_ipg, NBBY) + \
/* block map */ howmany((fs)->fs_fpg, NBBY) +\
/* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))
(((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
CTASSERT(bus_timing_max <= sizeof(uint32_t) * NBBY);
#define NBLONG (NBBY * sizeof(long))
var += bit / (sizeof(long) * NBBY);
bit %= sizeof(long) * NBBY;
const unsigned int units = (sizeof(*ptr) * NBBY);
var += bit / (sizeof(long) * NBBY);
bit %= sizeof(long) * NBBY;
howmany(sizeof(long) * NBBY, RADIX_TREE_MAP_SHIFT)
keyix = i*NBBY;
if (keyix == (i+1)*NBBY) {
keyix = i*NBBY;
if (keyix == (i+1)*NBBY) {
keyix = i*NBBY;
#define ATH_KEYBYTES (ATH_KEYMAX/NBBY) /* storage space in bytes */
#ifndef NBBY
if (k->kv_len < 40 / NBBY)
if (k->kv_len <= 40 / NBBY)
else if (k->kv_len <= 104 / NBBY)
if (k->kv_len <= 104 / NBBY)
if (k->kv_len < 40 / NBBY) {
if (k->kv_len <= 40 / NBBY)
else if (k->kv_len <= 104 / NBBY)
if (k->kv_len <= 104 / NBBY)
if (k->kv_len < 40 / NBBY) {
if (k->kv_len <= 40 / NBBY)
else if (k->kv_len <= 104 / NBBY)
if (k->kv_len <= 104 / NBBY)
uint8_t enabled_api[howmany(IWM_NUM_UCODE_TLV_API, NBBY)];
uint8_t enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];
#define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
root = rn_newpair(rn_zeros, off_bytes * NBBY, rnh->rnh_nodes);
left->rn_bit = -1 - off_bytes * NBBY;
bit = (i * NBBY) + b + j;
k = key_str[bit / NBBY];
shift = NBBY - (bit % NBBY) - 1;
for (b = 0; b < NBBY; ++b) {
shift = NBBY - b - 1;
uint32_t key[NBBY];
for (b = 0; b < NBBY; ++b) {
#define UNITS_BITSPERWORD (sizeof(*ng_fec_units) * NBBY)
#define UNITS_BITSPERWORD (sizeof(*ng_iface_units) * NBBY)
#define UNITS_BITSPERWORD (sizeof(*ng_iface_units) * NBBY)
#define UNITS_BITSPERWORD (sizeof(*ng_fec_units) * NBBY)
KASSERT ((bit >= 0 && bit < NBBY),
*unit = (index * NBBY) + bit;
index = unit / NBBY;
bit = unit % NBBY;
#define DP_MAPBITS (sizeof(u_int32_t) * NBBY)
#define NIFBITS (sizeof(if_mask) * NBBY) /* bits per mask */
#define IEEE80211_CHAN_BYTES howmany(IEEE80211_CHAN_MAX, NBBY)
#define IEEE80211_MODE_BYTES howmany(IEEE80211_MODE_MAX, NBBY)
#define IEEE80211_CCK_NBITS(frmlen) ((frmlen) * NBBY)
((frmlen) * NBBY) + \
*keylen = 40 / NBBY;
*keylen = 104 / NBBY;
*keylen = 40 / NBBY;
*keylen = 104 / NBBY;
maxchan = ireq->i_len * NBBY;
int ix = aid / NBBY;
if (k->wk_keylen != (128/NBBY)) {
__func__, k->wk_keylen, 128/NBBY);
rijndael_set_key(&ctx->cc_aes, k->wk_key, k->wk_keylen*NBBY);
if (k->wk_keylen != (128/NBBY)) {
__func__, k->wk_keylen, 128/NBBY);
return k->wk_keylen >= 40/NBBY;
asz = gas->BitWidth / NBBY;
if (gas->BitOffset % NBBY != 0)
end = gas->BitWidth / NBBY;
reg = gas->BitOffset / NBBY;
reg = res->pr_gas.BitOffset / NBBY;
reg = res->pr_gas.BitOffset / NBBY;
pa = (((uint64_t)i * sizeof(*vm_page_dump) * NBBY) + bit) * PAGE_SIZE;
pa = (((uint64_t)i * sizeof(*vm_page_dump) * NBBY) + bit) * PAGE_SIZE;
#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))
#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))
#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
start = dtogd(fs, bpref) / NBBY;
end = howmany(fs->e2fs_fpg, NBBY) - start;
runlen = NBBY - bit;
runstart = loc * NBBY + bit;
runlen += NBBY;
runlen = NBBY - bit;
runstart = loc * NBBY + bit;
loc = bpref / NBBY;
bit = 1 << (bpref % NBBY);
if ((got & (NBBY - 1)) != (NBBY - 1))
start = ipref / NBBY;
len = howmany(fs->e2fs_ipg - ipref, NBBY);
ipref = (loc - ibp) * NBBY + ffs(~*loc) - 1;
start = dtogd(fs, bpref) / NBBY;
len = howmany(fs->e2fs_fpg, NBBY) - start;
return ((loc - bbp) * NBBY + ffs(~*loc) - 1);
if ((i & (NBBY - 1)) != (NBBY - 1))
loc = start / NBBY;
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1))
loc = start / NBBY;
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != 0)
bit = 1 << (NBBY - 1);
mapp = &cg_clustersfree(cgp)[bpref / NBBY];
bit = 1 << (bpref % NBBY);
if ((got & (NBBY - 1)) != (NBBY - 1)) {
for (i = 0; i < NBBY; ++i) {
start = dtogd(fs, bpref) / NBBY;
start = cgp->cg_frotor / NBBY;
len = howmany(fs->fs_fpg, NBBY) - start;
(u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
(u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
bno = (start + len - loc) * NBBY;
for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != 0) {
bit = 1 << (NBBY - 1);
if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
/* inode map */ howmany((fs)->fs_ipg, NBBY) + \
/* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY) +\
/* cluster map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPB(fs), NBBY)))
(((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
vm_page_dump_size = round_page(roundup2(page_range, NBBY) / NBBY);
#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))
#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))
#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
u_int8_t ismic[128/NBBY];
uint32_t key[NBBY];
#ifndef NBBY
for (b = 0; b < NBBY; ++b) {
bit = (i * NBBY) + b + j;
k = key_str[bit / NBBY];
shift = NBBY - (bit % NBBY) - 1;
for (b = 0; b < NBBY; ++b) {
shift = NBBY - b - 1;
/* inode map */ howmany((fs)->fs_ipg, NBBY) + \
/* block map */ howmany((fs)->fs_fpg, NBBY) +\
/* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))
start = dtogd(fs, bpref) / NBBY;
start = ufs_rw32(cgp->cg_frotor, needswap) / NBBY;
len = howmany(fs->fs_fpg, NBBY) - start;
(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
bno = (start + len - loc) * NBBY;
for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != 0) {
bit = 1 << (NBBY - 1);
if ((inblk & (1 << (siz + (fs->fs_frag & (NBBY - 1))))) == 0)