---
name: "bitset"
section: "9"
platform: "freebsd"
package: "base"
version: "16.0-CURRENT-20261027-61c70dc16a79"
release: "FreeBSD 16.0-CURRENT (2026-10-27)"
platforms: ["freebsd"]
url: "https://new.carta.tech/BITSET_DEFINE"
---

# bitset(9)

BITSET\_DEFINE, BITSET\_T\_INITIALIZER, BITSET\_FSET, BIT\_CLR, BIT\_COPY, BIT\_ISSET, BIT\_SET, BIT\_ZERO, BIT\_FILL, BIT\_SETOF, BIT\_EMPTY, BIT\_ISFULLSET, BIT\_FFS, BIT\_FFS\_AT, BIT\_FLS, BIT\_FOREACH\_ISSET, BIT\_FOREACH\_ISCLR, BIT\_COUNT, BIT\_SUBSET, BIT\_OVERLAP, BIT\_CMP, BIT\_OR, BIT\_OR2, BIT\_ORNOT, BIT\_ORNOT2, BIT\_AND, BIT\_AND2, BIT\_ANDNOT, BIT\_ANDNOT2, BIT\_XOR, BIT\_XOR2, BIT\_CLR\_ATOMIC, BIT\_SET\_ATOMIC, BIT\_SET\_ATOMIC\_ACQ, BIT\_TEST\_SET\_ATOMIC, BIT\_TEST\_CLR\_ATOMIC, BIT\_AND\_ATOMIC, BIT\_OR\_ATOMIC, BIT\_COPY\_STORE\_REL – bitset manipulation macros

Part of [BITSET\_DEFINE(9)](/BITSET_DEFINE/9.md).

## NAME

**[bitset(9)](/bitset/9.md)** — **BITSET\_DEFINE**, **BITSET\_T\_INITIALIZER**, **BITSET\_FSET**, **BIT\_CLR**, **BIT\_COPY**, **BIT\_ISSET**, **BIT\_SET**, **BIT\_ZERO**, **BIT\_FILL**, **BIT\_SETOF**, **BIT\_EMPTY**, **BIT\_ISFULLSET**, **BIT\_FFS**, **BIT\_FFS\_AT**, **BIT\_FLS**, **BIT\_FOREACH\_ISSET**, **BIT\_FOREACH\_ISCLR**, **BIT\_COUNT**, **BIT\_SUBSET**, **BIT\_OVERLAP**, **BIT\_CMP**, **BIT\_OR**, **BIT\_OR2**, **BIT\_ORNOT**, **BIT\_ORNOT2**, **BIT\_AND**, **BIT\_AND2**, **BIT\_ANDNOT**, **BIT\_ANDNOT2**, **BIT\_XOR**, **BIT\_XOR2**, **BIT\_CLR\_ATOMIC**, **BIT\_SET\_ATOMIC**, **BIT\_SET\_ATOMIC\_ACQ**, **BIT\_TEST\_SET\_ATOMIC**, **BIT\_TEST\_CLR\_ATOMIC**, **BIT\_AND\_ATOMIC**, **BIT\_OR\_ATOMIC**, **BIT\_COPY\_STORE\_REL** – bitset manipulation macros

## SYNOPSIS

**#include \<sys/\_bitset.h\>**

**#include \<sys/bitset.h\>**

**BITSET\_DEFINE**(*STRUCTNAME*, *const SETSIZE*);

**BITSET\_T\_INITIALIZER**(*ARRAY\_CONTENTS*);

**BITSET\_FSET**(*N\_WORDS*);

**BIT\_CLR**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

**BIT\_COPY**(*const SETSIZE*, *struct STRUCTNAME \*from*, *struct STRUCTNAME \*to*);

*bool*\

**BIT\_ISSET**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

**BIT\_SET**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

**BIT\_ZERO**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

**BIT\_FILL**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

**BIT\_SETOF**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

*bool*\

**BIT\_EMPTY**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

*bool*\

**BIT\_ISFULLSET**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

*long*\

**BIT\_FFS**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

*long*\

**BIT\_FFS\_AT**(*const SETSIZE*, *struct STRUCTNAME \*bitset*, *long start*);

*long*\

**BIT\_FLS**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

**BIT\_FOREACH\_ISSET**(*const SETSIZE*, *size\_t bit*, *const struct STRUCTNAME \*bitset*);

**BIT\_FOREACH\_ISCLR**(*const SETSIZE*, *size\_t bit*, *const struct STRUCTNAME \*bitset*);

*long*\

**BIT\_COUNT**(*const SETSIZE*, *struct STRUCTNAME \*bitset*);

*bool*\

**BIT\_SUBSET**(*const SETSIZE*, *struct STRUCTNAME \*haystack*, *struct STRUCTNAME \*needle*);

*bool*\

**BIT\_OVERLAP**(*const SETSIZE*, *struct STRUCTNAME \*bitset1*, *struct STRUCTNAME \*bitset2*);

