x86_64: integer overflow in legalize with large packed struct field

[xdBronch]

Zig Version

0.15.0-dev.828+3ce8d19f7

Steps to Reproduce and Observed Behavior

export fn foo() void {
    var a: packed struct { n: u65409 = 0 } = .{};
    _ = &a;
    _ = a.n;
}

thread 32455 panic: integer overflow
/home/user/dev/zig/src/Zcu/PerThread.zig:3493:98: 0x1918796 in ptrType (main.zig)
            assert(info.packed_offset.bit_offset + elem_bit_size <= info.packed_offset.host_size * 8);
                                                                                                 ^
/home/user/dev/zig/src/Air/Legalize.zig:2503:44: 0x2c894bc in addStructFieldPtr (main.zig)
        const field_ptr_ty = try pt.ptrType(field_ptr_info);
                                           ^
/home/user/dev/zig/src/Air/Legalize.zig:2290:68: 0x27a38db in packedStructFieldValBlockPayload (main.zig)
                        .operand = (try res_block.addStructFieldPtr(l, agg_alloc_inst.toRef(), orig_extra.field_index)).toRef(),
                                                                   ^
/home/user/dev/zig/src/Air/Legalize.zig:550:116: 0x24037e4 in legalizeBody (main.zig)
                    .@"packed" => continue :inst l.replaceInst(inst, .block, try l.packedStructFieldValBlockPayload(inst)),
                                                                                                                   ^

anything below u65409 works

Expected Behavior

successful compile

[mlugg]

how on earth did you discover this lmao

Regardless: this sounds like one of many instances of the compiler disagreeing with itself on how bit-pointers work, or perhaps just constructing them in a completely bogus way. I'm not going to spend time tracking this down for the minute, since I'd prefer we just accept #24061 and implement saner bit-pointer semantics; debugging those will make me cry significantly less.

[jacobly0]

Technically I introduced this, but the same crash would have already happened with a u65529 in the old code anyway. Note that this case is completely impossible to implement without #24061 (or at least completely changing the meaning of host size in a breaking way) so it does not seem worth fixing the initial overflow at this time.