CHAR_BIT
#define BITS(t) (CHAR_BIT * sizeof(t))
#define BITS_PER_INT (sizeof(int) * CHAR_BIT)
if (sizeof(int) * CHAR_BIT == 32 &&
sizeof(long) * CHAR_BIT == 32 &&
sizeof(void *) * CHAR_BIT == 32 &&
sizeof(off_t) * CHAR_BIT >= 64)
if (sizeof(int) * CHAR_BIT == 32 &&
sizeof(long) * CHAR_BIT == 64 &&
sizeof(void *) * CHAR_BIT == 64 &&
sizeof(off_t) * CHAR_BIT == 64)
if (sizeof(int) * CHAR_BIT >= 32 &&
sizeof(long) * CHAR_BIT >= 64 &&
sizeof(void *) * CHAR_BIT >= 64 &&
sizeof(off_t) * CHAR_BIT >= 64)
if (sizeof(int) * CHAR_BIT == 32 &&
sizeof(long) * CHAR_BIT == 32 &&
sizeof(void *) * CHAR_BIT == 32 &&
sizeof(off_t) * CHAR_BIT >= 64)
if (sizeof(int) * CHAR_BIT == 32 &&
sizeof(long) * CHAR_BIT == 64 &&
sizeof(void *) * CHAR_BIT == 64 &&
sizeof(off_t) * CHAR_BIT == 64)
if (sizeof(int) * CHAR_BIT >= 32 &&
sizeof(long) * CHAR_BIT >= 64 &&
sizeof(void *) * CHAR_BIT >= 64 &&
sizeof(off_t) * CHAR_BIT >= 64)
#define QUAD_BITS (sizeof(quad_t) * CHAR_BIT)
#define INT_BITS (sizeof(int) * CHAR_BIT)
#define HALF_BITS (sizeof(int) * CHAR_BIT / 2)
p->ncsalloc += CHAR_BIT;
assert(nc % CHAR_BIT == 0);
ptr = reallocarray(p->g->setbits, nc / CHAR_BIT, css);
nbytes = (nc / CHAR_BIT) * css;
p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
cs->mask = 1 << ((no) % CHAR_BIT);
# define BACKSL (1<<CHAR_BIT)
if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
return (sizeof(int) * CHAR_BIT - 1) - __builtin_clz(x);
int lt = (p1[i] - p2[i]) >> CHAR_BIT;
int gt = (p2[i] - p1[i]) >> CHAR_BIT;
#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
if ((unsigned)rv >= CHAR_BIT * sizeof(unsigned)) {
mask = ((unsigned)-1) << (CHAR_BIT * sizeof(unsigned) - rv);
inomapsize = howmany(fs->fs_ipg, CHAR_BIT);
blkmapsize = howmany(fs->fs_fpg, CHAR_BIT);
howmany(fragstoblks(fs, fs->fs_fpg), CHAR_BIT);
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
if ((i & (CHAR_BIT - 1)) != CHAR_BIT - 1)
for (n = 0; n < sizeof(n) * CHAR_BIT; n++)
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
for (i = 0; i < CHAR_BIT; i++) { /* Walking zero */
for (i = 0; i < CHAR_BIT; i++) { /* Walking one */
for (i = 0; i < CHAR_BIT; i++) { /* Walking zero */
for (i = 0; i < CHAR_BIT; i++) { /* Walking one */
CTASSERT((CHAR_BIT * sizeof(struct list_head *)) <= 64);
const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
const int bits_in_dword_2 = (int)(sizeof(di_int) * CHAR_BIT) / 2;
#define QUAD_BITS (sizeof(quad_t) * CHAR_BIT)
#define INT_BITS (sizeof(int) * CHAR_BIT)
#define HALF_BITS (sizeof(int) * CHAR_BIT / 2)
return (sizeof(x) * CHAR_BIT - 1) - __builtin_clz(x);
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
howmany(sblock.fs_fpg, CHAR_BIT);
howmany(sblock.fs_fpg, CHAR_BIT) - sizeof(int32_t);
howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
if ((i & (CHAR_BIT - 1)) != (CHAR_BIT - 1)) {
for (n = 0; n < sizeof(n) * CHAR_BIT; n++)
n += ((srcset2->size % CHAR_BIT) != 0);
mask = (1 << ((srcset2->size % CHAR_BIT) + 1)) - 1;
return (bits / CHAR_BIT) + ((bits % CHAR_BIT) != 0) + sizeof(size_t);
return (bset->bits[ (bit / CHAR_BIT) ] & (1 << (bit % CHAR_BIT))) != 0;
bset->bits[ (bit / CHAR_BIT) ] |= (1 << (bit % CHAR_BIT));
bset->bits[ (bit / CHAR_BIT) ] &= ~(1 << (bit % CHAR_BIT));
bytes = (size / CHAR_BIT) + ((size % CHAR_BIT) != 0);
n = (srcset1->size / CHAR_BIT);
n += ((srcset1->size % CHAR_BIT) != 0);
mask = (1 << ((srcset1->size % CHAR_BIT) + 1)) - 1;
n = (srcset2->size / CHAR_BIT);