*bool*\

**BIT\_CMP**(*const SETSIZE*, *struct STRUCTNAME \*bitset1*, *struct STRUCTNAME \*bitset2*);

**BIT\_OR**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_OR2**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src1*, *struct STRUCTNAME \*src2*);

**BIT\_ORNOT**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_ORNOT2**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src1*, *struct STRUCTNAME \*src2*);

**BIT\_AND**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_AND2**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src1*, *struct STRUCTNAME \*src2*);

**BIT\_ANDNOT**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_ANDNOT2**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src1*, *struct STRUCTNAME \*src2*);

**BIT\_XOR**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_XOR2**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src1*, *struct STRUCTNAME \*src2*);

**BIT\_CLR\_ATOMIC**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

**BIT\_SET\_ATOMIC**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

**BIT\_SET\_ATOMIC\_ACQ**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

*bool*\

**BIT\_TEST\_SET\_ATOMIC**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

*bool*\

**BIT\_TEST\_CLR\_ATOMIC**(*const SETSIZE*, *size\_t bit*, *struct STRUCTNAME \*bitset*);

**BIT\_AND\_ATOMIC**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_OR\_ATOMIC**(*const SETSIZE*, *struct STRUCTNAME \*dst*, *struct STRUCTNAME \*src*);

**BIT\_COPY\_STORE\_REL**(*const SETSIZE*, *struct STRUCTNAME \*from*, *struct STRUCTNAME \*to*);

**#define \_WANT\_FREEBSD\_BITSET**

## DESCRIPTION

The **[bitset(9)](/bitset/9.md)** family of macros provide a flexible and efficient bitset implementation if the maximum size of the set is known at compilation. Throughout this manual page, the name *SETSIZE* refers to the size of the bitset in bits. Individual bits in bitsets are referenced with indices zero through *SETSIZE*, *-*, *1*. One example use of ⟨sys/bitset.h⟩ is ⟨sys/cpuset.h⟩.

These macros are meant to be used in the kernel and are visible if \_KERNEL is defined when ⟨sys/\_bitset.h⟩ or ⟨sys/bitset.h⟩ are included in a program. Userland programs must define \_WANT\_FREEBSD\_BITSET before including these files to make the macros visible.

The **BITSET\_DEFINE**() macro defines a bitset struct *STRUCTNAME* with room to represent *SETSIZE* bits.

The **BITSET\_T\_INITIALIZER**() macro allows one to initialize a bitset struct with a compile time literal value.

The **BITSET\_FSET**() macro generates a compile time literal, usable by **BITSET\_T\_INITIALIZER**(), representing a full bitset (all bits set). For examples of **BITSET\_T\_INITIALIZER**() and **BITSET\_FSET**() usage, see the BITSET\_T\_INITIALIZER EXAMPLE section. The *N\_WORDS* parameter to **BITSET\_FSET**() should be:

```
__bitset_words(SETSIZE)
```

The **BIT\_CLR**() macro clears bit *bit* in the bitset pointed to by *bitset*. The **BIT\_CLR\_ATOMIC**() macro is identical, but the bit is cleared atomically. The **BIT\_TEST\_CLR\_ATOMIC**() macro atomically clears the bit and returns whether it was set.

The **BIT\_COPY**() macro copies the contents of the bitset *from* to the bitset *to*. **BIT\_COPY\_STORE\_REL**() is similar, but copies component machine words from *from* and writes them to *to* with atomic store with release semantics. (That is, if *to* is composed of multiple machine words, **BIT\_COPY\_STORE\_REL**() performs multiple individually atomic operations.)

The **BIT\_ISSET**() macro returns true if the bit *bit* in the bitset pointed to by *bitset* is set.

The **BIT\_SET**() macro sets bit *bit* in the bitset pointed to by *bitset*. The **BIT\_SET\_ATOMIC**() macro is identical, but the bit is set atomically. The **BIT\_SET\_ATOMIC\_ACQ**() macro sets the bit with acquire semantics. The **BIT\_TEST\_SET\_ATOMIC**() macro atomically sets the bit and returns whether it was set.

The **BIT\_ZERO**() macro clears all bits in *bitset*.

The **BIT\_FILL**() macro sets all bits in *bitset*.

The **BIT\_SETOF**() macro clears all bits in *bitset* before setting only bit *bit*.

The **BIT\_EMPTY**() macro returns true if *bitset* is empty.

The **BIT\_ISFULLSET**() macro returns true if *bitset* is full (all bits set).

The **BIT\_FFS**() macro returns the 1-index of the first (lowest) set bit in *bitset*, or zero if *bitset* is empty. Like with [ffs(3)](/ffs/3.md), to use the non-zero result of **BIT\_FFS**() as a *bit* index parameter to any other **[bitset(9)](/bitset/9.md)** macro, you must subtract one from the result.

The **BIT\_FFS\_AT**() macro returns the 1-index of the first (lowest) set bit in *bitset*, which is greater than the given 1-indexed *start*, or zero if no bits in *bitset* greater than *start* are set.

