| author |  Jakub Konka <kubkon@jakubkonka.com> 2022-02-25 15:26:24+01:00 |
| committer | Jakub Konka <kubkon@jakubkonka.com> 2022-02-25 21:59:19+01:00 |
| log | 1b8ed7842cc09ff687aa7386bf3af8565055a8d1 |
| tree | c439e150d94ca8d9d4263094cb9473a24df0580b |
| parent | bf6540ce50f8613386be09aac7dc03604af12e1e |
macho: redo selection of segment/section for decls and consts
* fix alignment issues for consts with natural ABI alignment not
matching that of the `ldr` instruction in `aarch64` - solved by
preceeding the `ldr` with an additional `add` instruction to form
the full address before dereferencing the pointer.
* redo selection of segment/section for decls and consts based on
combined type and value6 files changed, 108 insertions(+), 112 deletions(-)
src/arch/aarch64/Emit.zig+21-5
| ... | @@ -208,8 +208,8 @@ fn instructionSize(emit: *Emit, inst: Mir.Inst.Index) usize { | ... | @@ -208,8 +208,8 @@ fn instructionSize(emit: *Emit, inst: Mir.Inst.Index) usize { |
| 208 | } | 208 | } |
| 209 | 209 | ||
| 210 | switch (tag) { | 210 | switch (tag) { |
| 211 | .load_memory_direct => return 3 * 4, | ||
| 211 | .load_memory_got, | 212 | .load_memory_got, |
| 212 | .load_memory_direct, | ||
| 213 | .load_memory_ptr_got, | 213 | .load_memory_ptr_got, |
| 214 | .load_memory_ptr_direct, | 214 | .load_memory_ptr_direct, |
| 215 | => return 2 * 4, | 215 | => return 2 * 4, |
| ... | @@ -654,15 +654,31 @@ fn mirLoadMemoryPie(emit: *Emit, inst: Mir.Inst.Index) !void { | ... | @@ -654,15 +654,31 @@ fn mirLoadMemoryPie(emit: *Emit, inst: Mir.Inst.Index) !void { |
| 654 | const data = emit.mir.extraData(Mir.LoadMemoryPie, payload).data; | 654 | const data = emit.mir.extraData(Mir.LoadMemoryPie, payload).data; |
| 655 | const reg = @intToEnum(Register, data.register); | 655 | const reg = @intToEnum(Register, data.register); |
| 656 | 656 | ||
| 657 | // PC-relative displacement to the entry in the GOT table. | 657 | // PC-relative displacement to the entry in memory. |
| 658 | // adrp | 658 | // adrp |
| 659 | const offset = @intCast(u32, emit.code.items.len); | 659 | const offset = @intCast(u32, emit.code.items.len); |
| 660 | try emit.writeInstruction(Instruction.adrp(reg, 0)); | 660 | try emit.writeInstruction(Instruction.adrp(reg, 0)); |
| 661 | 661 | ||
| 662 | switch (tag) { | 662 | switch (tag) { |
| 663 | .load_memory_got, | 663 | .load_memory_got => { |
| 664 | .load_memory_direct, | 664 | // ldr reg, reg, offset |
| 665 | => { | 665 | try emit.writeInstruction(Instruction.ldr( |
| 666 | reg, | ||
| 667 | reg, | ||
| 668 | Instruction.LoadStoreOffset.imm(0), | ||
| 669 | )); | ||
| 670 | }, | ||
| 671 | .load_memory_direct => { | ||
| 672 | // We cannot load the offset directly as it may not be aligned properly. | ||
| 673 | // For example, load for 64bit register will require the target address offset | ||
| 674 | // to be 8-byte aligned, while the value might have non-8-byte natural alignment, | ||
| 675 | // meaning the linker might have put it at a non-8-byte aligned address. To circumvent | ||
| 676 | // this, we use `adrp, add` to form the address value which we then dereference with | ||
| 677 | // `ldr`. | ||
| 678 | // Note that this can potentially be optimised out by the codegen/linker if the | ||
| 679 | // target address is appropriately aligned. | ||
| 680 | // add reg, reg, offset | ||
| 681 | try emit.writeInstruction(Instruction.add(reg, reg, 0, false)); | ||
| 666 | // ldr reg, reg, offset | 682 | // ldr reg, reg, offset |
| 667 | try emit.writeInstruction(Instruction.ldr( | 683 | try emit.writeInstruction(Instruction.ldr( |
| 668 | reg, | 684 | reg, |
src/link/MachO.zig+82-87
| ... | @@ -3797,10 +3797,11 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl: *Module.De | ... | @@ -3797,10 +3797,11 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl: *Module.De |
| 3797 | atom.code.clearRetainingCapacity(); | 3797 | atom.code.clearRetainingCapacity(); |
| 3798 | try atom.code.appendSlice(self.base.allocator, code); | 3798 | try atom.code.appendSlice(self.base.allocator, code); |
| 3799 | 3799 | ||
| 3800 | const match = try self.getMatchingSectionAtom(atom, typed_value.ty, typed_value.val); | 3800 | const match = try self.getMatchingSectionAtom(atom, decl_name, typed_value.ty, typed_value.val); |
| 3801 | const addr = try self.allocateAtom(atom, code.len, required_alignment, match); | 3801 | const addr = try self.allocateAtom(atom, code.len, required_alignment, match); |
| 3802 | 3802 | ||
| 3803 | log.debug("allocated atom for {s} at 0x{x}", .{ name, addr }); | 3803 | log.debug("allocated atom for {s} at 0x{x}", .{ name, addr }); |
| 3804 | log.debug(" (required alignment 0x{x})", .{required_alignment}); | ||
| 3804 | 3805 | ||
| 3805 | errdefer self.freeAtom(atom, match, true); | 3806 | errdefer self.freeAtom(atom, match, true); |
| 3806 | 3807 | ||
| ... | @@ -3903,28 +3904,60 @@ pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void { | ... | @@ -3903,28 +3904,60 @@ pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void { |
| 3903 | try self.updateDeclExports(module, decl, decl_exports); | 3904 | try self.updateDeclExports(module, decl, decl_exports); |
| 3904 | } | 3905 | } |
| 3905 | 3906 | ||
| 3906 | fn isElemTyPointer(ty: Type) bool { | 3907 | /// Checks if the value, or any of its embedded values stores a pointer, and thus requires |
| 3908 | /// a rebase opcode for the dynamic linker. | ||
| 3909 | fn needsPointerRebase(ty: Type, val: Value) bool { | ||
| 3910 | if (ty.zigTypeTag() == .Fn) { | ||
| 3911 | return false; | ||
| 3912 | } | ||
| 3913 | if (val.pointerDecl()) |_| { | ||
| 3914 | return true; | ||
| 3915 | } | ||
| 3916 | |||
| 3907 | switch (ty.zigTypeTag()) { | 3917 | switch (ty.zigTypeTag()) { |
| 3908 | .Fn => return false, | 3918 | .Fn => unreachable, |
| 3909 | .Pointer => return true, | 3919 | .Pointer => return true, |
| 3910 | .Array => { | 3920 | .Array, .Vector => { |
| 3911 | const elem_ty = ty.elemType(); | 3921 | if (ty.arrayLen() == 0) return false; |
| 3912 | return isElemTyPointer(elem_ty); | 3922 | const elem_ty = ty.childType(); |
| 3923 | var elem_value_buf: Value.ElemValueBuffer = undefined; | ||
| 3924 | const elem_val = val.elemValueBuffer(0, &elem_value_buf); | ||
| 3925 | return needsPointerRebase(elem_ty, elem_val); | ||
| 3913 | }, | 3926 | }, |
| 3914 | .Struct, .Union => { | 3927 | .Struct => { |
| 3915 | const len = ty.structFieldCount(); | 3928 | const fields = ty.structFields().values(); |
| 3916 | var i: usize = 0; | 3929 | if (fields.len == 0) return false; |
| 3917 | while (i < len) : (i += 1) { | 3930 | if (val.castTag(.@"struct")) |payload| { |
| 3918 | const field_ty = ty.structFieldType(i); | 3931 | const field_values = payload.data; |
| 3919 | if (isElemTyPointer(field_ty)) return true; | 3932 | for (field_values) |field_val, i| { |
| 3920 | } | 3933 | if (needsPointerRebase(fields[i].ty, field_val)) return true; |
| 3921 | return false; | 3934 | } else return false; |
| 3935 | } else return false; | ||
| 3936 | }, | ||
| 3937 | .Optional => { | ||
| 3938 | if (val.castTag(.opt_payload)) |payload| { | ||
| 3939 | const sub_val = payload.data; | ||
| 3940 | var buffer: Type.Payload.ElemType = undefined; | ||
| 3941 | const sub_ty = ty.optionalChild(&buffer); | ||
| 3942 | return needsPointerRebase(sub_ty, sub_val); | ||
| 3943 | } else return false; | ||
| 3944 | }, | ||
| 3945 | .Union => { | ||
| 3946 | const union_obj = val.cast(Value.Payload.Union).?.data; | ||
| 3947 | const active_field_ty = ty.unionFieldType(union_obj.tag); | ||
| 3948 | return needsPointerRebase(active_field_ty, union_obj.val); | ||
| 3949 | }, | ||
| 3950 | .ErrorUnion => { | ||
| 3951 | if (val.castTag(.eu_payload)) |payload| { | ||
| 3952 | const payload_ty = ty.errorUnionPayload(); | ||
| 3953 | return needsPointerRebase(payload_ty, payload.data); | ||
| 3954 | } else return false; | ||
| 3922 | }, | 3955 | }, |
| 3923 | else => return false, | 3956 | else => return false, |
| 3924 | } | 3957 | } |
| 3925 | } | 3958 | } |
| 3926 | 3959 | ||
| 3927 | fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !MatchingSection { | 3960 | fn getMatchingSectionAtom(self: *MachO, atom: *Atom, name: []const u8, ty: Type, val: Value) !MatchingSection { |
| 3928 | const code = atom.code.items; | 3961 | const code = atom.code.items; |
| 3929 | const alignment = ty.abiAlignment(self.base.options.target); | 3962 | const alignment = ty.abiAlignment(self.base.options.target); |
| 3930 | const align_log_2 = math.log2(alignment); | 3963 | const align_log_2 = math.log2(alignment); |
| ... | @@ -3938,10 +3971,25 @@ fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !Matc | ... | @@ -3938,10 +3971,25 @@ fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !Matc |
| 3938 | .seg = self.data_segment_cmd_index.?, | 3971 | .seg = self.data_segment_cmd_index.?, |
| 3939 | .sect = self.bss_section_index.?, | 3972 | .sect = self.bss_section_index.?, |
| 3940 | }; | 3973 | }; |
| 3974 | } else { | ||
| 3975 | break :blk MatchingSection{ | ||
| 3976 | .seg = self.data_segment_cmd_index.?, | ||
| 3977 | .sect = self.data_section_index.?, | ||
| 3978 | }; | ||
| 3941 | } | 3979 | } |
| 3980 | } | ||
| 3981 | |||
| 3982 | if (val.castTag(.variable)) |_| { | ||
| 3983 | break :blk MatchingSection{ | ||
| 3984 | .seg = self.data_segment_cmd_index.?, | ||
| 3985 | .sect = self.data_section_index.?, | ||
| 3986 | }; | ||
| 3987 | } | ||
| 3988 | |||
| 3989 | if (needsPointerRebase(ty, val)) { | ||
| 3942 | break :blk (try self.getMatchingSection(.{ | 3990 | break :blk (try self.getMatchingSection(.{ |
| 3943 | .segname = makeStaticString("__DATA"), | 3991 | .segname = makeStaticString("__DATA_CONST"), |
| 3944 | .sectname = makeStaticString("__data"), | 3992 | .sectname = makeStaticString("__const"), |
| 3945 | .size = code.len, | 3993 | .size = code.len, |
| 3946 | .@"align" = align_log_2, | 3994 | .@"align" = align_log_2, |
| 3947 | })).?; | 3995 | })).?; |
| ... | @@ -3954,8 +4002,8 @@ fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !Matc | ... | @@ -3954,8 +4002,8 @@ fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !Matc |
| 3954 | .sect = self.text_section_index.?, | 4002 | .sect = self.text_section_index.?, |
| 3955 | }; | 4003 | }; |
| 3956 | }, | 4004 | }, |
| 3957 | .Array => switch (val.tag()) { | 4005 | .Array => { |
| 3958 | .bytes => { | 4006 | if (val.tag() == .bytes) { |
| 3959 | switch (ty.tag()) { | 4007 | switch (ty.tag()) { |
| 3960 | .array_u8_sentinel_0, | 4008 | .array_u8_sentinel_0, |
| 3961 | .const_slice_u8_sentinel_0, | 4009 | .const_slice_u8_sentinel_0, |
| ... | @@ -3969,79 +4017,23 @@ fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !Matc | ... | @@ -3969,79 +4017,23 @@ fn getMatchingSectionAtom(self: *MachO, atom: *Atom, ty: Type, val: Value) !Matc |
| 3969 | .@"align" = align_log_2, | 4017 | .@"align" = align_log_2, |
| 3970 | })).?; | 4018 | })).?; |
| 3971 | }, | 4019 | }, |
| 3972 | else => { | 4020 | else => {}, |
| 3973 | break :blk (try self.getMatchingSection(.{ | ||
| 3974 | .segname = makeStaticString("__TEXT"), | ||
| 3975 | .sectname = makeStaticString("__const"), | ||
| 3976 | .size = code.len, | ||
| 3977 | .@"align" = align_log_2, | ||
| 3978 | })).?; | ||
| 3979 | }, | ||
| 3980 | } | ||
| 3981 | }, | ||
| 3982 | .array => { | ||
| 3983 | if (isElemTyPointer(ty)) { | ||
| 3984 | break :blk (try self.getMatchingSection(.{ | ||
| 3985 | .segname = makeStaticString("__DATA_CONST"), | ||
| 3986 | .sectname = makeStaticString("__const"), | ||
| 3987 | .size = code.len, | ||
| 3988 | .@"align" = align_log_2, | ||
| 3989 | })).?; | ||
| 3990 | } else { | ||
| 3991 | break :blk (try self.getMatchingSection(.{ | ||
| 3992 | .segname = makeStaticString("__TEXT"), | ||
| 3993 | .sectname = makeStaticString("__const"), | ||
| 3994 | .size = code.len, | ||
| 3995 | .@"align" = align_log_2, | ||
| 3996 | })).?; | ||
| 3997 | } | 4021 | } |
| 3998 | }, | ||
| 3999 | else => { | ||
| 4000 | break :blk (try self.getMatchingSection(.{ | ||
| 4001 | .segname = makeStaticString("__TEXT"), | ||
| 4002 | .sectname = makeStaticString("__const"), | ||
| 4003 | .size = code.len, | ||
| 4004 | .@"align" = align_log_2, | ||
| 4005 | })).?; | ||
| 4006 | }, | ||
| 4007 | }, | ||
| 4008 | .Pointer => { | ||
| 4009 | if (val.castTag(.variable)) |_| { | ||
| 4010 | break :blk MatchingSection{ | ||
| 4011 | .seg = self.data_segment_cmd_index.?, | ||
| 4012 | .sect = self.data_section_index.?, | ||
| 4013 | }; | ||
| 4014 | } else { | ||
| 4015 | break :blk (try self.getMatchingSection(.{ | ||
| 4016 | .segname = makeStaticString("__DATA_CONST"), | ||
| 4017 | .sectname = makeStaticString("__const"), | ||
| 4018 | .size = code.len, | ||
| 4019 | .@"align" = align_log_2, | ||
| 4020 | })).?; | ||
| 4021 | } | ||
| 4022 | }, | ||
| 4023 | else => { | ||
| 4024 | if (val.castTag(.variable)) |_| { | ||
| 4025 | break :blk MatchingSection{ | ||
| 4026 | .seg = self.data_segment_cmd_index.?, | ||
| 4027 | .sect = self.data_section_index.?, | ||
| 4028 | }; | ||
| 4029 | } else { | ||
| 4030 | break :blk (try self.getMatchingSection(.{ | ||
| 4031 | .segname = makeStaticString("__TEXT"), | ||
| 4032 | .sectname = makeStaticString("__const"), | ||
| 4033 | .size = code.len, | ||
| 4034 | .@"align" = align_log_2, | ||
| 4035 | })).?; | ||
| 4036 | } | 4022 | } |
| 4037 | }, | 4023 | }, |
| 4024 | else => {}, | ||
| 4038 | } | 4025 | } |
| 4026 | break :blk (try self.getMatchingSection(.{ | ||
| 4027 | .segname = makeStaticString("__TEXT"), | ||
| 4028 | .sectname = makeStaticString("__const"), | ||
| 4029 | .size = code.len, | ||
| 4030 | .@"align" = align_log_2, | ||
| 4031 | })).?; | ||
| 4039 | }; | 4032 | }; |
| 4040 | const local = self.locals.items[atom.local_sym_index]; | ||
| 4041 | const seg = self.load_commands.items[match.seg].segment; | 4033 | const seg = self.load_commands.items[match.seg].segment; |
| 4042 | const sect = seg.sections.items[match.sect]; | 4034 | const sect = seg.sections.items[match.sect]; |
| 4043 | log.debug(" allocating atom '{s}' in '{s},{s}' ({d},{d})", .{ | 4035 | log.debug(" allocating atom '{s}' in '{s},{s}' ({d},{d})", .{ |
| 4044 | self.getString(local.n_strx), | 4036 | name, |
| 4045 | sect.segName(), | 4037 | sect.segName(), |
| 4046 | sect.sectName(), | 4038 | sect.sectName(), |
| 4047 | match.seg, | 4039 | match.seg, |
| ... | @@ -4055,13 +4047,14 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64 | ... | @@ -4055,13 +4047,14 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64 |
| 4055 | assert(decl.link.macho.local_sym_index != 0); // Caller forgot to call allocateDeclIndexes() | 4047 | assert(decl.link.macho.local_sym_index != 0); // Caller forgot to call allocateDeclIndexes() |
| 4056 | const symbol = &self.locals.items[decl.link.macho.local_sym_index]; | 4048 | const symbol = &self.locals.items[decl.link.macho.local_sym_index]; |
| 4057 | 4049 | ||
| 4050 | const sym_name = try decl.getFullyQualifiedName(self.base.allocator); | ||
| 4051 | defer self.base.allocator.free(sym_name); | ||
| 4052 | |||
| 4058 | const decl_ptr = self.decls.getPtr(decl).?; | 4053 | const decl_ptr = self.decls.getPtr(decl).?; |
| 4059 | if (decl_ptr.* == null) { | 4054 | if (decl_ptr.* == null) { |
| 4060 | decl_ptr.* = try self.getMatchingSectionAtom(&decl.link.macho, decl.ty, decl.val); | 4055 | decl_ptr.* = try self.getMatchingSectionAtom(&decl.link.macho, sym_name, decl.ty, decl.val); |
| 4061 | } | 4056 | } |
| 4062 | const match = decl_ptr.*.?; | 4057 | const match = decl_ptr.*.?; |
| 4063 | const sym_name = try decl.getFullyQualifiedName(self.base.allocator); | ||
| 4064 | defer self.base.allocator.free(sym_name); | ||
| 4065 | 4058 | ||
| 4066 | if (decl.link.macho.size != 0) { | 4059 | if (decl.link.macho.size != 0) { |
| 4067 | const capacity = decl.link.macho.capacity(self.*); | 4060 | const capacity = decl.link.macho.capacity(self.*); |
| ... | @@ -4071,6 +4064,7 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64 | ... | @@ -4071,6 +4064,7 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64 |
| 4071 | const vaddr = try self.growAtom(&decl.link.macho, code_len, required_alignment, match); | 4064 | const vaddr = try self.growAtom(&decl.link.macho, code_len, required_alignment, match); |
| 4072 | 4065 | ||
| 4073 | log.debug("growing {s} and moving from 0x{x} to 0x{x}", .{ sym_name, symbol.n_value, vaddr }); | 4066 | log.debug("growing {s} and moving from 0x{x} to 0x{x}", .{ sym_name, symbol.n_value, vaddr }); |
| 4067 | log.debug(" (required alignment 0x{x})", .{required_alignment}); | ||
| 4074 | 4068 | ||
| 4075 | if (vaddr != symbol.n_value) { | 4069 | if (vaddr != symbol.n_value) { |
| 4076 | log.debug(" (writing new GOT entry)", .{}); | 4070 | log.debug(" (writing new GOT entry)", .{}); |
| ... | @@ -4105,6 +4099,7 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64 | ... | @@ -4105,6 +4099,7 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64 |
| 4105 | const addr = try self.allocateAtom(&decl.link.macho, code_len, required_alignment, match); | 4099 | const addr = try self.allocateAtom(&decl.link.macho, code_len, required_alignment, match); |
| 4106 | 4100 | ||
| 4107 | log.debug("allocated atom for {s} at 0x{x}", .{ sym_name, addr }); | 4101 | log.debug("allocated atom for {s} at 0x{x}", .{ sym_name, addr }); |
| 4102 | log.debug(" (required alignment 0x{x})", .{required_alignment}); | ||
| 4108 | 4103 | ||
| 4109 | errdefer self.freeAtom(&decl.link.macho, match, false); | 4104 | errdefer self.freeAtom(&decl.link.macho, match, false); |
| 4110 | 4105 |
src/link/MachO/Atom.zig+5-5
| ... | @@ -691,11 +691,11 @@ pub fn resolveRelocs(self: *Atom, macho_file: *MachO) !void { | ... | @@ -691,11 +691,11 @@ pub fn resolveRelocs(self: *Atom, macho_file: *MachO) !void { |
| 691 | 691 | ||
| 692 | if (is_via_got) { | 692 | if (is_via_got) { |
| 693 | const got_index = macho_file.got_entries_table.get(rel.target) orelse { | 693 | const got_index = macho_file.got_entries_table.get(rel.target) orelse { |
| 694 | const n_strx = switch (rel.target) { | 694 | log.err("expected GOT entry for symbol", .{}); |
| 695 | .local => |sym_index| macho_file.locals.items[sym_index].n_strx, | 695 | switch (rel.target) { |
| 696 | .global => |n_strx| n_strx, | 696 | .local => |sym_index| log.err(" local @{d}", .{sym_index}), |
| 697 | }; | 697 | .global => |n_strx| log.err(" global @'{s}'", .{macho_file.getString(n_strx)}), |
| 698 | log.err("expected GOT entry for symbol '{s}'", .{macho_file.getString(n_strx)}); | 698 | } |
| 699 | log.err(" this is an internal linker error", .{}); | 699 | log.err(" this is an internal linker error", .{}); |
| 700 | return error.FailedToResolveRelocationTarget; | 700 | return error.FailedToResolveRelocationTarget; |
| 701 | }; | 701 | }; |
test/behavior/align.zig-1
| ... | @@ -7,7 +7,6 @@ var foo: u8 align(4) = 100; | ... | @@ -7,7 +7,6 @@ var foo: u8 align(4) = 100; |
| 7 | 7 | ||
| 8 | test "global variable alignment" { | 8 | test "global variable alignment" { |
| 9 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 9 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 10 | if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .macos) return error.SkipZigTest; | ||
| 11 | 10 | ||
| 12 | comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); | 11 | comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); |
| 13 | comptime try expect(@TypeOf(&foo) == *align(4) u8); | 12 | comptime try expect(@TypeOf(&foo) == *align(4) u8); |
test/behavior/basic.zig-3
| ... | @@ -195,9 +195,6 @@ test "multiline string comments at multiple places" { | ... | @@ -195,9 +195,6 @@ test "multiline string comments at multiple places" { |
| 195 | } | 195 | } |
| 196 | 196 | ||
| 197 | test "string concatenation" { | 197 | test "string concatenation" { |
| 198 | if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; | ||
| 199 | if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .macos) return error.SkipZigTest; | ||
| 200 | |||
| 201 | try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); | 198 | try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); |
| 202 | } | 199 | } |
| 203 | 200 |
test/behavior/union.zig-11
| ... | @@ -44,7 +44,6 @@ fn setInt(foo: *Foo, x: i32) void { | ... | @@ -44,7 +44,6 @@ fn setInt(foo: *Foo, x: i32) void { |
| 44 | 44 | ||
| 45 | test "comptime union field access" { | 45 | test "comptime union field access" { |
| 46 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 46 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 47 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 48 | 47 | ||
| 49 | comptime { | 48 | comptime { |
| 50 | var foo = Foo{ .int = 0 }; | 49 | var foo = Foo{ .int = 0 }; |
| ... | @@ -77,14 +76,12 @@ const ExternPtrOrInt = extern union { | ... | @@ -77,14 +76,12 @@ const ExternPtrOrInt = extern union { |
| 77 | }; | 76 | }; |
| 78 | test "extern union size" { | 77 | test "extern union size" { |
| 79 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 78 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 80 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 81 | 79 | ||
| 82 | comptime try expect(@sizeOf(ExternPtrOrInt) == 8); | 80 | comptime try expect(@sizeOf(ExternPtrOrInt) == 8); |
| 83 | } | 81 | } |
| 84 | 82 | ||
| 85 | test "0-sized extern union definition" { | 83 | test "0-sized extern union definition" { |
| 86 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 84 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 87 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 88 | 85 | ||
| 89 | const U = extern union { | 86 | const U = extern union { |
| 90 | a: void, | 87 | a: void, |
| ... | @@ -115,9 +112,7 @@ const err = @as(anyerror!Agg, Agg{ | ... | @@ -115,9 +112,7 @@ const err = @as(anyerror!Agg, Agg{ |
| 115 | const array = [_]Value{ v1, v2, v1, v2 }; | 112 | const array = [_]Value{ v1, v2, v1, v2 }; |
| 116 | 113 | ||
| 117 | test "unions embedded in aggregate types" { | 114 | test "unions embedded in aggregate types" { |
| 118 | if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .macos) return error.SkipZigTest; | ||
| 119 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 115 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 120 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 121 | 116 | ||
| 122 | switch (array[1]) { | 117 | switch (array[1]) { |
| 123 | Value.Array => |arr| try expect(arr[4] == 3), | 118 | Value.Array => |arr| try expect(arr[4] == 3), |
| ... | @@ -131,7 +126,6 @@ test "unions embedded in aggregate types" { | ... | @@ -131,7 +126,6 @@ test "unions embedded in aggregate types" { |
| 131 | 126 | ||
| 132 | test "access a member of tagged union with conflicting enum tag name" { | 127 | test "access a member of tagged union with conflicting enum tag name" { |
| 133 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 128 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 134 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 135 | 129 | ||
| 136 | const Bar = union(enum) { | 130 | const Bar = union(enum) { |
| 137 | A: A, | 131 | A: A, |
| ... | @@ -176,7 +170,6 @@ const TaggedUnionWithPayload = union(enum) { | ... | @@ -176,7 +170,6 @@ const TaggedUnionWithPayload = union(enum) { |
| 176 | 170 | ||
| 177 | test "union alignment" { | 171 | test "union alignment" { |
| 178 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 172 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 179 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 180 | 173 | ||
| 181 | comptime { | 174 | comptime { |
| 182 | try expect(@alignOf(AlignTestTaggedUnion) >= @alignOf([9]u8)); | 175 | try expect(@alignOf(AlignTestTaggedUnion) >= @alignOf([9]u8)); |
| ... | @@ -276,7 +269,6 @@ fn testCastUnionToTag() !void { | ... | @@ -276,7 +269,6 @@ fn testCastUnionToTag() !void { |
| 276 | 269 | ||
| 277 | test "union field access gives the enum values" { | 270 | test "union field access gives the enum values" { |
| 278 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 271 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 279 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 280 | 272 | ||
| 281 | try expect(TheUnion.A == TheTag.A); | 273 | try expect(TheUnion.A == TheTag.A); |
| 282 | try expect(TheUnion.B == TheTag.B); | 274 | try expect(TheUnion.B == TheTag.B); |
| ... | @@ -352,7 +344,6 @@ const PackedPtrOrInt = packed union { | ... | @@ -352,7 +344,6 @@ const PackedPtrOrInt = packed union { |
| 352 | }; | 344 | }; |
| 353 | test "packed union size" { | 345 | test "packed union size" { |
| 354 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 346 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 355 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 356 | 347 | ||
| 357 | comptime try expect(@sizeOf(PackedPtrOrInt) == 8); | 348 | comptime try expect(@sizeOf(PackedPtrOrInt) == 8); |
| 358 | } | 349 | } |
| ... | @@ -362,7 +353,6 @@ const ZeroBits = union { | ... | @@ -362,7 +353,6 @@ const ZeroBits = union { |
| 362 | }; | 353 | }; |
| 363 | test "union with only 1 field which is void should be zero bits" { | 354 | test "union with only 1 field which is void should be zero bits" { |
| 364 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 355 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 365 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 366 | 356 | ||
| 367 | comptime try expect(@sizeOf(ZeroBits) == 0); | 357 | comptime try expect(@sizeOf(ZeroBits) == 0); |
| 368 | } | 358 | } |
| ... | @@ -422,7 +412,6 @@ test "union with only 1 field casted to its enum type" { | ... | @@ -422,7 +412,6 @@ test "union with only 1 field casted to its enum type" { |
| 422 | 412 | ||
| 423 | test "union with one member defaults to u0 tag type" { | 413 | test "union with one member defaults to u0 tag type" { |
| 424 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; | 414 | if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; |
| 425 | if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; | ||
| 426 | 415 | ||
| 427 | const U0 = union(enum) { | 416 | const U0 = union(enum) { |
| 428 | X: u32, | 417 | X: u32, |