426 lines
13 KiB
Zig
426 lines
13 KiB
Zig
const std = @import("std");
|
|
const TestContext = @import("../../src/test.zig").TestContext;
|
|
const build_options = @import("build_options");
|
|
|
|
// These tests should work with all platforms, but we're using linux_x64 for
|
|
// now for consistency. Will be expanded eventually.
|
|
const linux_x64 = std.zig.CrossTarget{
|
|
.cpu_arch = .x86_64,
|
|
.os_tag = .linux,
|
|
};
|
|
|
|
pub fn addCases(ctx: *TestContext) !void {
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("simple addition and subtraction", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn add(a: i32, b: i32) i32 {
|
|
\\ return a + b;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var a: i32 = -5;
|
|
\\ const x = add(a, 7);
|
|
\\ var y = add(2, 0);
|
|
\\ y -= x;
|
|
\\ return y;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("shift right + left", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\pub export fn main() c_int {
|
|
\\ var i: u32 = 16;
|
|
\\ assert(i >> 1, 8);
|
|
\\ return 0;
|
|
\\}
|
|
\\fn assert(a: u32, b: u32) void {
|
|
\\ if (a != b) unreachable;
|
|
\\}
|
|
, "");
|
|
case.addCompareOutput(
|
|
\\pub export fn main() c_int {
|
|
\\ var i: u32 = 16;
|
|
\\ assert(i << 1, 32);
|
|
\\ return 0;
|
|
\\}
|
|
\\fn assert(a: u32, b: u32) void {
|
|
\\ if (a != b) unreachable;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("llvm hello world", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\extern fn puts(s: [*:0]const u8) c_int;
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ _ = puts("hello world!");
|
|
\\ return 0;
|
|
\\}
|
|
, "hello world!" ++ std.cstr.line_sep);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("simple if statement", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn add(a: i32, b: i32) i32 {
|
|
\\ return a + b;
|
|
\\}
|
|
\\
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ assert(add(1,2) == 3);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("blocks", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\fn foo(ok: bool) i32 {
|
|
\\ const val: i32 = blk: {
|
|
\\ var x: i32 = 1;
|
|
\\ if (!ok) break :blk x + 9;
|
|
\\ break :blk x + 19;
|
|
\\ };
|
|
\\ return val + 10;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ assert(foo(false) == 20);
|
|
\\ assert(foo(true) == 30);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("nested blocks", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\fn foo(ok: bool) i32 {
|
|
\\ var val: i32 = blk: {
|
|
\\ const val2: i32 = another: {
|
|
\\ if (!ok) break :blk 10;
|
|
\\ break :another 10;
|
|
\\ };
|
|
\\ break :blk val2 + 10;
|
|
\\ };
|
|
\\ return val;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ assert(foo(false) == 10);
|
|
\\ assert(foo(true) == 20);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("while loops", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var sum: u32 = 0;
|
|
\\ var i: u32 = 0;
|
|
\\ while (i < 5) : (i += 1) {
|
|
\\ sum += i;
|
|
\\ }
|
|
\\ assert(sum == 10);
|
|
\\ assert(i == 5);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("optionals", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var opt_val: ?i32 = 10;
|
|
\\ var null_val: ?i32 = null;
|
|
\\
|
|
\\ var val1: i32 = opt_val.?;
|
|
\\ const val1_1: i32 = opt_val.?;
|
|
\\ var ptr_val1 = &(opt_val.?);
|
|
\\ const ptr_val1_1 = &(opt_val.?);
|
|
\\
|
|
\\ var val2: i32 = null_val orelse 20;
|
|
\\ const val2_2: i32 = null_val orelse 20;
|
|
\\
|
|
\\ var value: i32 = 20;
|
|
\\ var ptr_val2 = &(null_val orelse value);
|
|
\\
|
|
\\ const val3 = opt_val orelse 30;
|
|
\\ var val3_var = opt_val orelse 30;
|
|
\\
|
|
\\ assert(val1 == 10);
|
|
\\ assert(val1_1 == 10);
|
|
\\ assert(ptr_val1.* == 10);
|
|
\\ assert(ptr_val1_1.* == 10);
|
|
\\
|
|
\\ assert(val2 == 20);
|
|
\\ assert(val2_2 == 20);
|
|
\\ assert(ptr_val2.* == 20);
|
|
\\
|
|
\\ assert(val3 == 10);
|
|
\\ assert(val3_var == 10);
|
|
\\
|
|
\\ (null_val orelse val2) = 1234;
|
|
\\ assert(val2 == 1234);
|
|
\\
|
|
\\ (opt_val orelse val2) = 5678;
|
|
\\ assert(opt_val.? == 5678);
|
|
\\
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("for loop", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var x: u32 = 0;
|
|
\\ for ("hello") |_| {
|
|
\\ x += 1;
|
|
\\ }
|
|
\\ assert("hello".len == x);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("@rem", linux_x64);
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\fn rem(lhs: i32, rhs: i32, expected: i32) bool {
|
|
\\ return @rem(lhs, rhs) == expected;
|
|
\\}
|
|
\\pub export fn main() c_int {
|
|
\\ assert(rem(-5, 3, -2));
|
|
\\ assert(rem(5, 3, 2));
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("invalid address space coercion", linux_x64);
|
|
case.addError(
|
|
\\fn entry(a: *addrspace(.gs) i32) *i32 {
|
|
\\ return a;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
, &[_][]const u8{
|
|
":2:12: error: expected *i32, found *addrspace(.gs) i32",
|
|
});
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("pointer keeps address space", linux_x64);
|
|
case.compiles(
|
|
\\fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
|
|
\\ return a;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("pointer to explicit generic address space coerces to implicit pointer", linux_x64);
|
|
case.compiles(
|
|
\\fn entry(a: *addrspace(.generic) i32) *i32 {
|
|
\\ return a;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("pointers with different address spaces", linux_x64);
|
|
case.addError(
|
|
\\fn entry(a: *addrspace(.gs) i32) *addrspace(.fs) i32 {
|
|
\\ return a;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
, &[_][]const u8{
|
|
":2:12: error: expected *addrspace(.fs) i32, found *addrspace(.gs) i32",
|
|
});
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("pointers with different address spaces", linux_x64);
|
|
case.addError(
|
|
\\fn entry(a: ?*addrspace(.gs) i32) *i32 {
|
|
\\ return a.?;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
, &[_][]const u8{
|
|
":2:13: error: expected *i32, found *addrspace(.gs) i32",
|
|
});
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("invalid pointer keeps address space when taking address of dereference", linux_x64);
|
|
case.addError(
|
|
\\fn entry(a: *addrspace(.gs) i32) *i32 {
|
|
\\ return &a.*;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
, &[_][]const u8{
|
|
":2:12: error: expected *i32, found *addrspace(.gs) i32",
|
|
});
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("pointer keeps address space when taking address of dereference", linux_x64);
|
|
case.compiles(
|
|
\\fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
|
|
\\ return &a.*;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("address spaces pointer access chaining: array pointer", linux_x64);
|
|
case.compiles(
|
|
\\fn entry(a: *addrspace(.gs) [1]i32) *addrspace(.gs) i32 {
|
|
\\ return &a[0];
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("address spaces pointer access chaining: pointer to optional array", linux_x64);
|
|
case.compiles(
|
|
\\fn entry(a: *addrspace(.gs) ?[1]i32) *addrspace(.gs) i32 {
|
|
\\ return &a.*.?[0];
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("address spaces pointer access chaining: struct pointer", linux_x64);
|
|
case.compiles(
|
|
\\const A = struct{ a: i32 };
|
|
\\fn entry(a: *addrspace(.gs) A) *addrspace(.gs) i32 {
|
|
\\ return &a.a;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("address spaces pointer access chaining: complex", linux_x64);
|
|
case.compiles(
|
|
\\const A = struct{ a: ?[1]i32 };
|
|
\\fn entry(a: *addrspace(.gs) [1]A) *addrspace(.gs) i32 {
|
|
\\ return &a[0].a.?[0];
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("dereferencing through multiple pointers with address spaces", linux_x64);
|
|
case.compiles(
|
|
\\fn entry(a: *addrspace(.fs) *addrspace(.gs) *i32) *i32 {
|
|
\\ return a.*.*;
|
|
\\}
|
|
\\pub export fn main() void { _ = entry; }
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("f segment address space reading and writing", linux_x64);
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\fn setFs(value: c_ulong) void {
|
|
\\ asm volatile (
|
|
\\ \\syscall
|
|
\\ :
|
|
\\ : [number] "{rax}" (158),
|
|
\\ [code] "{rdi}" (0x1002),
|
|
\\ [val] "{rsi}" (value),
|
|
\\ : "rcx", "r11", "memory"
|
|
\\ );
|
|
\\}
|
|
\\
|
|
\\fn getFs() c_ulong {
|
|
\\ var result: c_ulong = undefined;
|
|
\\ asm volatile (
|
|
\\ \\syscall
|
|
\\ :
|
|
\\ : [number] "{rax}" (158),
|
|
\\ [code] "{rdi}" (0x1003),
|
|
\\ [ptr] "{rsi}" (@ptrToInt(&result)),
|
|
\\ : "rcx", "r11", "memory"
|
|
\\ );
|
|
\\ return result;
|
|
\\}
|
|
\\
|
|
\\var test_value: u64 = 12345;
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ const orig_fs = getFs();
|
|
\\
|
|
\\ setFs(@ptrToInt(&test_value));
|
|
\\ assert(getFs() == @ptrToInt(&test_value));
|
|
\\
|
|
\\ var test_ptr = @intToPtr(*allowzero addrspace(.fs) u64, 0);
|
|
\\ assert(test_ptr.* == 12345);
|
|
\\ test_ptr.* = 98765;
|
|
\\ assert(test_value == 98765);
|
|
\\
|
|
\\ setFs(orig_fs);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
}
|