The **BIT\_FLS**() macro returns the 1-index of the last (highest) set bit in *bitset*, or zero if *bitset* is empty. Like with [fls(3)](/fls/3.md), to use the non-zero result of **BIT\_FLS**() as a *bit* index parameter to any other **[bitset(9)](/bitset/9.md)** macro, you must subtract one from the result.

The **BIT\_FOREACH\_ISSET**() macro can be used to iterate over all set bits in *bitset*. The index variable *bit* must have been declared with type *int*, and upon each iteration *bit* is set to the index of successive set bits. The value of *bit* after the loop terminates is undefined. Similarly, **BIT\_FOREACH\_ISCLR**() iterates over all clear bits in *bitset*. In the loop body, the currently indexed bit may be set or cleared. However, setting or clearing bits other than the currently indexed bit does not guarantee that they will or will not be returned in subsequent iterations of the same loop.

The **BIT\_COUNT**() macro returns the total number of set bits in *bitset*.

The **BIT\_SUBSET**() macro returns true if *needle* is a subset of *haystack*.

The **BIT\_OVERLAP**() macro returns true if *bitset1* and *bitset2* have any common bits. (That is, if *bitset1* AND *bitset2* is not the empty set.)

The **BIT\_CMP**() macro returns true if *bitset1* is NOT equal to *bitset2*.

The **BIT\_OR**() macro sets bits present in *src* in *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* \|= *src*.) **BIT\_OR\_ATOMIC**() is similar, but sets bits in the component machine words in *dst* atomically. (That is, if *dst* is composed of multiple machine words, **BIT\_OR\_ATOMIC**() performs multiple individually atomic operations.)

The **BIT\_OR2**() macro computes *src1* bitwise or *src2* and assigns the result to *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* = *src1* \| *src2*.)

The **BIT\_ORNOT**() macro sets bits not in *src* in *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* \|= *~*, *src*.)

The **BIT\_ORNOT2**() macro computes *src1* bitwise or not *src2* and assigns the result to *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* = *src1* \| ~ *src2*.)

The **BIT\_AND**() macro clears bits absent from *src* from *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* &= *src*.) **BIT\_AND\_ATOMIC**() is similar, with the same atomic semantics as **BIT\_OR\_ATOMIC**().

The **BIT\_AND2**() macro computes *src1* bitwise and *src2* and assigns the result to *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* = *src1* & *src2*.)

The **BIT\_ANDNOT**() macro clears bits set in *src* from *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* &= *~*, *src*.)

The **BIT\_ANDNOT2**() macro computes *src1* bitwise and not *src2* and assigns the result to *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* = *src1* & ~ *src2*.)

The **BIT\_XOR**() macro toggles bits set in *src* in *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* ^= *src*.)

The **BIT\_XOR2**() macro computes *src1* bitwise exclusive or *src2* and assigns the result to *dst*. (It is the **[bitset(9)](/bitset/9.md)** equivalent of the scalar: *dst* = *src1* ^ *src2*.)

## BITSET\_T\_INITIALIZER EXAMPLE

```
BITSET_DEFINE(_myset, MYSETSIZE);
struct _myset myset;
/* Initialize myset to filled (all bits set) */
myset = BITSET_T_INITIALIZER(BITSET_FSET(__bitset_words(MYSETSIZE)));
/* Initialize myset to only the lowest bit set */
myset = BITSET_T_INITIALIZER(0x1);
```

## SEE ALSO

[bitstring(3)](/bitstring/3.md), [cpuset(9)](/cpuset/9.md)

## HISTORY

The **[bitset(9)](/bitset/9.md)** macros first appeared in FreeBSD 10.0 in January 2014. They were MFCed to FreeBSD 9.3, released in July 2014.

This manual page first appeared in FreeBSD 11.0.

## AUTHORS

The **[bitset(9)](/bitset/9.md)** macros were generalized and pulled out of ⟨sys/cpuset.h⟩ as ⟨sys/\_bitset.h⟩ and ⟨sys/bitset.h⟩ by Attilio Rao ⟨*attilio@FreeBSD.org*⟩. This manual page was written by Conrad Meyer ⟨*cem@FreeBSD.org*⟩.

## CAVEATS

The *SETSIZE* argument to all of these macros must match the value given to **BITSET\_DEFINE**().

Unlike every other reference to individual set members, which are zero-indexed, **BIT\_FFS**(), **BIT\_FFS\_AT**() and **BIT\_FLS**() return a one-indexed result (or zero if the set is empty).

In order to use the macros defined in ⟨sys/bitset.h⟩ and ⟨sys/\_bitset.h⟩ in userland programs, \_WANT\_FREEBSD\_BITSET has to be defined before including the header files. This requirements exists to prevent a name space pollution due to macros defined in **[bitset(9)](/bitset/9.md)** in programs that include ⟨sys/cpuset.h⟩ or ⟨sched.h⟩.