test: migrate llvm incremental tests

test/cases.zig

@@ -9,8 +9,6 @@ const TestContext = @import("../src/test.zig").TestContext;
 pub fn addCases(ctx: *TestContext) !void {
     try @import("compile_errors.zig").addCases(ctx);
     try @import("stage2/cbe.zig").addCases(ctx);
-    try @import("stage2/llvm.zig").addCases(ctx);
-    try @import("stage2/x86_64.zig").addCases(ctx);
     // https://github.com/ziglang/zig/issues/10968
     //try @import("stage2/nvptx.zig").addCases(ctx);
 }

test/incremental/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig

@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) ?[1]i32) *addrspace(.gs) i32 {
+    return &a.*.?[0];
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=llvm
+// target=x86_64-linux
+//

test/incremental/llvm/address_spaces_pointer_access_chaining_array_pointer.zig

@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) [1]i32) *addrspace(.gs) i32 {
+    return &a[0];
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/address_spaces_pointer_access_chaining_complex.zig

@@ -0,0 +1,13 @@
+const A = struct { a: ?[1]i32 };
+fn entry(a: *addrspace(.gs) [1]A) *addrspace(.gs) i32 {
+    return &a[0].a.?[0];
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=llvm
+// target=x86_64-linux
+//

test/incremental/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig

@@ -0,0 +1,13 @@
+const A = struct { a: i32 };
+fn entry(a: *addrspace(.gs) A) *addrspace(.gs) i32 {
+    return &a.a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/any_typed_null_to_any_typed_optional.zig

@@ -0,0 +1,11 @@
+pub fn main() void {
+    var a: ?*anyopaque = undefined;
+    a = @as(?usize, null);
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//
+// :3:21: error: expected *anyopaque, found ?usize

test/incremental/llvm/blocks.zig

@@ -0,0 +1,22 @@
+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 fn main() void {
+    assert(foo(false) == 20);
+    assert(foo(true) == 30);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig

@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.fs) *addrspace(.gs) *i32) *i32 {
+    return a.*.*;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/f_segment_address_space_reading_and_writing.zig

@@ -0,0 +1,48 @@
+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 fn main() void {
+    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);
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux
+//

test/incremental/llvm/for_loop.zig

@@ -0,0 +1,16 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    var x: u32 = 0;
+    for ("hello") |_| {
+        x += 1;
+    }
+    assert("hello".len == x);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/hello_world.zig

@@ -0,0 +1,12 @@
+extern fn puts(s: [*:0]const u8) c_int;
+
+pub fn main() void {
+    _ = puts("hello world!");
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux
+//
+// hello world!
+//

test/incremental/llvm/invalid_address_space_coercion.zig

@@ -0,0 +1,13 @@
+fn entry(a: *addrspace(.gs) i32) *i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//
+// :2:12: error: expected *i32, found *addrspace(.gs) i32

test/incremental/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig

@@ -0,0 +1,13 @@
+fn entry(a: *addrspace(.gs) i32) *i32 {
+    return &a.*;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//
+// :2:12: error: expected *i32, found *addrspace(.gs) i32

test/incremental/llvm/nested_blocks.zig

@@ -0,0 +1,24 @@
+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 fn main() void {
+    assert(foo(false) == 10);
+    assert(foo(true) == 20);
+}
+
+// run
+// backend=stage2, llvm
+// target=x86_64-linux
+//

test/incremental/llvm/optionals.zig

@@ -0,0 +1,45 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    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);
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux
+//

test/incremental/llvm/pointer_keeps_address_space.zig

@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig

@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
+    return &a.*;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig

@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.generic) i32) *i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/pointer_with_different_address_spaces.zig

@@ -0,0 +1,13 @@
+fn entry(a: *addrspace(.gs) i32) *addrspace(.fs) i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//
+// :2:12: error: expected *addrspace(.fs) i32, found *addrspace(.gs) i32

test/incremental/llvm/pointers_with_different_address_spaces.zig

@@ -0,0 +1,13 @@
+fn entry(a: ?*addrspace(.gs) i32) *i32 {
+    return a.?;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux
+//
+// :2:13: error: expected *i32, found *addrspace(.gs) i32

test/incremental/llvm/rem.zig

@@ -0,0 +1,15 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+fn rem(lhs: i32, rhs: i32, expected: i32) bool {
+    return @rem(lhs, rhs) == expected;
+}
+pub fn main() void {
+    assert(rem(-5, 3, -2));
+    assert(rem(5, 3, 2));
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/shift_right_plus_left.0.zig

@@ -0,0 +1,12 @@
+pub fn main() void {
+    var i: u32 = 16;
+    assert(i >> 1, 8);
+}
+fn assert(a: u32, b: u32) void {
+    if (a != b) unreachable;
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux
+//

test/incremental/llvm/shift_right_plus_left.1.zig

@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i: u32 = 16;
+    assert(i << 1, 32);
+}
+fn assert(a: u32, b: u32) void {
+    if (a != b) unreachable;
+}
+
+// run
+//

test/incremental/llvm/simple_addition_and_subtraction.zig

@@ -0,0 +1,20 @@
+fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+pub fn main() void {
+    var a: i32 = -5;
+    const x = add(a, 7);
+    var y = add(2, 0);
+    y -= x;
+    assert(y == 0);
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/simple_if_statement.zig

@@ -0,0 +1,16 @@
+fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    assert(add(1, 2) == 3);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/incremental/llvm/while_loops.zig

@@ -0,0 +1,18 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    var sum: u32 = 0;
+    var i: u32 = 0;
+    while (i < 5) : (i += 1) {
+        sum += i;
+    }
+    assert(sum == 10);
+    assert(i == 5);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux
+//

test/stage2/llvm.zig

@@ -1,438 +0,0 @@
-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;
-            \\}
-        , "");
-    }
-
-    {
-        // This worked in stage1 and we expressly do not want this to work in stage2
-        var case = ctx.exeUsingLlvmBackend("any typed null to any typed optional", linux_x64);
-        case.addError(
-            \\pub export fn main() void {
-            \\    var a: ?*anyopaque = undefined;
-            \\    a = @as(?usize, null);
-            \\}
-        , &[_][]const u8{
-            ":3:21: error: expected *anyopaque, found ?usize",
-        });
-    }
-}

test/stage2/x86_64.zig

@@ -1,59 +0,0 @@
-const std = @import("std");
-const CrossTarget = std.zig.CrossTarget;
-const TestContext = @import("../../src/test.zig").TestContext;
-
-const linux_x64 = std.zig.CrossTarget{
-    .cpu_arch = .x86_64,
-    .os_tag = .linux,
-};
-const macos_x64 = CrossTarget{
-    .cpu_arch = .x86_64,
-    .os_tag = .macos,
-};
-const all_targets: []const CrossTarget = &[_]CrossTarget{
-    linux_x64,
-    macos_x64,
-};
-
-pub fn addCases(ctx: *TestContext) !void {
-    for (all_targets) |target| {
-        // TODO port this to the new test harness
-        var case = ctx.exe("basic import", target);
-        case.addCompareOutput(
-            \\pub fn main() void {
-            \\    @import("print.zig").print();
-            \\}
-        ,
-            "Hello, World!\n",
-        );
-        switch (target.getOsTag()) {
-            .linux => try case.files.append(.{
-                .src = 
-                \\pub fn print() void {
-                \\    asm volatile ("syscall"
-                \\        :
-                \\        : [number] "{rax}" (@as(usize, 1)),
-                \\          [arg1] "{rdi}" (@as(usize, 1)),
-                \\          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
-                \\          [arg3] "{rdx}" (@as(usize, 14))
-                \\        : "rcx", "r11", "memory"
-                \\    );
-                \\    return;
-                \\}
-                ,
-                .path = "print.zig",
-            }),
-            .macos => try case.files.append(.{
-                .src = 
-                \\extern "c" fn write(usize, usize, usize) usize;
-                \\
-                \\pub fn print() void {
-                \\    _ = write(1, @ptrToInt("Hello, World!\n"), 14);
-                \\}
-                ,
-                .path = "print.zig",
-            }),
-            else => unreachable,
-        }
-    }
-}