authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-08-24 20:27:11-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-08-24 22:20:31-07:00
log7453f56e678c80928ababa2868c69cfe41647fed
tree689bfb73cab6314cb91898b174fcf12d50196009
parentaf19909b9cde3d009f0306ac825f39912644bca6

stage2: explicitly tagged enums no longer have one possible value

Previously, Zig had inconsistent semantics for an enum like this: `enum(u8){zero = 0}` Although in theory this can only hold one possible value, the tag `zero`, Zig no longer will treat the type this way. It will do loads and stores, as if the type has runtime bits. Closes #12619 Tests passed locally: * test-behavior * test-cases

10 files changed, 113 insertions(+), 60 deletions(-)

lib/std/elf.zig+7-7
......@@ -3,7 +3,7 @@ const io = std.io;
33const os = std.os;
44const math = std.math;
55const mem = std.mem;
6const debug = std.debug;
6const assert = std.debug.assert;
77const File = std.fs.File;
88const native_endian = @import("builtin").target.cpu.arch.endian();
99
......@@ -872,14 +872,14 @@ pub const Elf_MIPS_ABIFlags_v0 = extern struct {
872872};
873873
874874comptime {
875 debug.assert(@sizeOf(Elf32_Ehdr) == 52);
876 debug.assert(@sizeOf(Elf64_Ehdr) == 64);
875 assert(@sizeOf(Elf32_Ehdr) == 52);
876 assert(@sizeOf(Elf64_Ehdr) == 64);
877877
878 debug.assert(@sizeOf(Elf32_Phdr) == 32);
879 debug.assert(@sizeOf(Elf64_Phdr) == 56);
878 assert(@sizeOf(Elf32_Phdr) == 32);
879 assert(@sizeOf(Elf64_Phdr) == 56);
880880
881 debug.assert(@sizeOf(Elf32_Shdr) == 40);
882 debug.assert(@sizeOf(Elf64_Shdr) == 64);
881 assert(@sizeOf(Elf32_Shdr) == 40);
882 assert(@sizeOf(Elf64_Shdr) == 64);
883883}
884884
885885pub const Auxv = switch (@sizeOf(usize)) {
src/Module.zig+14-12
......@@ -1368,18 +1368,20 @@ pub const Union = struct {
13681368 }
13691369 }
13701370 payload_align = @maximum(payload_align, 1);
1371 if (!have_tag or fields.len <= 1) return .{
1372 .abi_size = std.mem.alignForwardGeneric(u64, payload_size, payload_align),
1373 .abi_align = payload_align,
1374 .most_aligned_field = most_aligned_field,
1375 .most_aligned_field_size = most_aligned_field_size,
1376 .biggest_field = biggest_field,
1377 .payload_size = payload_size,
1378 .payload_align = payload_align,
1379 .tag_align = 0,
1380 .tag_size = 0,
1381 .padding = 0,
1382 };
1371 if (!have_tag or !u.tag_ty.hasRuntimeBits()) {
1372 return .{
1373 .abi_size = std.mem.alignForwardGeneric(u64, payload_size, payload_align),
1374 .abi_align = payload_align,
1375 .most_aligned_field = most_aligned_field,
1376 .most_aligned_field_size = most_aligned_field_size,
1377 .biggest_field = biggest_field,
1378 .payload_size = payload_size,
1379 .payload_align = payload_align,
1380 .tag_align = 0,
1381 .tag_size = 0,
1382 .padding = 0,
1383 };
1384 }
13831385 // Put the tag before or after the payload depending on which one's
13841386 // alignment is greater.
13851387 const tag_size = u.tag_ty.abiSize(target);
src/Sema.zig+7
......@@ -28844,6 +28844,10 @@ pub fn typeHasOnePossibleValue(
2884428844 .enum_numbered => {
2884528845 const resolved_ty = try sema.resolveTypeFields(block, src, ty);
2884628846 const enum_obj = resolved_ty.castTag(.enum_numbered).?.data;
28847 // An explicit tag type is always provided for enum_numbered.
28848 if (enum_obj.tag_ty.hasRuntimeBits()) {
28849 return null;
28850 }
2884728851 if (enum_obj.fields.count() == 1) {
2884828852 if (enum_obj.values.count() == 0) {
2884928853 return Value.zero; // auto-numbered
......@@ -28857,6 +28861,9 @@ pub fn typeHasOnePossibleValue(
2885728861 .enum_full => {
2885828862 const resolved_ty = try sema.resolveTypeFields(block, src, ty);
2885928863 const enum_obj = resolved_ty.castTag(.enum_full).?.data;
28864 if (enum_obj.tag_ty.hasRuntimeBits()) {
28865 return null;
28866 }
2886028867 if (enum_obj.fields.count() == 1) {
2886128868 if (enum_obj.values.count() == 0) {
2886228869 return Value.zero; // auto-numbered
src/arch/x86_64/CodeGen.zig+2-2
......@@ -6524,13 +6524,13 @@ fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
65246524 const extra = self.air.extraData(Air.Block, ty_pl.payload);
65256525 _ = ty_pl;
65266526 _ = extra;
6527 return self.fail("TODO implement airCmpxchg for {}", .{self.target.cpu.arch});
6527 return self.fail("TODO implement x86 airCmpxchg", .{});
65286528 // return self.finishAir(inst, result, .{ extra.ptr, extra.expected_value, extra.new_value });
65296529}
65306530
65316531fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
65326532 _ = inst;
6533 return self.fail("TODO implement airCmpxchg for {}", .{self.target.cpu.arch});
6533 return self.fail("TODO implement x86 airAtomicRaw", .{});
65346534}
65356535
65366536fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
src/codegen/llvm.zig+4-4
......@@ -1860,7 +1860,7 @@ pub const Object = struct {
18601860 var offset: u64 = 0;
18611861
18621862 for (fields.values()) |field, i| {
1863 if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
1863 if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
18641864
18651865 const field_size = field.ty.abiSize(target);
18661866 const field_align = field.alignment(target, layout);
......@@ -2764,7 +2764,7 @@ pub const DeclGen = struct {
27642764 var any_underaligned_fields = false;
27652765
27662766 for (struct_obj.fields.values()) |field| {
2767 if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
2767 if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
27682768
27692769 const field_align = field.alignment(target, struct_obj.layout);
27702770 const field_ty_align = field.ty.abiAlignment(target);
......@@ -3443,7 +3443,7 @@ pub const DeclGen = struct {
34433443 var need_unnamed = false;
34443444
34453445 for (struct_obj.fields.values()) |field, i| {
3446 if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
3446 if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
34473447
34483448 const field_align = field.alignment(target, struct_obj.layout);
34493449 big_align = @maximum(big_align, field_align);
......@@ -9477,7 +9477,7 @@ fn llvmFieldIndex(
94779477
94789478 var llvm_field_index: c_uint = 0;
94799479 for (ty.structFields().values()) |field, i| {
9480 if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
9480 if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
94819481
94829482 const field_align = field.alignment(target, layout);
94839483 big_align = @maximum(big_align, field_align);
src/type.zig+33-18
......@@ -2310,6 +2310,8 @@ pub const Type = extern union {
23102310 /// fields will count towards the ABI size. For example, `struct {T: type, x: i32}`
23112311 /// hasRuntimeBits()=true and abiSize()=4
23122312 /// * the type has only one possible value, making its ABI size 0.
2313 /// - an enum with an explicit tag type has the ABI size of the integer tag type,
2314 /// making it one-possible-value only if the integer tag type has 0 bits.
23132315 /// When `ignore_comptime_only` is true, then types that are comptime only
23142316 /// may return false positives.
23152317 pub fn hasRuntimeBitsAdvanced(
......@@ -2452,9 +2454,9 @@ pub const Type = extern union {
24522454 _ = try sk.sema.resolveTypeFields(sk.block, sk.src, ty);
24532455 }
24542456 assert(struct_obj.haveFieldTypes());
2455 for (struct_obj.fields.values()) |value| {
2456 if (value.is_comptime) continue;
2457 if (try value.ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit))
2457 for (struct_obj.fields.values()) |field| {
2458 if (field.is_comptime) continue;
2459 if (try field.ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit))
24582460 return true;
24592461 } else {
24602462 return false;
......@@ -2463,7 +2465,7 @@ pub const Type = extern union {
24632465
24642466 .enum_full => {
24652467 const enum_full = ty.castTag(.enum_full).?.data;
2466 return enum_full.fields.count() >= 2;
2468 return enum_full.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit);
24672469 },
24682470 .enum_simple => {
24692471 const enum_simple = ty.castTag(.enum_simple).?.data;
......@@ -2490,9 +2492,10 @@ pub const Type = extern union {
24902492 },
24912493 .union_safety_tagged, .union_tagged => {
24922494 const union_obj = ty.cast(Payload.Union).?.data;
2493 if (union_obj.fields.count() > 0 and try union_obj.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit)) {
2495 if (try union_obj.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit)) {
24942496 return true;
24952497 }
2498
24962499 if (sema_kit) |sk| {
24972500 _ = try sk.sema.resolveTypeFields(sk.block, sk.src, ty);
24982501 }
......@@ -3125,7 +3128,11 @@ pub const Type = extern union {
31253128 .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
31263129 };
31273130 if (union_obj.fields.count() == 0) {
3128 return AbiAlignmentAdvanced{ .scalar = @boolToInt(union_obj.layout == .Extern) };
3131 if (have_tag) {
3132 return abiAlignmentAdvanced(union_obj.tag_ty, target, strat);
3133 } else {
3134 return AbiAlignmentAdvanced{ .scalar = @boolToInt(union_obj.layout == .Extern) };
3135 }
31293136 }
31303137
31313138 var max_align: u32 = 0;
......@@ -4991,14 +4998,18 @@ pub const Type = extern union {
49914998
49924999 .enum_numbered => {
49935000 const enum_numbered = ty.castTag(.enum_numbered).?.data;
4994 if (enum_numbered.fields.count() == 1) {
4995 return enum_numbered.values.keys()[0];
4996 } else {
5001 // An explicit tag type is always provided for enum_numbered.
5002 if (enum_numbered.tag_ty.hasRuntimeBits()) {
49975003 return null;
49985004 }
5005 assert(enum_numbered.fields.count() == 1);
5006 return enum_numbered.values.keys()[0];
49995007 },
50005008 .enum_full => {
50015009 const enum_full = ty.castTag(.enum_full).?.data;
5010 if (enum_full.tag_ty.hasRuntimeBits()) {
5011 return null;
5012 }
50025013 if (enum_full.fields.count() == 1) {
50035014 if (enum_full.values.count() == 0) {
50045015 return Value.zero;
......@@ -5333,7 +5344,8 @@ pub const Type = extern union {
53335344 .enum_numbered => return ty.castTag(.enum_numbered).?.data.tag_ty,
53345345 .enum_simple => {
53355346 const enum_simple = ty.castTag(.enum_simple).?.data;
5336 const bits = std.math.log2_int_ceil(usize, enum_simple.fields.count());
5347 const field_count = enum_simple.fields.count();
5348 const bits: u16 = if (field_count == 0) 0 else std.math.log2_int_ceil(usize, field_count);
53375349 buffer.* = .{
53385350 .base = .{ .tag = .int_unsigned },
53395351 .data = bits,
......@@ -5653,19 +5665,22 @@ pub const Type = extern union {
56535665 target: Target,
56545666
56555667 pub fn next(it: *StructOffsetIterator) ?FieldOffset {
5656 if (it.struct_obj.fields.count() <= it.field)
5668 const i = it.field;
5669 if (it.struct_obj.fields.count() <= i)
56575670 return null;
56585671
5659 const field = it.struct_obj.fields.values()[it.field];
5660 defer it.field += 1;
5661 if (!field.ty.hasRuntimeBits() or field.is_comptime)
5662 return FieldOffset{ .field = it.field, .offset = it.offset };
5672 const field = it.struct_obj.fields.values()[i];
5673 it.field += 1;
5674
5675 if (field.is_comptime or !field.ty.hasRuntimeBits()) {
5676 return FieldOffset{ .field = i, .offset = it.offset };
5677 }
56635678
56645679 const field_align = field.alignment(it.target, it.struct_obj.layout);
56655680 it.big_align = @maximum(it.big_align, field_align);
5666 it.offset = std.mem.alignForwardGeneric(u64, it.offset, field_align);
5667 defer it.offset += field.ty.abiSize(it.target);
5668 return FieldOffset{ .field = it.field, .offset = it.offset };
5681 const field_offset = std.mem.alignForwardGeneric(u64, it.offset, field_align);
5682 it.offset = field_offset + field.ty.abiSize(it.target);
5683 return FieldOffset{ .field = i, .offset = field_offset };
56695684 }
56705685 };
56715686
test/behavior.zig-1
......@@ -26,7 +26,6 @@ test {
2626 _ = @import("behavior/bugs/920.zig");
2727 _ = @import("behavior/bugs/1025.zig");
2828 _ = @import("behavior/bugs/1076.zig");
29 _ = @import("behavior/bugs/1111.zig");
3029 _ = @import("behavior/bugs/1277.zig");
3130 _ = @import("behavior/bugs/1310.zig");
3231 _ = @import("behavior/bugs/1381.zig");
test/behavior/bugs/1111.zig deleted-11
......@@ -1,11 +0,0 @@
1const Foo = enum(c_int) {
2 Bar = -1,
3};
4
5test "issue 1111 fixed" {
6 const v = Foo.Bar;
7
8 switch (v) {
9 Foo.Bar => return,
10 }
11}
test/behavior/enum.zig+42
......@@ -1,6 +1,7 @@
11const builtin = @import("builtin");
22const std = @import("std");
33const expect = std.testing.expect;
4const assert = std.debug.assert;
45const mem = std.mem;
56const Tag = std.meta.Tag;
67
......@@ -1128,3 +1129,44 @@ test "tag name functions are unique" {
11281129 _ = a;
11291130 }
11301131}
1132
1133test "size of enum with only one tag which has explicit integer tag type" {
1134 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1135 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1136 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1137
1138 const E = enum(u8) { nope = 10 };
1139 const S0 = struct { e: E };
1140 const S1 = extern struct { e: E };
1141 //const U = union(E) { nope: void };
1142 comptime assert(@sizeOf(E) == 1);
1143 comptime assert(@sizeOf(S0) == 1);
1144 comptime assert(@sizeOf(S1) == 1);
1145 //comptime assert(@sizeOf(U) == 1);
1146
1147 var s1: S1 = undefined;
1148 s1.e = .nope;
1149 try expect(s1.e == .nope);
1150 const ptr = @ptrCast(*u8, &s1);
1151 try expect(ptr.* == 10);
1152
1153 var s0: S0 = undefined;
1154 s0.e = .nope;
1155 try expect(s0.e == .nope);
1156}
1157
1158test "switch on an extern enum with negative value" {
1159 // TODO x86, wasm backends fail because they assume that enum tag types are unsigned
1160 if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
1161 if (@import("builtin").zig_backend == .stage2_wasm) return error.SkipZigTest;
1162
1163 const Foo = enum(c_int) {
1164 Bar = -1,
1165 };
1166
1167 const v = Foo.Bar;
1168
1169 switch (v) {
1170 Foo.Bar => return,
1171 }
1172}
test/behavior/union.zig+4-5
......@@ -1,6 +1,7 @@
11const builtin = @import("builtin");
22const std = @import("std");
33const expect = std.testing.expect;
4const assert = std.debug.assert;
45const expectEqual = std.testing.expectEqual;
56const Tag = std.meta.Tag;
67
......@@ -1065,6 +1066,8 @@ test "@unionInit on union with tag but no fields" {
10651066 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
10661067 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10671068 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1069 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1070 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10681071
10691072 const S = struct {
10701073 const Type = enum(u8) { no_op = 105 };
......@@ -1079,11 +1082,7 @@ test "@unionInit on union with tag but no fields" {
10791082 };
10801083
10811084 comptime {
1082 if (builtin.zig_backend == .stage1) {
1083 // stage1 gets the wrong answer here
1084 } else {
1085 std.debug.assert(@sizeOf(Data) == 0);
1086 }
1085 assert(@sizeOf(Data) == 1);
10871086 }
10881087
10891088 fn doTheTest() !void {