8.2.2 Bit Fields

Bit fields are the only objects that are packed within a byte. That is, two bit fields can be stored in the same byte. Bit fields can range in size from 1 to 64 bits in C or larger in C++.

For big-endian mode, bit fields are packed into registers from most significant bit (MSB) to least significant bit (LSB) in the order in which they are defined. Bit fields are packed in memory from most significant byte (MSbyte) to least significant byte (LSbyte). For little-endian mode, bit fields are packed into registers from the LSB to the MSB in the order in which they are defined, and packed in memory from LSbyte to MSbyte.

The size, alignment, and type of bit fields adhere to these rules:

• Bit fields up to long long are supported.
• Bit fields are treated as the declared signed or unsigned type.
• The size and alignment of the struct containing a bit field depends on the declared type of the bit field. For example, consider the struct:
struct st { int a:4 };

This struct uses up 4 bytes and is aligned at 4 bytes.

• Unnamed bit fields do affect the alignment of the struct or union. For example, consider the struct:
struct st { char a:4; int :22; };

This struct uses 4 bytes and is aligned at a 4-byte boundary.

• Bit fields declared volatile are accessed according to the bit field's declared type. A volatile bit field reference generates exactly one reference to its storage; multiple volatile bit field accesses are not merged.

Figure 8-9 illustrates bit-field packing, using the following bit field definitions:

A0 represents the least significant bit of the field A; A1 represents the next least significant bit, etc. Again, storage of bit fields in memory is done with a byte-by-byte, rather than bit-by-bit, transfer.