diff --git a/src/aro/Attribute.zig b/src/aro/Attribute.zig index 35e8aeee..2bdf5be2 100644 --- a/src/aro/Attribute.zig +++ b/src/aro/Attribute.zig @@ -38,6 +38,57 @@ pub const Kind = enum { } }; +pub const Iterator = struct { + source: union(enum) { + ty: Type, + slice: []const Attribute, + }, + index: usize, + + pub fn initSlice(slice: ?[]const Attribute) Iterator { + return .{ .source = .{ .slice = slice orelse &.{} }, .index = 0 }; + } + + pub fn initType(ty: Type) Iterator { + return .{ .source = .{ .ty = ty }, .index = 0 }; + } + + /// returns the next attribute as well as its index within the slice or current type + /// The index can be used to determine when a nested type has been recursed into + pub fn next(self: *Iterator) ?struct { Attribute, usize } { + switch (self.source) { + .slice => |slice| { + if (self.index < slice.len) { + defer self.index += 1; + return .{ slice[self.index], self.index }; + } + }, + .ty => |ty| { + switch (ty.specifier) { + .typeof_type => { + self.* = .{ .source = .{ .ty = ty.data.sub_type.* }, .index = 0 }; + return self.next(); + }, + .typeof_expr => { + self.* = .{ .source = .{ .ty = ty.data.expr.ty }, .index = 0 }; + return self.next(); + }, + .attributed => { + if (self.index < ty.data.attributed.attributes.len) { + defer self.index += 1; + return .{ ty.data.attributed.attributes[self.index], self.index }; + } + self.* = .{ .source = .{ .ty = ty.data.attributed.base }, .index = 0 }; + return self.next(); + }, + else => {}, + } + }, + } + return null; + } +}; + pub const ArgumentType = enum { string, identifier, @@ -740,7 +791,6 @@ pub fn applyVariableAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag: const toks = p.attr_buf.items(.tok)[attr_buf_start..]; p.attr_application_buf.items.len = 0; var base_ty = ty; - if (base_ty.specifier == .attributed) base_ty = base_ty.data.attributed.base; var common = false; var nocommon = false; for (attrs, toks) |attr, tok| switch (attr.tag) { @@ -785,12 +835,7 @@ pub fn applyVariableAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag: => |t| try p.errExtra(.attribute_todo, tok, .{ .attribute_todo = .{ .tag = t, .kind = .variables } }), else => try ignoredAttrErr(p, tok, attr.tag, "variables"), }; - const existing = ty.getAttributes(); - if (existing.len == 0 and p.attr_application_buf.items.len == 0) return base_ty; - if (existing.len == 0) return base_ty.withAttributes(p.arena, p.attr_application_buf.items); - - const attributed_type = try Type.Attributed.create(p.arena, base_ty, existing, p.attr_application_buf.items); - return Type{ .specifier = .attributed, .data = .{ .attributed = attributed_type } }; + return base_ty.withAttributes(p.arena, p.attr_application_buf.items); } pub fn applyFieldAttributes(p: *Parser, field_ty: *Type, attr_buf_start: usize) ![]const Attribute { @@ -815,7 +860,6 @@ pub fn applyTypeAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag: ?Di const toks = p.attr_buf.items(.tok)[attr_buf_start..]; p.attr_application_buf.items.len = 0; var base_ty = ty; - if (base_ty.specifier == .attributed) base_ty = base_ty.data.attributed.base; for (attrs, toks) |attr, tok| switch (attr.tag) { // zig fmt: off .@"packed", .may_alias, .deprecated, .unavailable, .unused, .warn_if_not_aligned, .mode, @@ -836,19 +880,7 @@ pub fn applyTypeAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag: ?Di => |t| try p.errExtra(.attribute_todo, tok, .{ .attribute_todo = .{ .tag = t, .kind = .types } }), else => try ignoredAttrErr(p, tok, attr.tag, "types"), }; - - const existing = ty.getAttributes(); - // TODO: the alignment annotation on a type should override - // the decl it refers to. This might not be true for others. Maybe bug. - - // if there are annotations on this type def use those. - if (p.attr_application_buf.items.len > 0) { - return try base_ty.withAttributes(p.arena, p.attr_application_buf.items); - } else if (existing.len > 0) { - // else use the ones on the typedef decl we were refering to. - return try base_ty.withAttributes(p.arena, existing); - } - return base_ty; + return base_ty.withAttributes(p.arena, p.attr_application_buf.items); } pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Type { @@ -856,7 +888,6 @@ pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Typ const toks = p.attr_buf.items(.tok)[attr_buf_start..]; p.attr_application_buf.items.len = 0; var base_ty = ty; - if (base_ty.specifier == .attributed) base_ty = base_ty.data.attributed.base; var hot = false; var cold = false; var @"noinline" = false; @@ -1059,6 +1090,7 @@ fn applyTransparentUnion(attr: Attribute, p: *Parser, tok: TokenIndex, ty: Type) } fn applyVectorSize(attr: Attribute, p: *Parser, tok: TokenIndex, ty: *Type) !void { + const base = ty.base(); const is_enum = ty.is(.@"enum"); if (!(ty.isInt() or ty.isFloat()) or !ty.isReal() or (is_enum and p.comp.langopts.emulate == .gcc)) { try p.errStr(.invalid_vec_elem_ty, tok, try p.typeStr(ty.*)); @@ -1075,7 +1107,7 @@ fn applyVectorSize(attr: Attribute, p: *Parser, tok: TokenIndex, ty: *Type) !voi const arr_ty = try p.arena.create(Type.Array); arr_ty.* = .{ .elem = ty.*, .len = vec_size }; - ty.* = Type{ + base.* = .{ .specifier = .vector, .data = .{ .array = arr_ty }, }; diff --git a/src/aro/Parser.zig b/src/aro/Parser.zig index 89800985..0a8907b2 100644 --- a/src/aro/Parser.zig +++ b/src/aro/Parser.zig @@ -1037,10 +1037,8 @@ fn decl(p: *Parser) Error!bool { // Collect old style parameter declarations. if (init_d.d.old_style_func != null) { - const attrs = init_d.d.ty.getAttributes(); - var base_ty = if (init_d.d.ty.specifier == .attributed) init_d.d.ty.data.attributed.base else init_d.d.ty; + var base_ty = init_d.d.ty.base(); base_ty.specifier = .func; - init_d.d.ty = try base_ty.withAttributes(p.arena, attrs); const param_buf_top = p.param_buf.items.len; defer p.param_buf.items.len = param_buf_top; @@ -3901,8 +3899,6 @@ fn convertInitList(p: *Parser, il: InitList, init_ty: Type) Error!NodeIndex { .specifier = .array, .data = .{ .array = arr_ty }, }; - const attrs = init_ty.getAttributes(); - arr_init_node.ty = try arr_init_node.ty.withAttributes(p.arena, attrs); } else if (start < max_items) { const elem = try p.addNode(.{ .tag = .array_filler_expr, diff --git a/src/aro/Tree.zig b/src/aro/Tree.zig index c2210f63..0da1d913 100644 --- a/src/aro/Tree.zig +++ b/src/aro/Tree.zig @@ -909,7 +909,9 @@ fn dumpNode( if (ty.specifier == .attributed) { try config.setColor(w, ATTRIBUTE); - for (ty.data.attributed.attributes) |attr| { + var it = Attribute.Iterator.initType(ty); + while (it.next()) |item| { + const attr, _ = item; try w.writeByteNTimes(' ', level + half); try w.print("attr: {s}", .{@tagName(attr.tag)}); try tree.dumpAttribute(attr, w); diff --git a/src/aro/Type.zig b/src/aro/Type.zig index ab083942..2aee9f03 100644 --- a/src/aro/Type.zig +++ b/src/aro/Type.zig @@ -146,17 +146,14 @@ pub const Attributed = struct { attributes: []Attribute, base: Type, - pub fn create(allocator: std.mem.Allocator, base: Type, existing_attributes: []const Attribute, attributes: []const Attribute) !*Attributed { + pub fn create(allocator: std.mem.Allocator, base_ty: Type, attributes: []const Attribute) !*Attributed { const attributed_type = try allocator.create(Attributed); errdefer allocator.destroy(attributed_type); - - const all_attrs = try allocator.alloc(Attribute, existing_attributes.len + attributes.len); - @memcpy(all_attrs[0..existing_attributes.len], existing_attributes); - @memcpy(all_attrs[existing_attributes.len..], attributes); + const duped = try allocator.dupe(Attribute, attributes); attributed_type.* = .{ - .attributes = all_attrs, - .base = base, + .attributes = duped, + .base = base_ty, }; return attributed_type; } @@ -438,8 +435,8 @@ pub fn is(ty: Type, specifier: Specifier) bool { pub fn withAttributes(self: Type, allocator: std.mem.Allocator, attributes: []const Attribute) !Type { if (attributes.len == 0) return self; - const attributed_type = try Type.Attributed.create(allocator, self, self.getAttributes(), attributes); - return Type{ .specifier = .attributed, .data = .{ .attributed = attributed_type }, .decayed = self.decayed }; + const attributed_type = try Type.Attributed.create(allocator, self, attributes); + return .{ .specifier = .attributed, .data = .{ .attributed = attributed_type }, .decayed = self.decayed }; } pub fn isCallable(ty: Type) ?Type { @@ -756,15 +753,6 @@ pub fn anyQual(ty: Type) bool { }; } -pub fn getAttributes(ty: Type) []const Attribute { - return switch (ty.specifier) { - .attributed => ty.data.attributed.attributes, - .typeof_type => ty.data.sub_type.getAttributes(), - .typeof_expr => ty.data.expr.ty.getAttributes(), - else => &.{}, - }; -} - pub fn getRecord(ty: Type) ?*const Type.Record { return switch (ty.specifier) { .attributed => ty.data.attributed.base.getRecord(), @@ -825,8 +813,8 @@ fn realIntegerConversion(a: Type, b: Type, comp: *const Compilation) Type { pub fn makeIntegerUnsigned(ty: Type) Type { // TODO discards attributed/typeof - var base = ty.canonicalize(.standard); - switch (base.specifier) { + var base_ty = ty.canonicalize(.standard); + switch (base_ty.specifier) { // zig fmt: off .uchar, .ushort, .uint, .ulong, .ulong_long, .uint128, .complex_uchar, .complex_ushort, .complex_uint, .complex_ulong, .complex_ulong_long, .complex_uint128, @@ -834,21 +822,21 @@ pub fn makeIntegerUnsigned(ty: Type) Type { // zig fmt: on .char, .complex_char => { - base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 2); - return base; + base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 2); + return base_ty; }, // zig fmt: off .schar, .short, .int, .long, .long_long, .int128, .complex_schar, .complex_short, .complex_int, .complex_long, .complex_long_long, .complex_int128 => { - base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 1); - return base; + base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 1); + return base_ty; }, // zig fmt: on .bit_int, .complex_bit_int => { - base.data.int.signedness = .unsigned; - return base; + base_ty.data.int.signedness = .unsigned; + return base_ty; }, else => unreachable, } @@ -1144,17 +1132,12 @@ pub const QualHandling = enum { /// arrays and pointers. pub fn canonicalize(ty: Type, qual_handling: QualHandling) Type { var cur = ty; - if (cur.specifier == .attributed) { - cur = cur.data.attributed.base; - cur.decayed = ty.decayed; - } - if (!cur.isTypeof()) return cur; - var qual = cur.qual; while (true) { switch (cur.specifier) { .typeof_type => cur = cur.data.sub_type.*, .typeof_expr => cur = cur.data.expr.ty, + .attributed => cur = cur.data.attributed.base, else => break, } qual = qual.mergeAll(cur.qual); @@ -1182,7 +1165,7 @@ pub fn requestedAlignment(ty: Type, comp: *const Compilation) ?u29 { return switch (ty.specifier) { .typeof_type => ty.data.sub_type.requestedAlignment(comp), .typeof_expr => ty.data.expr.ty.requestedAlignment(comp), - .attributed => annotationAlignment(comp, ty.data.attributed.attributes), + .attributed => annotationAlignment(comp, Attribute.Iterator.initType(ty)), else => null, }; } @@ -1192,12 +1175,18 @@ pub fn enumIsPacked(ty: Type, comp: *const Compilation) bool { return comp.langopts.short_enums or target_util.packAllEnums(comp.target) or ty.hasAttribute(.@"packed"); } -pub fn annotationAlignment(comp: *const Compilation, attrs: ?[]const Attribute) ?u29 { - const a = attrs orelse return null; - +pub fn annotationAlignment(comp: *const Compilation, attrs: Attribute.Iterator) ?u29 { + var it = attrs; var max_requested: ?u29 = null; - for (a) |attribute| { + var last_aligned_index: ?usize = null; + while (it.next()) |item| { + const attribute, const index = item; if (attribute.tag != .aligned) continue; + if (last_aligned_index) |aligned_index| { + // once we recurse into a new type, after an `aligned` attribute was found, we're done + if (index <= aligned_index) break; + } + last_aligned_index = index; const requested = if (attribute.args.aligned.alignment) |alignment| alignment.requested else target_util.defaultAlignment(comp.target); if (max_requested == null or max_requested.? < requested) { max_requested = requested; @@ -1332,19 +1321,19 @@ pub fn sameRankDifferentSign(a: Type, b: Type, comp: *const Compilation) bool { pub fn makeReal(ty: Type) Type { // TODO discards attributed/typeof - var base = ty.canonicalize(.standard); - switch (base.specifier) { + var base_ty = ty.canonicalize(.standard); + switch (base_ty.specifier) { .complex_float16, .complex_float, .complex_double, .complex_long_double, .complex_float128 => { - base.specifier = @enumFromInt(@intFromEnum(base.specifier) - 5); - return base; + base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) - 5); + return base_ty; }, .complex_char, .complex_schar, .complex_uchar, .complex_short, .complex_ushort, .complex_int, .complex_uint, .complex_long, .complex_ulong, .complex_long_long, .complex_ulong_long, .complex_int128, .complex_uint128 => { - base.specifier = @enumFromInt(@intFromEnum(base.specifier) - 13); - return base; + base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) - 13); + return base_ty; }, .complex_bit_int => { - base.specifier = .bit_int; - return base; + base_ty.specifier = .bit_int; + return base_ty; }, else => return ty, } @@ -1352,19 +1341,19 @@ pub fn makeReal(ty: Type) Type { pub fn makeComplex(ty: Type) Type { // TODO discards attributed/typeof - var base = ty.canonicalize(.standard); - switch (base.specifier) { + var base_ty = ty.canonicalize(.standard); + switch (base_ty.specifier) { .float, .double, .long_double, .float128 => { - base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 5); - return base; + base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 5); + return base_ty; }, .char, .schar, .uchar, .short, .ushort, .int, .uint, .long, .ulong, .long_long, .ulong_long, .int128, .uint128 => { - base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 13); - return base; + base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 13); + return base_ty; }, .bit_int => { - base.specifier = .complex_bit_int; - return base; + base_ty.specifier = .complex_bit_int; + return base_ty; }, else => return ty, } @@ -2343,22 +2332,29 @@ pub const Builder = struct { } }; +/// Use with caution +pub fn base(ty: *Type) *Type { + return switch (ty.specifier) { + .typeof_type => ty.data.sub_type.base(), + .typeof_expr => ty.data.expr.ty.base(), + .attributed => ty.data.attributed.base.base(), + else => ty, + }; +} + pub fn getAttribute(ty: Type, comptime tag: Attribute.Tag) ?Attribute.ArgumentsForTag(tag) { - switch (ty.specifier) { - .typeof_type => return ty.data.sub_type.getAttribute(tag), - .typeof_expr => return ty.data.expr.ty.getAttribute(tag), - .attributed => { - for (ty.data.attributed.attributes) |attribute| { - if (attribute.tag == tag) return @field(attribute.args, @tagName(tag)); - } - return null; - }, - else => return null, + var it = Attribute.Iterator.initType(ty); + while (it.next()) |item| { + const attribute, _ = item; + if (attribute.tag == tag) return @field(attribute.args, @tagName(tag)); } + return null; } pub fn hasAttribute(ty: Type, tag: Attribute.Tag) bool { - for (ty.getAttributes()) |attr| { + var it = Attribute.Iterator.initType(ty); + while (it.next()) |item| { + const attr, _ = item; if (attr.tag == tag) return true; } return false; @@ -2639,7 +2635,7 @@ pub fn dump(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: .attributed => { if (ty.isDecayed()) try w.writeAll("*d:"); try w.writeAll("attributed("); - try ty.data.attributed.base.dump(mapper, langopts, w); + try ty.data.attributed.base.canonicalize(.standard).dump(mapper, langopts, w); try w.writeAll(")"); }, .bit_int => try w.print("{s} _BitInt({d})", .{ @tagName(ty.data.int.signedness), ty.data.int.bits }), diff --git a/src/aro/record_layout.zig b/src/aro/record_layout.zig index 39938330..da0517d9 100644 --- a/src/aro/record_layout.zig +++ b/src/aro/record_layout.zig @@ -101,7 +101,7 @@ const SysVContext = struct { field_attrs: ?[]const Attribute, field_layout: TypeLayout, ) !FieldLayout { - const annotation_alignment_bits = BITS_PER_BYTE * @as(u32, (Type.annotationAlignment(self.comp, field_attrs) orelse 1)); + const annotation_alignment_bits = BITS_PER_BYTE * @as(u32, (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(field_attrs)) orelse 1)); const is_attr_packed = self.attr_packed or isPacked(field_attrs); const ignore_type_alignment = ignoreTypeAlignment(is_attr_packed, field.bit_width, self.ongoing_bitfield, field_layout); @@ -240,7 +240,7 @@ const SysVContext = struct { // The field alignment can be increased by __attribute__((aligned)) annotations on the // field. See test case 0085. - if (Type.annotationAlignment(self.comp, fld_attrs)) |anno| { + if (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(fld_attrs))) |anno| { fld_align_bits = @max(fld_align_bits, @as(u32, anno) * BITS_PER_BYTE); } @@ -302,7 +302,7 @@ const SysVContext = struct { const attr_packed = self.attr_packed or isPacked(fld_attrs); const has_packing_annotation = attr_packed or self.max_field_align_bits != null; - const annotation_alignment = if (Type.annotationAlignment(self.comp, fld_attrs)) |anno| @as(u32, anno) * BITS_PER_BYTE else 1; + const annotation_alignment = if (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(fld_attrs))) |anno| @as(u32, anno) * BITS_PER_BYTE else 1; const first_unused_bit: u64 = if (self.is_union) 0 else self.size_bits; var field_align_bits: u64 = 1; @@ -441,7 +441,7 @@ const MsvcContext = struct { // underlying type and the __declspec(align) annotation on the field itself. // See test case 0028. var req_align = type_layout.required_alignment_bits; - if (Type.annotationAlignment(self.comp, fld_attrs)) |anno| { + if (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(fld_attrs))) |anno| { req_align = @max(@as(u32, anno) * BITS_PER_BYTE, req_align); } diff --git a/test/cases/nested attributes.c b/test/cases/nested attributes.c new file mode 100644 index 00000000..d5b08880 --- /dev/null +++ b/test/cases/nested attributes.c @@ -0,0 +1,15 @@ +typedef int __attribute__((aligned(1))) ALIGN_1; +typedef ALIGN_1 __attribute__((unused)) UNUSED; +_Static_assert(_Alignof(UNUSED) == 1, ""); + +typedef int __attribute__((aligned(16))) __attribute__((aligned(1))) ALIGN_16; +_Static_assert(_Alignof(ALIGN_16) == 16, ""); + +typedef ALIGN_16 __attribute__((aligned(1))) LOWERED_ALIGNMENT; +_Static_assert(_Alignof(LOWERED_ALIGNMENT) == 1, ""); + +typedef ALIGN_1 __attribute__((aligned(16))) RAISED_ALIGNMENT; +_Static_assert(_Alignof(RAISED_ALIGNMENT) == 16, ""); + +__auto_type ARRAY = (__attribute__((aligned(16))) int[]) {1, 2, 3}; +_Static_assert(_Alignof(__typeof__(ARRAY)) == _Alignof(int *), ""); diff --git a/test/record_runner.zig b/test/record_runner.zig index 1398a602..9a1abe3d 100644 --- a/test/record_runner.zig +++ b/test/record_runner.zig @@ -406,14 +406,6 @@ fn parseTargetsFromCode(cases: *TestCase.List, path: []const u8, source: []const const compErr = blk: { @setEvalBranchQuota(100_000); break :blk std.StaticStringMap(ExpectedFailure).initComptime(.{ - .{ - "aarch64-generic-windows-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "aarch64-generic-windows-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "aarch64-generic-windows-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -466,10 +458,6 @@ const compErr = blk: { "aarch64-generic-windows-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "aarch64-generic-windows-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "aarch64-generic-windows-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -494,14 +482,6 @@ const compErr = blk: { "aarch64-generic-windows-msvc:Msvc|0080", .{ .parse = false, .layout = true, .extra = true, .offset = false }, }, - .{ - "x86-i586-windows-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "x86-i586-windows-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86-i586-windows-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -534,10 +514,6 @@ const compErr = blk: { "x86-i586-windows-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "x86-i586-windows-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86-i586-windows-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -554,14 +530,6 @@ const compErr = blk: { "x86-i586-windows-msvc:Msvc|0066", .{ .parse = false, .layout = true, .extra = true, .offset = false }, }, - .{ - "x86-i686-uefi-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "x86-i686-uefi-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86-i686-uefi-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -594,10 +562,6 @@ const compErr = blk: { "x86-i686-uefi-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "x86-i686-uefi-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86-i686-uefi-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -614,14 +578,6 @@ const compErr = blk: { "x86-i686-uefi-msvc:Msvc|0066", .{ .parse = false, .layout = true, .extra = true, .offset = false }, }, - .{ - "x86-i686-windows-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "x86-i686-windows-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86-i686-windows-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -654,10 +610,6 @@ const compErr = blk: { "x86-i686-windows-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "x86-i686-windows-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86-i686-windows-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -674,14 +626,6 @@ const compErr = blk: { "x86-i686-windows-msvc:Msvc|0066", .{ .parse = false, .layout = true, .extra = true, .offset = false }, }, - .{ - "thumb-baseline-windows-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "thumb-baseline-windows-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "thumb-baseline-windows-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -730,10 +674,6 @@ const compErr = blk: { "thumb-baseline-windows-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "thumb-baseline-windows-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "thumb-baseline-windows-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -758,14 +698,6 @@ const compErr = blk: { "thumb-baseline-windows-msvc:Msvc|0080", .{ .parse = false, .layout = true, .extra = true, .offset = false }, }, - .{ - "x86_64-x86_64-uefi-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "x86_64-x86_64-uefi-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86_64-x86_64-uefi-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -798,10 +730,6 @@ const compErr = blk: { "x86_64-x86_64-uefi-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "x86_64-x86_64-uefi-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86_64-x86_64-uefi-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -818,14 +746,6 @@ const compErr = blk: { "x86_64-x86_64-uefi-msvc:Msvc|0066", .{ .parse = false, .layout = true, .extra = true, .offset = false }, }, - .{ - "x86_64-x86_64-windows-msvc:Msvc|0011", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, - .{ - "x86_64-x86_64-windows-msvc:Msvc|0014", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86_64-x86_64-windows-msvc:Msvc|0018", .{ .parse = false, .layout = false, .extra = true, .offset = false }, @@ -858,10 +778,6 @@ const compErr = blk: { "x86_64-x86_64-windows-msvc:Msvc|0045", .{ .parse = false, .layout = false, .extra = true, .offset = false }, }, - .{ - "x86_64-x86_64-windows-msvc:Msvc|0046", - .{ .parse = false, .layout = true, .extra = true, .offset = false }, - }, .{ "x86_64-x86_64-windows-msvc:Msvc|0053", .{ .parse = false, .layout = false, .extra = true, .offset = false },