Support bitfields

[MeteorsLiu]

Bitfields are a useful feature for low-level tasks like OS development in C. However, Go's language specification does not include native support for bitfields.

​​C Example:​​

This C structure uses bitfields to pack data efficiently:

struct vector_desc_t {
 int flags: 16; // Bitfield: OR of VECDESC_FL_* defines (16 bits)
 unsigned int cpu: 1; // Bitfield (1 bit)
 unsigned int intno: 5; // Bitfield (5 bits)
 int source: 8; // Bitfield: Interrupt mux flags (used when not shared, 8 bits)
 shared_vector_desc_t *shared_vec_info; // Pointer (used when VECDESC_FL_SHARED)
 vector_desc_t *next; // Pointer
};

The numbers (16, 1, 5, 8) specify the ​​exact number of bits​​ each field occupies in memory.

Emulating Bitfields in Go​​

While Go lacks direct language-level support for bitfields, we can achieve similar functionality through ​​code generation​​. This approach manually implements the bit manipulation operations.

The Go team exemplifies this technique in the https://cs.opensource.google/go/x/text/+/refs/tags/v0.28.0:internal/gen/bitfield/bitfield.go. For instance, code like this:

type myUint8 uint8

type test1 struct { // Represents 28 bits of data
 foo uint16 `bitfield:",fob"` // Tag hints for field "foo" with getter "fob"
 Bar int8 `bitfield:"5,baz"` // Tag: occupies 5 bits, getter named "baz"
 Foo uint64 // Regular field (whole uint64)
 bar myUint8 `bitfield:"3"` // Tag: occupies 3 bits (default getter "bar")
 Bool bool `bitfield:""` // Tag: occupies 1 bit (default getter "Bool")
 Baz int8 `bitfield:"3"` // Tag: occupies 3 bits (default getter "Baz")
}

Can be processed by a generator to produce methods that manipulate the bits within a single underlying integer type (here, uint32 for the bitfields):

type test1 uint32 // Underlying type holding the packed bits

func (t test1) fob() uint16 { // Getter for field 'foo' (tag defined name "fob")
 return uint16((t >> 16) & 0xffff) // Shift and mask for bits 16-31
}

func (t test1) baz() int8 { // Getter for field 'Bar' (tag defined name "baz")
 return int8((t >> 11) & 0x1f) // Shift and mask for 5 bits at pos 11
}

func (t test1) bar() myUint8 { // Getter for field 'bar' (type myUint8)
 return myUint8((t >> 8) & 0x7) // Shift and mask for 3 bits at pos 8
}

func (t test1) Bool() bool { // Getter for field 'Bool' (1 bit)
 const bit = 1 << 7 // Bit mask for position 7
 return t&bit == bit // Check if bit at pos 7 is set
}

func (t test1) Baz() int8 { // Getter for field 'Baz'
 return int8((t >> 4) & 0x7) // Shift and mask for 3 bits at pos 4
}

Memory alignment

By default, the most of compilers respect that memory alignment:

Size = ceil(bits ÷ unit_bits)+ padding for larger members.

(Unit size = sizeof(unsigned int), typically 32 bits).