Inconsistent @bitCast between packed struct and integer on big endian

[tgschultz]

Zig Version

0.9.0-dev.1324+598db831f

Steps to Reproduce

On big endian hardware:

const S = packed struct {
    .one: u6,
    .two: u1,
};

const s = S{ .one = 0b110101, .two = 0b1};

const u = @bitCast(u7, s);
const s2 = @bitCast(S, u);

try testing.expectEqual(s.one, s2.one); //will fail
try testing.expectEqual(s.two, s2.two);

Expected Behavior

I believe the correct behavior for big endian is:

Given a packed struct with one field as defined below:

const S = packed struct {
    .one: u7,
};

its representation in memory should have all 7 bits at the high end of the containing byte.

Packed structs containing more than one field require no changes.

@bitCast from a packed struct to an int requires no changes.

@bitCast from an int to a packed struct should place the bits at the high end. Thus:

const s = S{ .one = 0b110101, .two = 0b1};
// s byte = 0b11010110

const u = @bitCast(u7, s);
// u byte = 0b01101011

const s2 = @bitCast(S, u);
// s2 byte = 0b11010110
// s2 = .{.one = 0b110101, .two = 0b1}

Actual Behavior

On big endian hardware, given a packed struct as defined below:

const S = packed struct {
    .one: u7,
};

its representation in memory will be exactly identical that of a u7 integer of the same value. That is to say, the low 7 bits of the byte occupied by our S instance contain the value. However, when the struct has more than one field:

const S = packed struct {
    .one: u6,
    .two: u1,
};

its representation in memory now occupies the high 7 bits of the byte. When @bitCasting this struct to a u7, the value is converted such that the high 7 bits of the struct byte now occupy the low 7 bits of the integer byte. However, when @bitCasting the u7 back to S the high 7 bits are kept and the low 1 is discarded.

examples with binary:

const s = S{ .one = 0b110101, .two = 0b1};
// s byte = 0b11010110

const u = @bitCast(u7, s);
// u byte = 0b01101011

const s2 = @bitCast(S, u);
// s2 byte = 0b01101010
// s2 = .{.one = 0b011010, .two = 0b1}

[tgschultz]

After further experimentation, I am not convinced my analysis above holds for all cases. Specifically, it would seem that @bitCast from a packed struct to an int does not always produce a sensical result.