mirror of
https://codeberg.org/ziglang/zig.git
synced 2026-10-29 03:06:10 +08:00
Justus Klausecker
cb4c344e19
This commit implements the `@backingInt` and `@fromBackingInt` builtins. These builtins are meant to replace the now-deprecated `@intFromEnum` and `@enumFromInt` builtins. `@backingInt` works with all enums and with bitpacks with *explicit* backing integer types only. It also works with tagged unions, returning the backing integer of the active tag value. An `undefined` enum or bitpack yields an `undefined` backing integer. The builtin is lowered to `bit_cast`. `@fromBackingInt` infers its result type, which may be any enum or a bitpack with an *explicit* backing integer type. It takes a parameter of exactly that backing integer type. For enums, passing a backing integer that is either `undefined` or would yield an invalid tag value results in safety-checked Illegal Behavior. For bitpacks, passing an `undefined` backing integer yields an `undefined` bitpack. The builtin is lowered to `bit_cast` or `bit_cast_safe` (more details below). `@bitCast` now also performs a safety check for invalid tag values if its destination type is an `enum`. This commit also introduces a new AIR instruction, `bit_cast_safe`. Similarly to `int_cast_safe`, it includes a safety check for invalid enum tag values. When `@enumFromInt` is eventually removed, `int_cast_safe` won't need to perform this safety check anymore. Legalize only implements `expand_bit_cast_safe`, and no additional insts to scalarize `bit_cast_safe` with vector/array operands. That is because it can just reuse the existing scalarizations for regular `bit_cast`. The safety check mandated by `bit_cast_safe` is only desired if the result type is a scalar enum tag value, so the scalarization process is exactly equivalent. The only difference is that we have to perform a safety check on the result of the scalarization. This means that there's no reason for a backend to want scalarization of regular `bit_cast`, but not of `bit_cast_safe` (or the other way round). If a backend is having trouble with the `bit_cast_safe` safety check it should just use `expand_bit_cast_safe` instead. Also adds a `std.meta.BackingInt()` function to conveniently get the result type of `@backingInt` and for use in the langref.
22 lines
561 B
Zig
22 lines
561 B
Zig
const std = @import("std");
|
|
const assert = std.debug.assert;
|
|
const expectEqual = std.testing.expectEqual;
|
|
|
|
const PackedStruct = packed struct(u8) {
|
|
lo: u4,
|
|
hi: u4,
|
|
};
|
|
|
|
test "convert to and from backing integer" {
|
|
const original: PackedStruct = .{ .lo = 0b1100, .hi = 0b0101 };
|
|
|
|
const backing_int = @backingInt(original);
|
|
comptime assert(@TypeOf(backing_int) == u8);
|
|
try expectEqual(0b0101_1100, backing_int);
|
|
|
|
const reconstructed: PackedStruct = @fromBackingInt(backing_int);
|
|
try expectEqual(original, reconstructed);
|
|
}
|
|
|
|
// test
|