Commit 243afdcdf57d74a184784551aebe58062e5afc03 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-03-31 15:06:44-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-03-31 15:10:31-07:00
log	243afdcdf57d74a184784551aebe58062e5afc03
tree	7e637a4c50b8abf6beb1354c346fc08055c5f0e7
parent	df1ba38a88a255286af4d939d427f8a4ee667485

test harness improvements

 * `-Dskip-compile-errors` is removed; `-Dskip-stage1` is added.
 * Use `std.testing.allocator` instead of a new instance of GPA.
   - Fix the memory leaks this revealed.
 * Show the file name when it is not parsed correctly such as when the
   manifest is missing.
   - Better error messages when test files are not parsed correctly.
 * Ignore unknown files such as swap files.
 * Move logic from declarative file to the test harness implementation.
 * Move stage1 tests to stage2 tests where appropriate.

11 files changed, 184 insertions(+), 152 deletions(-)

build.zig
src
- test.zig
test
- compile_errors.zig
- compile_errors
  - stage1
    exe
    std.fmt_error_for_unused_arguments.zig
    obj
    constant_inside_comptime_function_has_compile_error.zig
    std.fmt_error_for_unused_arguments.zig
    unused_variable_error_on_errdefer.zig
    test
    duplicate-unused_labels.zig
    unused_variable_error_on_errdefer.zig
  - stage2
    constant_inside_comptime_function_has_compile_error.zig
    duplicate-unused_labels.zig

build.zig+2-2

src/test.zig+114-45

 @@ -12,7 +12,7 @@ const enable_wasmtime: bool = build_options.enable_wasmtime;
 const enable_darling: bool = build_options.enable_darling;
 const enable_rosetta: bool = build_options.enable_rosetta;
 const glibc_runtimes_dir: ?[]const u8 = build_options.glibc_runtimes_dir;
-const skip_compile_errors = build_options.skip_compile_errors;
+const skip_stage1 = build_options.skip_stage1;
 const ThreadPool = @import("ThreadPool.zig");
 const CrossTarget = std.zig.CrossTarget;
 const print = std.debug.print;
 @@ -20,7 +20,6 @@ const assert = std.debug.assert;
 const zig_h = link.File.C.zig_h;
