Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 Zig
Normal View History Raw
align(@alignOf(T)) T does not force resolution of T
2019-08-30 14:53:44 -04:00
const std = @import("std");
const expect = std.testing.expect;
add @setAlignStack builtin
2017-10-02 22:00:42 -04:00
const builtin = @import("builtin");
update behavior tests with respect to new builtin pkg
2021-04-29 15:18:40 -07:00
const native_arch = builtin.target.cpu.arch;
Sema: fix alignment of element ptr result type
2022-06-01 15:43:21 -07:00
const assert = std.debug.assert;
fix bitfield pointer syntax See #37
2017-08-29 08:35:51 -04:00
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
var foo: u8 align(4) = 100;
test "global variable alignment" {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
comptime assert(@typeInfo(@TypeOf(&foo)).pointer.alignment == 4);
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(@TypeOf(&foo) == *align(4) u8);
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
{
Sema: implement pointer-to-tuple coercion to slice and struct
2022-03-09 17:33:01 -07:00
const slice = @as(*align(4) [1]u8, &foo)[0..];
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(@TypeOf(slice) == *align(4) [1]u8);
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
}
stage2: fix pointer arithmetic result type This makes it so the result of doing pointer arithmetic creates a new pointer type that has adjusted alignment.
2022-05-17 01:52:02 -07:00
}
migrate make_ptr_const to new anonymous decl mechanism Instead of creating Module.Decl objects, directly create InternPool pointer values using the anon_decl Addr encoding. The LLVM backend needed code to notice the alignment of the pointer and lower accordingly. The other backends likely need a similar change.
2023-10-15 16:49:59 -07:00
test "large alignment of local constant" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
spirv: unused instruction pruning linker pass
2024-03-17 14:16:04 +01:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
migrate make_ptr_const to new anonymous decl mechanism Instead of creating Module.Decl objects, directly create InternPool pointer values using the anon_decl Addr encoding. The LLVM backend needed code to notice the alignment of the pointer and lower accordingly. The other backends likely need a similar change.
2023-10-15 16:49:59 -07:00
const x: f32 align(128) = 12.34;
try std.testing.expect(@intFromPtr(&x) % 128 == 0);
}
fix alignment behavior test case As demonstrated by this new test case, stage1's functionality is incorrect since it does not handle slicing from len..len correctly. stage2 already has the correct behavior here.
2022-05-26 21:55:51 -07:00
test "slicing array of length 1 can not assume runtime index is always zero" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
spirv: update tests
2024-01-13 18:44:44 +01:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
stage2: fix pointer arithmetic result type This makes it so the result of doing pointer arithmetic creates a new pointer type that has adjusted alignment.
2022-05-17 01:52:02 -07:00
fix alignment behavior test case As demonstrated by this new test case, stage1's functionality is incorrect since it does not handle slicing from len..len correctly. stage2 already has the correct behavior here.
2022-05-26 21:55:51 -07:00
var runtime_index: usize = 1;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &runtime_index;
fix alignment behavior test case As demonstrated by this new test case, stage1's functionality is incorrect since it does not handle slicing from len..len correctly. stage2 already has the correct behavior here.
2022-05-26 21:55:51 -07:00
const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
try expect(@TypeOf(slice) == []u8);
try expect(slice.len == 0);
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u2, @truncate(@intFromPtr(slice.ptr) - 1)) == 0);
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
}
test "default alignment allows unspecified in type syntax" {
try expect(*u32 == *align(@alignOf(u32)) u32);
}
test "implicitly decreasing pointer alignment" {
const a: u32 align(4) = 3;
const b: u32 align(8) = 4;
try expect(addUnaligned(&a, &b) == 7);
}
fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
return a.* + b.*;
}
test "@alignCast pointers" {
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
var x: u32 align(4) = 1;
expectsOnly1(&x);
try expect(x == 2);
}
fn expectsOnly1(x: *align(1) u32) void {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
expects4(@alignCast(x));
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
}
fn expects4(x: *align(4) u32) void {
x.* += 1;
}
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
test "alignment of struct with pointer has same alignment as usize" {
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
try expect(@alignOf(struct {
a: i32,
b: *i32,
}) == @alignOf(usize));
}
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
test "alignment and size of structs with 128-bit fields" {
stage2: change x86_64 max int alignment from 8 to 16 For x86_64, LLVMABIAlignmentOfType(i128) reports 8. However I think 16 is a better number for two reasons: 1. Better machine code when loading into SIMD register. 2. The C ABI wants 16 for extern structs.
2022-05-04 15:22:41 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
stage2: change x86_64 max int alignment from 8 to 16 For x86_64, LLVMABIAlignmentOfType(i128) reports 8. However I think 16 is a better number for two reasons: 1. Better machine code when loading into SIMD register. 2. The C ABI wants 16 for extern structs.
2022-05-04 15:22:41 -07:00
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
const A = struct {
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
x: u128,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
};
const B = extern struct {
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
x: u128,
y: u8,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
};
const expected = switch (builtin.cpu.arch) {
compiler: Update max int alignments for some targets.
2025-03-05 07:59:58 +01:00
.amdgcn,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
.arm,
.armeb,
.thumb,
.thumbeb,
.hexagon,
compiler: Update max int alignments for some targets.
2025-03-05 07:59:58 +01:00
.lanai,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
.mips,
.mipsel,
.powerpc,
.powerpcle,
.riscv32,
.s390x,
=> .{
.a_align = 8,
.a_size = 16,
improved ABI alignment/size for >= 128-bit integers * riscv64: adjust alignment and size of 128-bit integers. * take ofmt=c into account for ABI alignment of 128-bit integers and structs. * Type: make packed struct support intInfo * fix f80 alignment for i386-windows-msvc
2022-08-18 20:34:36 -07:00
.b_align = 16,
.b_size = 32,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
.u128_align = 8,
.u128_size = 16,
.u129_align = 8,
.u129_size = 24,
},
.aarch64,
.aarch64_be,
.bpfel,
.bpfeb,
compiler: Update max int alignments for some targets.
2025-03-05 07:59:58 +01:00
.mips64,
.mips64el,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
.nvptx,
.nvptx64,
compiler: Update max int alignments for some targets.
2025-03-05 07:59:58 +01:00
.powerpc64,
.powerpc64le,
.sparc,
.sparc64,
.riscv64,
.wasm32,
.wasm64,
.x86,
.x86_64,
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
=> .{
.a_align = 16,
.a_size = 16,
.b_align = 16,
.b_size = 32,
.u128_align = 16,
.u128_size = 16,
.u129_align = 16,
.u129_size = 32,
},
else => return error.SkipZigTest,
};
cbe: get behavior tests running on arm Specifically without linking libc.
2023-07-30 07:49:45 -04:00
const min_struct_align = if (builtin.zig_backend == .stage2_c) 16 else 0;
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
comptime {
cbe: get behavior tests running on arm Specifically without linking libc.
2023-07-30 07:49:45 -04:00
assert(@alignOf(A) == @max(expected.a_align, min_struct_align));
stage2: agree with LLVM that `@alignOf(u128)` is 8 on x86_64 and similar targets.
2022-07-16 16:27:37 -07:00
assert(@sizeOf(A) == expected.a_size);
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
cbe: get behavior tests running on arm Specifically without linking libc.
2023-07-30 07:49:45 -04:00
assert(@alignOf(B) == @max(expected.b_align, min_struct_align));
stage2: agree with LLVM that `@alignOf(u128)` is 8 on x86_64 and similar targets.
2022-07-16 16:27:37 -07:00
assert(@sizeOf(B) == expected.b_size);
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
stage2: agree with LLVM that `@alignOf(u128)` is 8 on x86_64 and similar targets.
2022-07-16 16:27:37 -07:00
assert(@alignOf(u128) == expected.u128_align);
assert(@sizeOf(u128) == expected.u128_size);
stage2: improve `@sizeOf` and `@alignOf` integers Prior to this commit, the logic for ABI size and ABI alignment for integers was naive and incorrect. This results in wasted hardware as well as undefined behavior in the LLVM backend when we memset an incorrect number of bytes to 0xaa due to disagreeing with LLVM about the ABI size of integers. This commit introduces a "max int align" value which is different per Target. This value is used to derive the ABI size and alignment of all integers. This commit makes an interesting change from stage1, which treats 128-bit integers as 16-bytes aligned for x86_64-linux. stage1 is incorrect. The maximum integer alignment on this system is only 8 bytes. This change breaks the behavior test called "128-bit cmpxchg" because on that target, 128-bit cmpxchg does require a 16-bytes aligned pointer to a 128 bit integer. However, this alignment property does not belong on *all* 128 bit integers - only on the pointer type in the `@cmpxchg` builtin function prototype. The user can then use an alignment override annotation on a 128-bit integer variable or struct field to obtain such a pointer.
2022-05-03 23:44:32 -07:00
stage2: agree with LLVM that `@alignOf(u128)` is 8 on x86_64 and similar targets.
2022-07-16 16:27:37 -07:00
assert(@alignOf(u129) == expected.u129_align);
assert(@sizeOf(u129) == expected.u129_size);
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
}
}
prevent implicitly increasing pointer alignment See #37
2017-08-29 15:19:15 -04:00
test "implicitly decreasing slice alignment" {
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
align syntax: align(4) instead of align 4 closes #37
2017-08-30 04:54:33 -04:00
const a: u32 align(4) = 3;
const b: u32 align(8) = 4;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7);
prevent implicitly increasing pointer alignment See #37
2017-08-29 15:19:15 -04:00
}
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
return a[0] + b[0];
}
stage2: implement aligned variables and `@alignCast` * Sema: implement zirAllocExtended * Sema: implement zirAlignCast
2021-10-22 17:50:36 -07:00
test "specifying alignment allows pointer cast" {
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
stage2: implement aligned variables and `@alignCast` * Sema: implement zirAllocExtended * Sema: implement zirAlignCast
2021-10-22 17:50:36 -07:00
try testBytesAlign(0x33);
}
fn testBytesAlign(b: u8) !void {
var bytes align(4) = [_]u8{ b, b, b, b };
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const ptr = @as(*u32, @ptrCast(&bytes[0]));
stage2: implement aligned variables and `@alignCast` * Sema: implement zirAllocExtended * Sema: implement zirAlignCast
2021-10-22 17:50:36 -07:00
try expect(ptr.* == 0x33333333);
}
test "@alignCast slices" {
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
Sema: don't add union field access safety check for single field unions
2022-07-23 14:26:01 +03:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
stage2: implement aligned variables and `@alignCast` * Sema: implement zirAllocExtended * Sema: implement zirAlignCast
2021-10-22 17:50:36 -07:00
var array align(4) = [_]u32{ 1, 1 };
const slice = array[0..];
sliceExpectsOnly1(slice);
try expect(slice[0] == 2);
}
fn sliceExpectsOnly1(slice: []align(1) u32) void {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
sliceExpects4(@alignCast(slice));
stage2: implement aligned variables and `@alignCast` * Sema: implement zirAllocExtended * Sema: implement zirAlignCast
2021-10-22 17:50:36 -07:00
}
fn sliceExpects4(slice: []align(4) u32) void {
slice[0] += 1;
}
test "return error union with 128-bit integer" {
riscv: big rewrite to use latest liveness this one is even harder to document then the last large overhaul. TLDR; - split apart Emit.zig into an Emit.zig and a Lower.zig - created seperate files for the encoding, and now adding a new instruction is as simple as just adding it to a couple of switch statements and providing the encoding. - relocs are handled in a more sane maner, and we have a clear defining boundary between lea_symbol and load_symbol now. - a lot of different abstractions for things like the stack, memory, registers, and others. - we're using x86_64's FrameIndex now, which simplifies a lot of the tougher design process. - a lot more that I don't have the energy to document. at this point, just read the commit itself :p
2024-04-03 00:15:56 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
x64: pass more behavior tests
2022-02-28 19:54:13 +01:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: return error.SkipZigTest in unsupported behavior tests
2022-01-17 20:30:44 +01:00
stage2: implement aligned variables and `@alignCast` * Sema: implement zirAllocExtended * Sema: implement zirAlignCast
2021-10-22 17:50:36 -07:00
try expect(3 == try give());
}
fn give() anyerror!u128 {
return 3;
}
c backend: Implement aligning fields and local/global variables There are some restrictions here. - We either need C11 or a compiler that supports the aligned attribute - We cannot provide align less than the type's natural C alignment.
2022-01-20 22:46:15 +01:00
test "page aligned array on stack" {
riscv: big rewrite to use latest liveness this one is even harder to document then the last large overhaul. TLDR; - split apart Emit.zig into an Emit.zig and a Lower.zig - created seperate files for the encoding, and now adding a new instruction is as simple as just adding it to a couple of switch statements and providing the encoding. - relocs are handled in a more sane maner, and we have a clear defining boundary between lea_symbol and load_symbol now. - a lot of different abstractions for things like the stack, memory, registers, and others. - we're using x86_64's FrameIndex now, which simplifies a lot of the tougher design process. - a lot more that I don't have the energy to document. at this point, just read the commit itself :p
2024-04-03 00:15:56 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
behavior tests: prevent disabled tests from lowering std.Target
2022-01-24 22:04:28 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
disable failing CBE behavior tests failing on aarch64-windows Also start to move redundant tests next to each other to make them slightly more obvious that they need to be cleaned up. See tracking issue #13876
2022-12-10 13:44:12 -07:00
c backend: Implement aligning fields and local/global variables There are some restrictions here. - We either need C11 or a compiler that supports the aligned attribute - We cannot provide align less than the type's natural C alignment.
2022-01-20 22:46:15 +01:00
// Large alignment value to make it hard to accidentally pass.
var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
var number1: u8 align(16) = 42;
var number2: u8 align(16) = 43;
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
try expect(@intFromPtr(&array[0]) & 0xFFF == 0);
c backend: Implement aligning fields and local/global variables There are some restrictions here. - We either need C11 or a compiler that supports the aligned attribute - We cannot provide align less than the type's natural C alignment.
2022-01-20 22:46:15 +01:00
try expect(array[3] == 4);
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u4, @truncate(@intFromPtr(&number1))) == 0);
try expect(@as(u4, @truncate(@intFromPtr(&number2))) == 0);
c backend: Implement aligning fields and local/global variables There are some restrictions here. - We either need C11 or a compiler that supports the aligned attribute - We cannot provide align less than the type's natural C alignment.
2022-01-20 22:46:15 +01:00
try expect(number1 == 42);
try expect(number2 == 43);
}
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 00:49:58 -07:00
test "function alignment" {
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 00:49:58 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 00:49:58 -07:00
x86_64: implement switch jump tables
2025-01-02 03:10:19 -05:00
// function alignment is a compile error on wasm
if (native_arch.isWasm()) return error.SkipZigTest;
behavior tests: prevent disabled tests from lowering std.Target
2022-01-24 22:04:28 -07:00
AstGen: disallow alignment on function types A pointer type already has an alignment, so this information does not need to be duplicated on the function type. This already has precedence with addrspace which is already disallowed on function types for this reason. Also fixes `@TypeOf(&func)` to have the correct addrspace and alignment.
2024-03-16 16:46:45 +01:00
const S = struct {
fn alignExpr() align(@sizeOf(usize) * 2) i32 {
return 1234;
}
fn align1() align(1) void {}
fn align4() align(4) void {}
};
try expect(S.alignExpr() == 1234);
try expect(@TypeOf(S.alignExpr) == fn () i32);
try expect(@TypeOf(&S.alignExpr) == *align(@sizeOf(usize) * 2) const fn () i32);
S.align1();
try expect(@TypeOf(S.align1) == fn () void);
try expect(@TypeOf(&S.align1) == *align(1) const fn () void);
S.align4();
try expect(@TypeOf(S.align4) == fn () void);
try expect(@TypeOf(&S.align4) == *align(4) const fn () void);
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 00:49:58 -07:00
}
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
test "implicitly decreasing fn alignment" {
Sema: implement pointer to tuple to pointer to array coercion This involved an LLVM backend fix for the aggregate_init instruction.
2022-03-09 18:47:42 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
x86_64: implement switch jump tables
2025-01-02 03:10:19 -05:00
// function alignment is a compile error on wasm
if (native_arch.isWasm()) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
try testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
try testImplicitlyDecreaseFnAlign(alignedBig, 5678);
}
AstGen: disallow alignment on function types A pointer type already has an alignment, so this information does not need to be duplicated on the function type. This already has precedence with addrspace which is already disallowed on function types for this reason. Also fixes `@TypeOf(&func)` to have the correct addrspace and alignment.
2024-03-16 16:46:45 +01:00
fn testImplicitlyDecreaseFnAlign(ptr: *align(1) const fn () i32, answer: i32) !void {
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
try expect(ptr() == answer);
}
fn alignedSmall() align(8) i32 {
return 1234;
}
fn alignedBig() align(16) i32 {
return 5678;
}
test "@alignCast functions" {
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
x86_64: implement switch jump tables
2025-01-02 03:10:19 -05:00
// function alignment is a compile error on wasm
if (native_arch.isWasm()) return error.SkipZigTest;
if (native_arch.isThumb()) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
try expect(fnExpectsOnly1(simple4) == 0x19);
}
AstGen: disallow alignment on function types A pointer type already has an alignment, so this information does not need to be duplicated on the function type. This already has precedence with addrspace which is already disallowed on function types for this reason. Also fixes `@TypeOf(&func)` to have the correct addrspace and alignment.
2024-03-16 16:46:45 +01:00
fn fnExpectsOnly1(ptr: *align(1) const fn () i32) i32 {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return fnExpects4(@alignCast(ptr));
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
AstGen: disallow alignment on function types A pointer type already has an alignment, so this information does not need to be duplicated on the function type. This already has precedence with addrspace which is already disallowed on function types for this reason. Also fixes `@TypeOf(&func)` to have the correct addrspace and alignment.
2024-03-16 16:46:45 +01:00
fn fnExpects4(ptr: *align(4) const fn () i32) i32 {
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
return ptr();
}
fn simple4() align(4) i32 {
return 0x19;
}
fix(text): hyphenate "runtime" adjectives
2022-10-05 21:17:06 +02:00
test "runtime-known array index has best alignment possible" {
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
// take full advantage of over-alignment
var array align(4) = [_]u8{ 1, 2, 3, 4 };
Sema: fix alignment of element ptr result type
2022-06-01 15:43:21 -07:00
comptime assert(@TypeOf(&array[0]) == *align(4) u8);
comptime assert(@TypeOf(&array[1]) == *u8);
comptime assert(@TypeOf(&array[2]) == *align(2) u8);
comptime assert(@TypeOf(&array[3]) == *u8);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
// because align is too small but we still figure out to use 2
var bigger align(2) = [_]u64{ 1, 2, 3, 4 };
Sema: fix alignment of element ptr result type
2022-06-01 15:43:21 -07:00
comptime assert(@TypeOf(&bigger[0]) == *align(2) u64);
comptime assert(@TypeOf(&bigger[1]) == *align(2) u64);
comptime assert(@TypeOf(&bigger[2]) == *align(2) u64);
comptime assert(@TypeOf(&bigger[3]) == *align(2) u64);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
// because pointer is align 2 and u32 align % 2 == 0 we can assume align 2
var smaller align(2) = [_]u32{ 1, 2, 3, 4 };
var runtime_zero: usize = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &runtime_zero;
Sema: fix alignment of element ptr result type
2022-06-01 15:43:21 -07:00
comptime assert(@TypeOf(smaller[runtime_zero..]) == []align(2) u32);
comptime assert(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
try testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32);
try testIndex(smaller[runtime_zero..].ptr, 1, *align(2) u32);
try testIndex(smaller[runtime_zero..].ptr, 2, *align(2) u32);
try testIndex(smaller[runtime_zero..].ptr, 3, *align(2) u32);
// has to use ABI alignment because index known at runtime only
Sema: fix alignment of element ptr result type
2022-06-01 15:43:21 -07:00
try testIndex2(&array, 0, *u8);
try testIndex2(&array, 1, *u8);
try testIndex2(&array, 2, *u8);
try testIndex2(&array, 3, *u8);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) !void {
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(@TypeOf(&smaller[index]) == T);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(@TypeOf(&ptr[index]) == T);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
test "alignment of function with c calling convention" {
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const a = @alignOf(@TypeOf(nothing));
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
var runtime_nothing = &nothing;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &runtime_nothing;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const casted1: *align(a) const u8 = @ptrCast(runtime_nothing);
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
const casted2: *const fn () callconv(.c) void = @ptrCast(casted1);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
casted2();
}
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
fn nothing() callconv(.c) void {}
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
const DefaultAligned = struct {
nevermind: u32,
badguy: i128,
};
test "read 128-bit field from default aligned struct in stack memory" {
riscv: big rewrite to use latest liveness this one is even harder to document then the last large overhaul. TLDR; - split apart Emit.zig into an Emit.zig and a Lower.zig - created seperate files for the encoding, and now adding a new instruction is as simple as just adding it to a couple of switch statements and providing the encoding. - relocs are handled in a more sane maner, and we have a clear defining boundary between lea_symbol and load_symbol now. - a lot of different abstractions for things like the stack, memory, registers, and others. - we're using x86_64's FrameIndex now, which simplifies a lot of the tougher design process. - a lot more that I don't have the energy to document. at this point, just read the commit itself :p
2024-04-03 00:15:56 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
stage2 AArch64: Enable behavior testing
2022-02-14 22:33:01 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
var default_aligned = DefaultAligned{
.nevermind = 1,
.badguy = 12,
};
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &default_aligned;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
try expect(12 == default_aligned.badguy);
}
var default_aligned_global = DefaultAligned{
.nevermind = 1,
.badguy = 12,
};
test "read 128-bit field from default aligned struct in global memory" {
riscv: big rewrite to use latest liveness this one is even harder to document then the last large overhaul. TLDR; - split apart Emit.zig into an Emit.zig and a Lower.zig - created seperate files for the encoding, and now adding a new instruction is as simple as just adding it to a couple of switch statements and providing the encoding. - relocs are handled in a more sane maner, and we have a clear defining boundary between lea_symbol and load_symbol now. - a lot of different abstractions for things like the stack, memory, registers, and others. - we're using x86_64's FrameIndex now, which simplifies a lot of the tougher design process. - a lot more that I don't have the energy to document. at this point, just read the commit itself :p
2024-04-03 00:15:56 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
mark some more behavior tests as passing
2022-05-25 00:12:56 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
try expect(12 == default_aligned_global.badguy);
}
test "struct field explicit alignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
Sema: implement pointer to tuple to pointer to array coercion This involved an LLVM backend fix for the aggregate_init instruction.
2022-03-09 18:47:42 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
spirv: update tests
2024-01-13 18:44:44 +01:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
const S = struct {
const Node = struct {
next: *Node,
massive_byte: u8 align(64),
};
};
var node: S.Node = undefined;
node.massive_byte = 100;
try expect(node.massive_byte == 100);
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(@TypeOf(&node.massive_byte) == *align(64) u8);
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
try expect(@intFromPtr(&node.massive_byte) % 64 == 0);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
test "align(@alignOf(T)) T does not force resolution of T" {
remove references to stage1 in behavior tests Good riddance.
2022-12-06 19:06:48 -07:00
if (true) return error.SkipZigTest; // TODO
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
const S = struct {
const A = struct {
a: *align(@alignOf(A)) A,
};
fn doTheTest() void {
suspend {
resume @frame();
}
_ = bar(@Frame(doTheTest));
}
fn bar(comptime T: type) *align(@alignOf(T)) T {
ok = true;
return undefined;
}
var ok = false;
};
_ = async S.doTheTest();
try expect(S.ok);
}
test "align(N) on functions" {
Sema: fix compiler crash with comptime arithmetic involving `@ptrToInt`
2022-06-01 16:45:28 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
behaviortest: Skip 'align(N) on functions' on sparc64 for now
2022-06-06 06:30:08 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
behavior: enable passing CBE tests
2023-02-21 09:43:00 -05:00
disable behavior tests regressed by LLVM 17 See #16844 See #16845 See #16846 See #16848
2023-08-15 17:36:38 -07:00
if (builtin.zig_backend == .stage2_c) {
// https://github.com/ziglang/zig/issues/16845
return error.SkipZigTest;
}
behavior: enable passing CBE tests
2023-02-21 09:43:00 -05:00
if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) {
disable behavior tests regressed by LLVM 17 See #16844 See #16845 See #16846 See #16848
2023-08-15 17:36:38 -07:00
// This is not supported on MSVC.
behavior: enable passing CBE tests
2023-02-21 09:43:00 -05:00
return error.SkipZigTest;
}
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
x86_64: implement switch jump tables
2025-01-02 03:10:19 -05:00
// function alignment is a compile error on wasm
if (native_arch.isWasm()) return error.SkipZigTest;
if (native_arch.isThumb()) return error.SkipZigTest;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
try expect((@intFromPtr(&overaligned_fn) & (0x1000 - 1)) == 0);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
fn overaligned_fn() align(0x1000) i32 {
return 42;
}
stage2: Correctly align decls for comptime allocs This updates WipAnonDecl to require an alignment provided by the caller, which is needed for explicitly aligned comptime allocs.
2022-03-19 11:59:41 -07:00
test "comptime alloc alignment" {
compiler: implement analysis-local comptime-mutable memory This commit changes how we represent comptime-mutable memory (`comptime var`) in the compiler in order to implement the intended behavior that references to such memory can only exist at comptime. It does *not* clean up the representation of mutable values, improve the representation of comptime-known pointers, or fix the many bugs in the comptime pointer access code. These will be future enhancements. Comptime memory lives for the duration of a single Sema, and is not permitted to escape that one analysis, either by becoming runtime-known or by becoming comptime-known to other analyses. These restrictions mean that we can represent comptime allocations not via Decl, but with state local to Sema - specifically, the new `Sema.comptime_allocs` field. All comptime-mutable allocations, as well as any comptime-known const allocs containing references to such memory, live in here. This allows for relatively fast checking of whether a value references any comptime-mtuable memory, since we need only traverse values up to pointers: pointers to Decls can never reference comptime-mutable memory, and pointers into `Sema.comptime_allocs` always do. This change exposed some faulty pointer access logic in `Value.zig`. I've fixed the important cases, but there are some TODOs I've put in which are definitely possible to hit with sufficiently esoteric code. I plan to resolve these by auditing all direct accesses to pointers (most of them ought to use Sema to perform the pointer access!), but for now this is sufficient for all realistic code and to get tests passing. This change eliminates `Zcu.tmp_hack_arena`, instead using the Sema arena for comptime memory mutations, which is possible since comptime memory is now local to the current Sema. This change should allow `Decl` to store only an `InternPool.Index` rather than a full-blown `ty: Type, val: Value`. This commit does not perform this refactor.
2024-03-22 23:39:44 +00:00
// TODO: it's impossible to test this in Zig today, since comptime vars do not have runtime addresses.
if (true) return error.SkipZigTest;
stage2: Correctly align decls for comptime allocs This updates WipAnonDecl to require an alignment provided by the caller, which is needed for explicitly aligned comptime allocs.
2022-03-19 11:59:41 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
spirv: update tests
2024-01-13 18:44:44 +01:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
stage2: Correctly align decls for comptime allocs This updates WipAnonDecl to require an alignment provided by the caller, which is needed for explicitly aligned comptime allocs.
2022-03-19 11:59:41 -07:00
comptime var bytes1 = [_]u8{0};
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &bytes1;
stage2: Correctly align decls for comptime allocs This updates WipAnonDecl to require an alignment provided by the caller, which is needed for explicitly aligned comptime allocs.
2022-03-19 11:59:41 -07:00
comptime var bytes2 align(256) = [_]u8{0};
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
const bytes2_addr = @intFromPtr(&bytes2);
Sema: fix compiler crash with comptime arithmetic involving `@ptrToInt`
2022-06-01 16:45:28 -07:00
try expect(bytes2_addr & 0xff == 0);
stage2: Correctly align decls for comptime allocs This updates WipAnonDecl to require an alignment provided by the caller, which is needed for explicitly aligned comptime allocs.
2022-03-19 11:59:41 -07:00
}
Sema: do not use coerceCompatiblePtr for alignCast Closes #12902
2022-09-19 12:38:31 +03:00
test "@alignCast null" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
Sema: do not use coerceCompatiblePtr for alignCast Closes #12902
2022-09-19 12:38:31 +03:00
var ptr: ?*anyopaque = null;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &ptr;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const aligned: ?*anyopaque = @alignCast(ptr);
Sema: do not use coerceCompatiblePtr for alignCast Closes #12902
2022-09-19 12:38:31 +03:00
try expect(aligned == null);
}
Sema: pass calculated offset to `elemPtrType` in `elemPtrSlice`
2022-09-19 17:06:57 +03:00
test "alignment of slice element" {
const a: []align(1024) const u8 = undefined;
try expect(@TypeOf(&a[0]) == *align(1024) const u8);
}
add behavior test for sub-aligned field access The workaround in std.zig.Server remains because the C backend is not passing the new test. see #14904
2023-07-31 18:25:27 -07:00
test "sub-aligned pointer field access" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
add behavior test for sub-aligned field access The workaround in std.zig.Server remains because the C backend is not passing the new test. see #14904
2023-07-31 18:25:27 -07:00
// Originally reported at https://github.com/ziglang/zig/issues/14904
const Header = extern struct {
tag: u32,
bytes_len: u32,
};
var buf: [9]u8 align(4) = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const ptr: *align(1) Header = @ptrCast(buf[1..][0..8]);
const x = ptr.bytes_len;
switch (builtin.cpu.arch.endian()) {
std.builtin.Endian: make the tags lower case Let's take this breaking change opportunity to fix the style of this enum.
2023-10-31 13:02:38 -07:00
.big => try expect(x == 0x06070809),
.little => try expect(x == 0x09080706),
add behavior test for sub-aligned field access The workaround in std.zig.Server remains because the C backend is not passing the new test. see #14904
2023-07-31 18:25:27 -07:00
}
}
InternPool,Sema,type,llvm: alignment fixes This changeset fixes the handling of alignment in several places. The new rules are: * `@alignOf(T)` where `T` is a runtime zero-bit type is at least 1, maybe greater. * Zero-bit fields in `extern` structs *do* force alignment, potentially offsetting following fields. * Zero-bit fields *do* have addresses within structs which can be observed and are consistent with `@offsetOf`. These are not necessarily all implemented correctly yet (see disabled test), but this commit fixes all regressions compared to master, and makes one new test pass.
2023-09-21 02:00:52 +01:00
test "alignment of zero-bit types is respected" {
if (true) return error.SkipZigTest; // TODO
const S = struct { arr: [0]usize = .{} };
comptime assert(@alignOf(void) == 1);
comptime assert(@alignOf(u0) == 1);
comptime assert(@alignOf([0]usize) == @alignOf(usize));
comptime assert(@alignOf(S) == @alignOf(usize));
var s: S = .{};
var v32: void align(32) = {};
var x32: u0 align(32) = 0;
var s32: S align(32) = .{};
var zero: usize = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &zero;
InternPool,Sema,type,llvm: alignment fixes This changeset fixes the handling of alignment in several places. The new rules are: * `@alignOf(T)` where `T` is a runtime zero-bit type is at least 1, maybe greater. * Zero-bit fields in `extern` structs *do* force alignment, potentially offsetting following fields. * Zero-bit fields *do* have addresses within structs which can be observed and are consistent with `@offsetOf`. These are not necessarily all implemented correctly yet (see disabled test), but this commit fixes all regressions compared to master, and makes one new test pass.
2023-09-21 02:00:52 +01:00
try expect(@intFromPtr(&s) % @alignOf(usize) == 0);
try expect(@intFromPtr(&s.arr) % @alignOf(usize) == 0);
try expect(@intFromPtr(s.arr[zero..zero].ptr) % @alignOf(usize) == 0);
try expect(@intFromPtr(&v32) % 32 == 0);
try expect(@intFromPtr(&x32) % 32 == 0);
try expect(@intFromPtr(&s32) % 32 == 0);
try expect(@intFromPtr(&s32.arr) % 32 == 0);
try expect(@intFromPtr(s32.arr[zero..zero].ptr) % 32 == 0);
}
test "zero-bit fields in extern struct pad fields appropriately" {
riscv: big rewrite to use latest liveness this one is even harder to document then the last large overhaul. TLDR; - split apart Emit.zig into an Emit.zig and a Lower.zig - created seperate files for the encoding, and now adding a new instruction is as simple as just adding it to a couple of switch statements and providing the encoding. - relocs are handled in a more sane maner, and we have a clear defining boundary between lea_symbol and load_symbol now. - a lot of different abstractions for things like the stack, memory, registers, and others. - we're using x86_64's FrameIndex now, which simplifies a lot of the tougher design process. - a lot more that I don't have the energy to document. at this point, just read the commit itself :p
2024-04-03 00:15:56 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
InternPool,Sema,type,llvm: alignment fixes This changeset fixes the handling of alignment in several places. The new rules are: * `@alignOf(T)` where `T` is a runtime zero-bit type is at least 1, maybe greater. * Zero-bit fields in `extern` structs *do* force alignment, potentially offsetting following fields. * Zero-bit fields *do* have addresses within structs which can be observed and are consistent with `@offsetOf`. These are not necessarily all implemented correctly yet (see disabled test), but this commit fixes all regressions compared to master, and makes one new test pass.
2023-09-21 02:00:52 +01:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const S = extern struct {
x: u8,
a: [0]u16 = .{},
y: u8,
};
// `a` should give `S` alignment 2, and pad the `arr` field.
comptime assert(@alignOf(S) == 2);
comptime assert(@sizeOf(S) == 4);
comptime assert(@offsetOf(S, "x") == 0);
comptime assert(@offsetOf(S, "a") == 2);
comptime assert(@offsetOf(S, "y") == 2);
var s: S = .{ .x = 100, .y = 200 };
try expect(@intFromPtr(&s) % 2 == 0);
try expect(@intFromPtr(&s.y) - @intFromPtr(&s.x) == 2);
try expect(@intFromPtr(&s.y) == @intFromPtr(&s.a));
Update uses of `@fieldParentPtr` to use RLS
2024-03-19 12:46:38 +01:00
try expect(@as(*S, @fieldParentPtr("a", &s.a)) == &s);
InternPool,Sema,type,llvm: alignment fixes This changeset fixes the handling of alignment in several places. The new rules are: * `@alignOf(T)` where `T` is a runtime zero-bit type is at least 1, maybe greater. * Zero-bit fields in `extern` structs *do* force alignment, potentially offsetting following fields. * Zero-bit fields *do* have addresses within structs which can be observed and are consistent with `@offsetOf`. These are not necessarily all implemented correctly yet (see disabled test), but this commit fixes all regressions compared to master, and makes one new test pass.
2023-09-21 02:00:52 +01:00
}
Sema: Fix fnptr alignment safety checks to account for potential ISA tag. As seen on e.g. Arm/Thumb and MIPS (MIPS16/microMIPS). Fixes #22888.
2025-02-15 02:44:58 +01:00
test "function pointer @intFromPtr/@ptrFromInt roundtrip" {
test: skip failing tests with spirv-vulkan
2025-02-19 00:07:07 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
Sema: Fix fnptr alignment safety checks to account for potential ISA tag. As seen on e.g. Arm/Thumb and MIPS (MIPS16/microMIPS). Fixes #22888.
2025-02-15 02:44:58 +01:00
// This only succeeds on Thumb if we handle the Thumb bit correctly; if not, the `@ptrFromInt`
// will incorrectly trip an alignment safety check.
const nothing_ptr: *const fn () callconv(.c) void = &nothing;
const nothing_int: usize = @intFromPtr(nothing_ptr);
const nothing_ptr2: *const fn () callconv(.c) void = @ptrFromInt(nothing_int);
try std.testing.expectEqual(nothing_ptr, nothing_ptr2);
}
Sema: Fix some ptr alignment checks to handle a potential ISA tag bit. Closes #23570.
2025-04-14 18:40:47 +02:00
test "function pointer align mask" {
if (!(builtin.cpu.arch.isArm() or builtin.cpu.arch.isMIPS())) return error.SkipZigTest;
const a: *const fn () callconv(.c) void = @ptrFromInt(0x20202021);
_ = &a;
const b: *align(16) const fn () callconv(.c) void = @alignCast(a);
_ = &b;
}
Reference in New Issue Copy Permalink