class DataMember

The byte offset from the containing class or struct of this data member. This is only valid

if !is_external() and data_bit_offset is not set -- see the base class' Value::is_external().

The DW_AT_data_bit_offset is used in DWARF 4 to indicate the bit position of a member bitfield.

Unlike bit_offset, this will measure from the beginning of the containing structure.

If data_bit_offset is set, then member_location, byte_size, and bit_offset will not be set.

The DW_AT_byte_size attribute on the data member. It won't be set if data_bit_offset is set.

Normally the byte size will be 0 which means to take the size from the type. For bitfields

this will indicate the size of the larger field containing the bitfield, and the bit_offset

will count from the high bit inside this byte_size (where byte_size is read as little-endian

on little-endian machines).

As of this writing I've only ever seen GCC and Clang generated byte_size() that matches the

type().byte_size() even when the actual data occupies more physical bytes than the size of

the type (because it's not aligned). This case will generated negative bit offsets.

Note that for bitfields reading this many bytes may read off the end of the structure. For

example:

struct MyStruct {

long long data : 2;

};

MyStruct will have a byte_size of 1, while MyStruct.data will have a byte_size of 8! The bit

offset will select the value bits from the structure.

Bit offset from the member_location(). This is counting from the high bit of the byte_size().

When that many bytes is read into memory (swapping the byte order for little-endian).

As an example, a little-endian "int foo : 3;" might be defined as having:

- byte_size = 4

- bit_offset = 29

- bit_size = 3

- data_bit_offset = 0

Bit layout (stored in the low 3 bits of a 32-bit integer):

Byte 0 (low) Byte 1 Byte 2 Byte 3 (high bits)

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

x x x

It can be negative which means it starts *beyond* the byte_size(). I have not seen this be

more than one byte extra since otherwise the address will likely be one greater. For example:

struct {

// member_location = 0

// byte_size = 1

// bit_size = 6

// bit_offset = 2

// data_bit_offset = 0

bool a : 6;

// member_location = 0

// byte_size = 1

// bit_size = 7

// bit_offset = -5

// data_bit_offset = 6

bool b : 7;

};

Bit layout:

Byte 0 Byte 1

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

b b a a a a a a b b b b b

^ -5 bits in little-endian from the high bit of byte 0.

Number of bits that count. 0 means all.

The location of the declaration, used by Rust generators.