-var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
 const hr = "=" ** 80;
 test {
 @@ -28,9 +27,50 @@ test {
         @import("stage1.zig").os_init();
     }
-    var ctx = TestContext.init();
+    var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena_allocator.deinit();
+    const arena = arena_allocator.allocator();
+    var ctx = TestContext.init(std.testing.allocator, arena);
     defer ctx.deinit();
+    const compile_errors_dir_path = try std.fs.path.join(arena, &.{
+        std.fs.path.dirname(@src().file).?, "..", "test", "compile_errors",
+    });
+    var compile_errors_dir = try std.fs.cwd().openDir(compile_errors_dir_path, .{});
+    defer compile_errors_dir.close();
+    {
+        var stage2_dir = try compile_errors_dir.openDir("stage2", .{ .iterate = true });
+        defer stage2_dir.close();
+        // TODO make this incremental once the bug is solved that it triggers
+        ctx.addErrorCasesFromDir("stage2", stage2_dir, .stage2, .Obj, false, .independent);
+    }
+    if (!skip_stage1) {
+        var stage1_dir = try compile_errors_dir.openDir("stage1", .{});
+        defer stage1_dir.close();
+        const Config = struct {
+            name: []const u8,
+            is_test: bool,
+            output_mode: std.builtin.OutputMode,
+        };
+        for ([_]Config{
+            .{ .name = "obj", .is_test = false, .output_mode = .Obj },
+            .{ .name = "exe", .is_test = false, .output_mode = .Exe },
+            .{ .name = "test", .is_test = true, .output_mode = .Exe },
+        }) |config| {
+            var dir = try stage1_dir.openDir(config.name, .{ .iterate = true });
+            defer dir.close();
+            ctx.addErrorCasesFromDir("stage1", dir, .stage1, config.output_mode, config.is_test, .independent);
+        }
+    }
     try @import("test_cases").addCases(&ctx);
     try ctx.run();
 @@ -114,6 +154,7 @@ const ErrorMsg = union(enum) {
 };
 pub const TestContext = struct {
+    arena: Allocator,
     cases: std.ArrayList(Case),
     pub const Update = struct {
 @@ -316,7 +357,7 @@ pub const TestContext = struct {
             .target = target,
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Exe,
-            .files = std.ArrayList(File).init(ctx.cases.allocator),
+            .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
     }
 @@ -327,7 +368,7 @@ pub const TestContext = struct {
     }
     pub fn exeFromCompiledC(ctx: *TestContext, name: []const u8, target: CrossTarget) *Case {
-        const prefixed_name = std.fmt.allocPrint(ctx.cases.allocator, "CBE: {s}", .{name}) catch
+        const prefixed_name = std.fmt.allocPrint(ctx.arena, "CBE: {s}", .{name}) catch
             @panic("out of memory");
         ctx.cases.append(Case{
             .name = prefixed_name,
 @@ -335,7 +376,7 @@ pub const TestContext = struct {
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Exe,
             .object_format = .c,
-            .files = std.ArrayList(File).init(ctx.cases.allocator),
+            .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
     }
 @@ -348,7 +389,7 @@ pub const TestContext = struct {
             .target = target,
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Exe,
-            .files = std.ArrayList(File).init(ctx.cases.allocator),
+            .files = std.ArrayList(File).init(ctx.arena),
             .backend = .llvm,
             .link_libc = true,
         }) catch @panic("out of memory");
 @@ -365,7 +406,7 @@ pub const TestContext = struct {
             .target = target,
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Obj,
-            .files = std.ArrayList(File).init(ctx.cases.allocator),
+            .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
     }
 @@ -381,7 +422,7 @@ pub const TestContext = struct {
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Exe,
             .is_test = true,
-            .files = std.ArrayList(File).init(ctx.cases.allocator),
+            .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
     }
 @@ -404,7 +445,7 @@ pub const TestContext = struct {
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Obj,
             .object_format = .c,
-            .files = std.ArrayList(File).init(ctx.cases.allocator),
+            .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
     }
 @@ -423,7 +464,7 @@ pub const TestContext = struct {
         src: [:0]const u8,
         expected_errors: []const []const u8,
     ) void {
-        if (skip_compile_errors) return;
+        if (skip_stage1) return;
         const case = ctx.addObj(name, .{});
         case.backend = .stage1;
 @@ -436,7 +477,7 @@ pub const TestContext = struct {
         src: [:0]const u8,
         expected_errors: []const []const u8,
     ) void {
-        if (skip_compile_errors) return;
+        if (skip_stage1) return;
         const case = ctx.addTest(name, .{});
         case.backend = .stage1;
 @@ -449,7 +490,7 @@ pub const TestContext = struct {
         src: [:0]const u8,
         expected_errors: []const []const u8,
     ) void {
-        if (skip_compile_errors) return;
+        if (skip_stage1) return;
         const case = ctx.addExe(name, .{});
         case.backend = .stage1;
 @@ -612,6 +653,8 @@ pub const TestContext = struct {
         case.compiles(fixed_src);
     }
+    const Strategy = enum { incremental, independent };
     /// Adds a compile-error test for each file in the provided directory, using the
     /// selected backend and output mode. If `one_test_case_per_file` is true, a new
     /// test case is created for each file. Otherwise, a single test case is used for
 @@ -628,33 +671,58 @@ pub const TestContext = struct {
         backend: Backend,
         output_mode: std.builtin.OutputMode,
         is_test: bool,
-        one_test_case_per_file: bool,
+        strategy: Strategy,
-    ) !void {
+    ) void {
-        if (skip_compile_errors) return;
+        var current_file: []const u8 = "none";
+        addErrorCasesFromDirInner(ctx, name, dir, backend, output_mode, is_test, strategy, &current_file) catch |err| {
+            std.debug.panic("test harness failed to process file '{s}': {s}\n", .{
+                current_file, @errorName(err),
+            });
+        };
+    }
-        const gpa = general_purpose_allocator.allocator();
+    fn addErrorCasesFromDirInner(
+        ctx: *TestContext,
+        name: []const u8,
+        dir: std.fs.Dir,
+        backend: Backend,
+        output_mode: std.builtin.OutputMode,
+        is_test: bool,
+        strategy: Strategy,
+        /// This is kept up to date with the currently being processed file so
+        /// that if any errors occur the caller knows it happened during this file.
+        current_file: *[]const u8,
+    ) !void {
         var opt_case: ?*Case = null;
         var it = dir.iterate();
         while (try it.next()) |entry| {
             if (entry.kind != .File) continue;
-            var contents = try dir.readFileAlloc(gpa, entry.name, std.math.maxInt(u32));
+            // Ignore stuff such as .swp files
-            defer gpa.free(contents);
+            switch (Compilation.classifyFileExt(entry.name)) {
+                .unknown => continue,
+                else => {},
+            }
+            current_file.* = try ctx.arena.dupe(u8, entry.name);
+            const max_file_size = 10 * 1024 * 1024;
+            const src = try dir.readFileAllocOptions(ctx.arena, entry.name, max_file_size, null, 1, 0);
             // The manifest is the last contiguous block of comments in the file
             // We scan for the beginning by searching backward for the first non-empty line that does not start with "//"
             var manifest_start: ?usize = null;
-            var manifest_end: usize = contents.len;
+            var manifest_end: usize = src.len;
-            if (contents.len > 0) {
+            if (src.len > 0) {
-                var cursor: usize = contents.len - 1;
+                var cursor: usize = src.len - 1;
                 while (true) {
                     // Move to beginning of line
-                    while (cursor > 0 and contents[cursor - 1] != '\n') cursor -= 1;
+                    while (cursor > 0 and src[cursor - 1] != '\n') cursor -= 1;
                     // Check if line is non-empty and does not start with "//"
-                    if (cursor + 1 < contents.len and contents[cursor + 1] != '\n' and contents[cursor + 1] != '\r') {
+                    if (cursor + 1 < src.len and src[cursor + 1] != '\n' and src[cursor + 1] != '\r') {
-                        if (std.mem.startsWith(u8, contents[cursor..], "//")) {
+                        if (std.mem.startsWith(u8, src[cursor..], "//")) {
                             manifest_start = cursor;
                         } else {
                             break;
 @@ -666,27 +734,23 @@ pub const TestContext = struct {
                 }
             }
-            var errors = std.ArrayList([]const u8).init(gpa);
+            var errors = std.ArrayList([]const u8).init(ctx.arena);
-            defer errors.deinit();
             if (manifest_start) |start| {
                 // Due to the above processing, we know that this is a contiguous block of comments
-                var manifest_it = std.mem.tokenize(u8, contents[start..manifest_end], "\r\n");
+                var manifest_it = std.mem.tokenize(u8, src[start..manifest_end], "\r\n");
                 // First line is the test case name
-                const first_line = manifest_it.next() orelse return error.InvalidFile;
+                const first_line = manifest_it.next() orelse return error.MissingTestCaseName;
-                const case_name = try std.mem.concat(gpa, u8, &.{ name, ": ", std.mem.trim(u8, first_line[2..], " \t") });
+                const case_name = try std.mem.concat(ctx.arena, u8, &.{ name, ": ", std.mem.trim(u8, first_line[2..], " \t") });
                 // If the second line is present, it should be blank
                 if (manifest_it.next()) |second_line| {
-                    if (std.mem.trim(u8, second_line[2..], " \t").len != 0) return error.InvalidFile;
+                    if (std.mem.trim(u8, second_line[2..], " \t").len != 0) return error.SecondLineNotBlank;
                 }
                 // All following lines are expected error messages
-                while (manifest_it.next()) |line| try errors.append(try gpa.dupe(u8, std.mem.trim(u8, line[2..], " \t")));
+                while (manifest_it.next()) |line| try errors.append(try ctx.arena.dupe(u8, std.mem.trim(u8, line[2..], " \t")));
-                // The entire file contents is the source, including the manifest
-                const src = try gpa.dupeZ(u8, contents);
                 const case = opt_case orelse case: {
                     ctx.cases.append(TestContext.Case{
 @@ -702,22 +766,27 @@ pub const TestContext = struct {
                     opt_case = case;
                     break :case case;
                 };
-                if (one_test_case_per_file) {
+                switch (strategy) {
-                    case.name = case_name;
+                    .independent => {
-                    case.addError(src, errors.items);
+                        case.name = case_name;
-                    opt_case = null;
+                        case.addError(src, errors.items);
-                } else {
+                        opt_case = null;
-                    case.addErrorNamed(case_name, src, errors.items);
+                    },
+                    .incremental => {
+                        case.addErrorNamed(case_name, src, errors.items);
+                    },
                 }
             } else {
-                return error.InvalidFile; // Manifests are currently mandatory
+                return error.MissingManifest;
             }
         }
     }
-    fn init() TestContext {
+    fn init(gpa: Allocator, arena: Allocator) TestContext {
-        const allocator = std.heap.page_allocator;
+        return .{
-        return .{ .cases = std.ArrayList(Case).init(allocator) };
+            .cases = std.ArrayList(Case).init(gpa),
+            .arena = arena,
+        };
     }
     fn deinit(self: *TestContext) void {

test/compile_errors.zig-38

...	@@ -3,44 +3,6 @@ const builtin = @import("builtin");	...	@@ -3,44 +3,6 @@ const builtin = @import("builtin");
3	const TestContext = @import("../src/test.zig").TestContext;	3	const TestContext = @import("../src/test.zig").TestContext;
4		4
5	pub fn addCases(ctx: *TestContext) !void {	5	pub fn addCases(ctx: *TestContext) !void {
6	var parent_dir = try std.fs.cwd().openDir(std.fs.path.dirname(@src().file).?, .{ .no_follow = true });
7	defer parent_dir.close();
8
9	var compile_errors_dir = try parent_dir.openDir("compile_errors", .{ .no_follow = true });
10	defer compile_errors_dir.close();
11
12	{
13	var stage2_dir = try compile_errors_dir.openDir("stage2", .{ .iterate = true, .no_follow = true });
14	defer stage2_dir.close();
15
16	// TODO make this false once the bug is solved that it triggers
17	const one_test_case_per_file = true;
18	try ctx.addErrorCasesFromDir("stage2", stage2_dir, .stage2, .Obj, false, one_test_case_per_file);
19	}
20
21	{
22	var stage1_dir = try compile_errors_dir.openDir("stage1", .{ .no_follow = true });
23	defer stage1_dir.close();
24	{
25	const one_test_case_per_file = true;
26
27	var obj_dir = try stage1_dir.openDir("obj", .{ .iterate = true, .no_follow = true });
28	defer obj_dir.close();
29
30	try ctx.addErrorCasesFromDir("stage1", obj_dir, .stage1, .Obj, false, one_test_case_per_file);
31
32	var exe_dir = try stage1_dir.openDir("exe", .{ .iterate = true, .no_follow = true });
33	defer exe_dir.close();
34
35	try ctx.addErrorCasesFromDir("stage1", exe_dir, .stage1, .Exe, false, one_test_case_per_file);
36
37	var test_dir = try stage1_dir.openDir("test", .{ .iterate = true, .no_follow = true });
38	defer test_dir.close();
39
40	try ctx.addErrorCasesFromDir("stage1", test_dir, .stage1, .Exe, true, one_test_case_per_file);
41	}
42	}
43
44	{	6	{
45	const case = ctx.obj("callconv(.Interrupt) on unsupported platform", .{	7	const case = ctx.obj("callconv(.Interrupt) on unsupported platform", .{
46	.cpu_arch = .aarch64,	8	.cpu_arch = .aarch64,

test/compile_errors/stage1/exe/std.fmt_error_for_unused_arguments.zig deleted-7

...	@@ -1,7 +0,0 @@
1	pub fn main() !void {
2	@import("std").debug.print("{d} {d} {d} {d} {d}", .{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15});
3	}
4
5	// std.fmt error for unused arguments
6	//
7	// ?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'

test/compile_errors/stage1/obj/constant_inside_comptime_function_has_compile_error.zig deleted-19

...	@@ -1,19 +0,0 @@
1	const ContextAllocator = MemoryPool(usize);
2
3	pub fn MemoryPool(comptime T: type) type {
4	const free_list_t = @compileError("aoeu",);
5
6	return struct {
7	free_list: free_list_t,
8	};
9	}
10
11	export fn entry() void {
12	var allocator: ContextAllocator = undefined;
13	}
14
15	// constant inside comptime function has compile error
16	//
17	// tmp.zig:4:5: error: unreachable code
18	// tmp.zig:4:25: note: control flow is diverted here
19	// tmp.zig:12:9: error: unused local variable

test/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig created+7

...	@@ -0,0 +1,7 @@
1	export fn entry() void {
2	@import("std").debug.print("{d} {d} {d} {d} {d}", .{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15});
3	}
4
5	// std.fmt error for unused arguments
6	//
7	// ?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'

test/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig created+11

...	@@ -0,0 +1,11 @@
1	fn foo() !void {
2	errdefer \|a\| unreachable;
3	return error.A;
4	}
5	export fn entry() void {
6	foo() catch unreachable;
7	}
8
9	// unused variable error on errdefer
10	//
11	// tmp.zig:2:15: error: unused variable: 'a'

test/compile_errors/stage1/test/duplicate-unused_labels.zig deleted-30

...	@@ -1,30 +0,0 @@
1	comptime {
2	blk: { blk: while (false) {} }
3	}
4	comptime {
5	blk: while (false) { blk: for (@as([0]void, undefined)) \|_\| {} }
6	}
7	comptime {
8	blk: for (@as([0]void, undefined)) \|_\| { blk: {} }
9	}
10	comptime {
11	blk: {}
12	}
13	comptime {
14	blk: while(false) {}
15	}
16	comptime {
17	blk: for(@as([0]void, undefined)) \|_\| {}
18	}
19
20	// duplicate/unused labels
21	//
22	// tmp.zig:2:12: error: redefinition of label 'blk'
23	// tmp.zig:2:5: note: previous definition here
24	// tmp.zig:5:26: error: redefinition of label 'blk'
25	// tmp.zig:5:5: note: previous definition here
26	// tmp.zig:8:46: error: redefinition of label 'blk'
27	// tmp.zig:8:5: note: previous definition here
28	// tmp.zig:11:5: error: unused block label
29	// tmp.zig:14:5: error: unused while loop label
30	// tmp.zig:17:5: error: unused for loop label

test/compile_errors/stage1/test/unused_variable_error_on_errdefer.zig deleted-11

...	@@ -1,11 +0,0 @@
1	fn foo() !void {
2	errdefer \|a\| unreachable;
3	return error.A;
4	}
5	export fn entry() void {
6	foo() catch unreachable;
7	}
8
9	// unused variable error on errdefer
10	//
11	// tmp.zig:2:15: error: unused variable: 'a'

test/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig created+20

...	@@ -0,0 +1,20 @@
1	const ContextAllocator = MemoryPool(usize);
2
3	pub fn MemoryPool(comptime T: type) type {
4	const free_list_t = @compileError("aoeu",);
5	_ = T;
6
7	return struct {
8	free_list: free_list_t,
9	};
10	}
11
12	export fn entry() void {
13	var allocator: ContextAllocator = undefined;
14	_ = allocator;
15	}
16
17	// constant inside comptime function has compile error
18	//
19	// :4:5: error: unreachable code
20	// :4:25: note: control flow is diverted here

test/compile_errors/stage2/duplicate-unused_labels.zig created+30

...	@@ -0,0 +1,30 @@
1	comptime {
2	blk: { blk: while (false) {} }
3	}
4	comptime {
5	blk: while (false) { blk: for (@as([0]void, undefined)) \|_\| {} }
6	}
7	comptime {
8	blk: for (@as([0]void, undefined)) \|_\| { blk: {} }
9	}
10	comptime {
11	blk: {}
12	}
13	comptime {
14	blk: while(false) {}
15	}
16	comptime {
17	blk: for(@as([0]void, undefined)) \|_\| {}
18	}
19
20	// duplicate/unused labels
21	//
22	// :2:12: error: redefinition of label 'blk'
23	// :2:5: note: previous definition here
24	// :5:26: error: redefinition of label 'blk'
25	// :5:5: note: previous definition here
26	// :8:46: error: redefinition of label 'blk'
27	// :8:5: note: previous definition here
28	// :11:5: error: unused block label
29	// :14:5: error: unused while loop label
30	// :17:5: error: unused for loop label

...	@@ -54,7 +54,7 @@ pub fn build(b: *Builder) !void {	...	@@ -54,7 +54,7 @@ pub fn build(b: *Builder) !void {
54	const skip_release_safe = b.option(bool, "skip-release-safe", "Main test suite skips release-safe builds") orelse skip_release;	54	const skip_release_safe = b.option(bool, "skip-release-safe", "Main test suite skips release-safe builds") orelse skip_release;
55	const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse false;	55	const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse false;
56	const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;	56	const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;
57	const skip_compile_errors = b.option(bool, "skip-compile-errors", "Main test suite skips compile error tests") orelse false;	57	const skip_stage1 = b.option(bool, "skip-stage1", "Main test suite skips stage1 compile error tests") orelse false;
58	const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;	58	const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;
59	const skip_stage2_tests = b.option(bool, "skip-stage2-tests", "Main test suite skips self-hosted compiler tests") orelse false;	59	const skip_stage2_tests = b.option(bool, "skip-stage2-tests", "Main test suite skips self-hosted compiler tests") orelse false;
60	const skip_install_lib_files = b.option(bool, "skip-install-lib-files", "Do not copy lib/ files to installation prefix") orelse false;	60	const skip_install_lib_files = b.option(bool, "skip-install-lib-files", "Do not copy lib/ files to installation prefix") orelse false;
...	@@ -386,7 +386,7 @@ pub fn build(b: *Builder) !void {	...	@@ -386,7 +386,7 @@ pub fn build(b: *Builder) !void {
386	test_stage2_options.addOption(bool, "enable_logging", enable_logging);	386	test_stage2_options.addOption(bool, "enable_logging", enable_logging);
387	test_stage2_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);	387	test_stage2_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
388	test_stage2_options.addOption(bool, "skip_non_native", skip_non_native);	388	test_stage2_options.addOption(bool, "skip_non_native", skip_non_native);
389	test_stage2_options.addOption(bool, "skip_compile_errors", skip_compile_errors);	389	test_stage2_options.addOption(bool, "skip_stage1", skip_stage1);
390	test_stage2_options.addOption(bool, "is_stage1", is_stage1);	390	test_stage2_options.addOption(bool, "is_stage1", is_stage1);
391	test_stage2_options.addOption(bool, "omit_stage2", omit_stage2);	391	test_stage2_options.addOption(bool, "omit_stage2", omit_stage2);
392	test_stage2_options.addOption(bool, "have_llvm", enable_llvm);	392	test_stage2_options.addOption(bool, "have_llvm", enable_llvm);