| ... | @@ -44,7 +44,7 @@ const test_targets = blk: { | ... | @@ -44,7 +44,7 @@ const test_targets = blk: { |
| 44 | break :blk [_]TestTarget{ | 44 | break :blk [_]TestTarget{ |
| 45 | // Native Targets | 45 | // Native Targets |
| 46 | | 46 | |
| 47 | .{}, | 47 | .{}, // 0 index must be all defaults |
| 48 | .{ | 48 | .{ |
| 49 | .link_libc = true, | 49 | .link_libc = true, |
| 50 | }, | 50 | }, |
| ... | @@ -2224,6 +2224,7 @@ const ModuleTestOptions = struct { | ... | @@ -2224,6 +2224,7 @@ const ModuleTestOptions = struct { |
| 2224 | desc: []const u8, | 2224 | desc: []const u8, |
| 2225 | optimize_modes: []const OptimizeMode, | 2225 | optimize_modes: []const OptimizeMode, |
| 2226 | include_paths: []const []const u8, | 2226 | include_paths: []const []const u8, |
| | 2227 | test_default_only: bool, |
| 2227 | skip_single_threaded: bool, | 2228 | skip_single_threaded: bool, |
| 2228 | skip_non_native: bool, | 2229 | skip_non_native: bool, |
| 2229 | skip_freebsd: bool, | 2230 | skip_freebsd: bool, |
| ... | @@ -2235,13 +2236,21 @@ const ModuleTestOptions = struct { | ... | @@ -2235,13 +2236,21 @@ const ModuleTestOptions = struct { |
| 2235 | skip_libc: bool, | 2236 | skip_libc: bool, |
| 2236 | max_rss: usize = 0, | 2237 | max_rss: usize = 0, |
| 2237 | no_builtin: bool = false, | 2238 | no_builtin: bool = false, |
| 2238 | build_options: ?*std.Build.Step.Options = null, | 2239 | build_options: ?*Step.Options = null, |
| 2239 | }; | 2240 | }; |
| 2240 | | 2241 | |
| 2241 | pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step { | 2242 | pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step { |
| 2242 | const step = b.step(b.fmt("test-{s}", .{options.name}), options.desc); | 2243 | const step = b.step(b.fmt("test-{s}", .{options.name}), options.desc); |
| 2243 | | 2244 | |
| 2244 | for_targets: for (test_targets) |test_target| { | 2245 | if (options.test_default_only) { |
| | 2246 | const test_target = &test_targets[0]; |
| | 2247 | const resolved_target = b.resolveTargetQuery(test_target.target); |
| | 2248 | const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); |
| | 2249 | addOneModuleTest(b, step, test_target, &resolved_target, triple_txt, options); |
| | 2250 | return step; |
| | 2251 | } |
| | 2252 | |
| | 2253 | for_targets: for (&test_targets) |*test_target| { |
| 2245 | if (test_target.skip_modules.len > 0) { | 2254 | if (test_target.skip_modules.len > 0) { |
| 2246 | for (test_target.skip_modules) |skip_mod| { | 2255 | for (test_target.skip_modules) |skip_mod| { |
| 2247 | if (std.mem.eql(u8, options.name, skip_mod)) continue :for_targets; | 2256 | if (std.mem.eql(u8, options.name, skip_mod)) continue :for_targets; |
| ... | @@ -2306,167 +2315,180 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step { | ... | @@ -2306,167 +2315,180 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step { |
| 2306 | } else false; | 2315 | } else false; |
| 2307 | if (!want_this_mode) continue; | 2316 | if (!want_this_mode) continue; |
| 2308 | | 2317 | |
| 2309 | const libc_suffix = if (test_target.link_libc == true) "-libc" else ""; | 2318 | addOneModuleTest(b, step, test_target, &resolved_target, triple_txt, options); |
| 2310 | const model_txt = target.cpu.model.name; | 2319 | } |
| | 2320 | return step; |
| | 2321 | } |
| 2311 | | 2322 | |
| 2312 | // wasm32-wasi builds need more RAM, idk why | 2323 | fn addOneModuleTest( |
| 2313 | const max_rss = if (target.os.tag == .wasi) | 2324 | b: *std.Build, |
| 2314 | options.max_rss * 2 | 2325 | step: *Step, |
| 2315 | else | 2326 | test_target: *const TestTarget, |
| 2316 | options.max_rss; | 2327 | resolved_target: *const std.Build.ResolvedTarget, |
| | 2328 | triple_txt: []const u8, |
| | 2329 | options: ModuleTestOptions, |
| | 2330 | ) void { |
| | 2331 | const target = &resolved_target.result; |
| | 2332 | const libc_suffix = if (test_target.link_libc == true) "-libc" else ""; |
| | 2333 | const model_txt = target.cpu.model.name; |
| | 2334 | |
| | 2335 | // wasm32-wasi builds need more RAM, idk why |
| | 2336 | const max_rss = if (target.os.tag == .wasi) |
| | 2337 | options.max_rss * 2 |
| | 2338 | else |
| | 2339 | options.max_rss; |
| | 2340 | |
| | 2341 | const these_tests = b.addTest(.{ |
| | 2342 | .root_module = b.createModule(.{ |
| | 2343 | .root_source_file = b.path(options.root_src), |
| | 2344 | .optimize = test_target.optimize_mode, |
| | 2345 | .target = resolved_target.*, |
| | 2346 | .link_libc = test_target.link_libc, |
| | 2347 | .pic = test_target.pic, |
| | 2348 | .strip = test_target.strip, |
| | 2349 | .single_threaded = test_target.single_threaded, |
| | 2350 | }), |
| | 2351 | .max_rss = max_rss, |
| | 2352 | .filters = options.test_filters, |
| | 2353 | .use_llvm = test_target.use_llvm, |
| | 2354 | .use_lld = test_target.use_lld, |
| | 2355 | .zig_lib_dir = b.path("lib"), |
| | 2356 | }); |
| | 2357 | these_tests.linkage = test_target.linkage; |
| | 2358 | if (options.no_builtin) these_tests.root_module.no_builtin = false; |
| | 2359 | if (options.build_options) |build_options| { |
| | 2360 | these_tests.root_module.addOptions("build_options", build_options); |
| | 2361 | } |
| | 2362 | const single_threaded_suffix = if (test_target.single_threaded == true) "-single" else ""; |
| | 2363 | const backend_suffix = if (test_target.use_llvm == true) |
| | 2364 | "-llvm" |
| | 2365 | else if (target.ofmt == std.Target.ObjectFormat.c) |
| | 2366 | "-cbe" |
| | 2367 | else if (test_target.use_llvm == false) |
| | 2368 | "-selfhosted" |
| | 2369 | else |
| | 2370 | ""; |
| | 2371 | const use_lld = if (test_target.use_lld == false) "-no-lld" else ""; |
| | 2372 | const linkage_name = if (test_target.linkage) |linkage| switch (linkage) { |
| | 2373 | inline else => |t| "-" ++ @tagName(t), |
| | 2374 | } else ""; |
| | 2375 | const use_pic = if (test_target.pic == true) "-pic" else ""; |
| | 2376 | |
| | 2377 | for (options.include_paths) |include_path| these_tests.root_module.addIncludePath(b.path(include_path)); |
| | 2378 | |
| | 2379 | const qualified_name = b.fmt("{s}-{s}-{s}-{t}{s}{s}{s}{s}{s}{s}", .{ |
| | 2380 | options.name, |
| | 2381 | triple_txt, |
| | 2382 | model_txt, |
| | 2383 | test_target.optimize_mode, |
| | 2384 | libc_suffix, |
| | 2385 | single_threaded_suffix, |
| | 2386 | backend_suffix, |
| | 2387 | use_lld, |
| | 2388 | linkage_name, |
| | 2389 | use_pic, |
| | 2390 | }); |
| 2317 | | 2391 | |
| 2318 | const these_tests = b.addTest(.{ | 2392 | if (target.ofmt == std.Target.ObjectFormat.c) { |
| 2319 | .root_module = b.createModule(.{ | 2393 | var altered_query = test_target.target; |
| 2320 | .root_source_file = b.path(options.root_src), | 2394 | altered_query.ofmt = null; |
| 2321 | .optimize = test_target.optimize_mode, | 2395 | |
| 2322 | .target = resolved_target, | 2396 | const compile_c = b.createModule(.{ |
| 2323 | .link_libc = test_target.link_libc, | 2397 | .root_source_file = null, |
| 2324 | .pic = test_target.pic, | 2398 | .link_libc = test_target.link_libc, |
| 2325 | .strip = test_target.strip, | 2399 | .target = b.resolveTargetQuery(altered_query), |
| 2326 | .single_threaded = test_target.single_threaded, | | |
| 2327 | }), | | |
| 2328 | .max_rss = max_rss, | | |
| 2329 | .filters = options.test_filters, | | |
| 2330 | .use_llvm = test_target.use_llvm, | | |
| 2331 | .use_lld = test_target.use_lld, | | |
| 2332 | .zig_lib_dir = b.path("lib"), | | |
| 2333 | }); | 2400 | }); |
| 2334 | these_tests.linkage = test_target.linkage; | 2401 | const compile_c_exe = b.addExecutable(.{ |
| 2335 | if (options.no_builtin) these_tests.root_module.no_builtin = false; | 2402 | .name = qualified_name, |
| 2336 | if (options.build_options) |build_options| { | 2403 | .root_module = compile_c, |
| 2337 | these_tests.root_module.addOptions("build_options", build_options); | 2404 | .zig_lib_dir = b.path("lib"), |
| 2338 | } | | |
| 2339 | const single_threaded_suffix = if (test_target.single_threaded == true) "-single" else ""; | | |
| 2340 | const backend_suffix = if (test_target.use_llvm == true) | | |
| 2341 | "-llvm" | | |
| 2342 | else if (target.ofmt == std.Target.ObjectFormat.c) | | |
| 2343 | "-cbe" | | |
| 2344 | else if (test_target.use_llvm == false) | | |
| 2345 | "-selfhosted" | | |
| 2346 | else | | |
| 2347 | ""; | | |
| 2348 | const use_lld = if (test_target.use_lld == false) "-no-lld" else ""; | | |
| 2349 | const linkage_name = if (test_target.linkage) |linkage| switch (linkage) { | | |
| 2350 | inline else => |t| "-" ++ @tagName(t), | | |
| 2351 | } else ""; | | |
| 2352 | const use_pic = if (test_target.pic == true) "-pic" else ""; | | |
| 2353 | | | |
| 2354 | for (options.include_paths) |include_path| these_tests.root_module.addIncludePath(b.path(include_path)); | | |
| 2355 | | | |
| 2356 | const qualified_name = b.fmt("{s}-{s}-{s}-{s}{s}{s}{s}{s}{s}{s}", .{ | | |
| 2357 | options.name, | | |
| 2358 | triple_txt, | | |
| 2359 | model_txt, | | |
| 2360 | @tagName(test_target.optimize_mode), | | |
| 2361 | libc_suffix, | | |
| 2362 | single_threaded_suffix, | | |
| 2363 | backend_suffix, | | |
| 2364 | use_lld, | | |
| 2365 | linkage_name, | | |
| 2366 | use_pic, | | |
| 2367 | }); | 2405 | }); |
| 2368 | | 2406 | |
| 2369 | if (target.ofmt == std.Target.ObjectFormat.c) { | 2407 | compile_c.addCSourceFile(.{ |
| 2370 | var altered_query = test_target.target; | 2408 | .file = these_tests.getEmittedBin(), |
| 2371 | altered_query.ofmt = null; | 2409 | .flags = &.{ |
| 2372 | | 2410 | // Tracking issue for making the C backend generate C89 compatible code: |
| 2373 | const compile_c = b.createModule(.{ | 2411 | // https://github.com/ziglang/zig/issues/19468 |
| 2374 | .root_source_file = null, | 2412 | "-std=c99", |
| 2375 | .link_libc = test_target.link_libc, | 2413 | "-Werror", |
| 2376 | .target = b.resolveTargetQuery(altered_query), | 2414 | |
| 2377 | }); | 2415 | "-Wall", |
| 2378 | const compile_c_exe = b.addExecutable(.{ | 2416 | "-Wembedded-directive", |
| 2379 | .name = qualified_name, | 2417 | "-Wempty-translation-unit", |
| 2380 | .root_module = compile_c, | 2418 | "-Wextra", |
| 2381 | .zig_lib_dir = b.path("lib"), | 2419 | "-Wgnu", |
| 2382 | }); | 2420 | "-Winvalid-utf8", |
| 2383 | | 2421 | "-Wkeyword-macro", |
| 2384 | compile_c.addCSourceFile(.{ | 2422 | "-Woverlength-strings", |
| 2385 | .file = these_tests.getEmittedBin(), | 2423 | |
| 2386 | .flags = &.{ | 2424 | // Tracking issue for making the C backend generate code |
| 2387 | // Tracking issue for making the C backend generate C89 compatible code: | 2425 | // that does not trigger warnings: |
| 2388 | // https://github.com/ziglang/zig/issues/19468 | 2426 | // https://github.com/ziglang/zig/issues/19467 |
| 2389 | "-std=c99", | 2427 | |
| 2390 | "-Werror", | 2428 | // spotted everywhere |
| 2391 | | 2429 | "-Wno-builtin-requires-header", |
| 2392 | "-Wall", | 2430 | |
| 2393 | "-Wembedded-directive", | 2431 | // spotted on linux |
| 2394 | "-Wempty-translation-unit", | 2432 | "-Wno-braced-scalar-init", |
| 2395 | "-Wextra", | 2433 | "-Wno-excess-initializers", |
| 2396 | "-Wgnu", | 2434 | "-Wno-incompatible-pointer-types-discards-qualifiers", |
| 2397 | "-Winvalid-utf8", | 2435 | "-Wno-unused", |
| 2398 | "-Wkeyword-macro", | 2436 | "-Wno-unused-parameter", |
| 2399 | "-Woverlength-strings", | 2437 | |
| 2400 | | 2438 | // spotted on darwin |
| 2401 | // Tracking issue for making the C backend generate code | 2439 | "-Wno-incompatible-pointer-types", |
| 2402 | // that does not trigger warnings: | 2440 | |
| 2403 | // https://github.com/ziglang/zig/issues/19467 | 2441 | // https://github.com/llvm/llvm-project/issues/153314 |
| 2404 | | 2442 | "-Wno-unterminated-string-initialization", |
| 2405 | // spotted everywhere | 2443 | |
| 2406 | "-Wno-builtin-requires-header", | 2444 | // In both Zig and C it is legal to return a pointer to a |
| 2407 | | 2445 | // local. The C backend lowers such thing directly, so the |
| 2408 | // spotted on linux | 2446 | // corresponding warning in C must be disabled. |
| 2409 | "-Wno-braced-scalar-init", | 2447 | "-Wno-return-stack-address", |
| 2410 | "-Wno-excess-initializers", | 2448 | }, |
| 2411 | "-Wno-incompatible-pointer-types-discards-qualifiers", | 2449 | }); |
| 2412 | "-Wno-unused", | 2450 | compile_c.addIncludePath(b.path("lib")); // for zig.h |
| 2413 | "-Wno-unused-parameter", | 2451 | if (target.os.tag == .windows) { |
| 2414 | | 2452 | if (true) { |
| 2415 | // spotted on darwin | 2453 | // Unfortunately this requires about 8G of RAM for clang to compile |
| 2416 | "-Wno-incompatible-pointer-types", | 2454 | // and our Windows CI runners do not have this much. |
| 2417 | | 2455 | // TODO This is not an appropriate way to work around this problem. |
| 2418 | // https://github.com/llvm/llvm-project/issues/153314 | 2456 | step.dependOn(&these_tests.step); |
| 2419 | "-Wno-unterminated-string-initialization", | 2457 | return; |
| 2420 | | 2458 | } |
| 2421 | // In both Zig and C it is legal to return a pointer to a | 2459 | if (test_target.link_libc == false) { |
| 2422 | // local. The C backend lowers such thing directly, so the | 2460 | compile_c_exe.subsystem = .Console; |
| 2423 | // corresponding warning in C must be disabled. | 2461 | compile_c.linkSystemLibrary("kernel32", .{}); |
| 2424 | "-Wno-return-stack-address", | 2462 | compile_c.linkSystemLibrary("ntdll", .{}); |
| 2425 | }, | 2463 | } |
| 2426 | }); | 2464 | if (mem.eql(u8, options.name, "std")) { |
| 2427 | compile_c.addIncludePath(b.path("lib")); // for zig.h | | |
| 2428 | if (target.os.tag == .windows) { | | |
| 2429 | if (true) { | | |
| 2430 | // Unfortunately this requires about 8G of RAM for clang to compile | | |
| 2431 | // and our Windows CI runners do not have this much. | | |
| 2432 | step.dependOn(&these_tests.step); | | |
| 2433 | continue; | | |
| 2434 | } | | |
| 2435 | if (test_target.link_libc == false) { | 2465 | if (test_target.link_libc == false) { |
| 2436 | compile_c_exe.subsystem = .Console; | 2466 | compile_c.linkSystemLibrary("shell32", .{}); |
| 2437 | compile_c.linkSystemLibrary("kernel32", .{}); | 2467 | compile_c.linkSystemLibrary("advapi32", .{}); |
| 2438 | compile_c.linkSystemLibrary("ntdll", .{}); | | |
| 2439 | } | | |
| 2440 | if (mem.eql(u8, options.name, "std")) { | | |
| 2441 | if (test_target.link_libc == false) { | | |
| 2442 | compile_c.linkSystemLibrary("shell32", .{}); | | |
| 2443 | compile_c.linkSystemLibrary("advapi32", .{}); | | |
| 2444 | } | | |
| 2445 | compile_c.linkSystemLibrary("crypt32", .{}); | | |
| 2446 | compile_c.linkSystemLibrary("ws2_32", .{}); | | |
| 2447 | compile_c.linkSystemLibrary("ole32", .{}); | | |
| 2448 | } | 2468 | } |
| | 2469 | compile_c.linkSystemLibrary("crypt32", .{}); |
| | 2470 | compile_c.linkSystemLibrary("ws2_32", .{}); |
| | 2471 | compile_c.linkSystemLibrary("ole32", .{}); |
| 2449 | } | 2472 | } |
| | 2473 | } |
| 2450 | | 2474 | |
| 2451 | const run = b.addRunArtifact(compile_c_exe); | 2475 | const run = b.addRunArtifact(compile_c_exe); |
| 2452 | run.skip_foreign_checks = true; | 2476 | run.skip_foreign_checks = true; |
| 2453 | run.enableTestRunnerMode(); | 2477 | run.enableTestRunnerMode(); |
| 2454 | run.setName(b.fmt("run test {s}", .{qualified_name})); | 2478 | run.setName(b.fmt("run test {s}", .{qualified_name})); |
| 2455 | | 2479 | |
| 2456 | step.dependOn(&run.step); | 2480 | step.dependOn(&run.step); |
| 2457 | } else if (target.cpu.arch.isSpirV()) { | 2481 | } else if (target.cpu.arch.isSpirV()) { |
| 2458 | // Don't run spirv binaries | 2482 | // Don't run spirv binaries |
| 2459 | _ = these_tests.getEmittedBin(); | 2483 | _ = these_tests.getEmittedBin(); |
| 2460 | step.dependOn(&these_tests.step); | 2484 | step.dependOn(&these_tests.step); |
| 2461 | } else { | 2485 | } else { |
| 2462 | const run = b.addRunArtifact(these_tests); | 2486 | const run = b.addRunArtifact(these_tests); |
| 2463 | run.skip_foreign_checks = true; | 2487 | run.skip_foreign_checks = true; |
| 2464 | run.setName(b.fmt("run test {s}", .{qualified_name})); | 2488 | run.setName(b.fmt("run test {s}", .{qualified_name})); |
| 2465 | | 2489 | |
| 2466 | step.dependOn(&run.step); | 2490 | step.dependOn(&run.step); |
| 2467 | } | | |
| 2468 | } | 2491 | } |
| 2469 | return step; | | |
| 2470 | } | 2492 | } |
| 2471 | | 2493 | |
| 2472 | pub fn wouldUseLlvm(use_llvm: ?bool, query: std.Target.Query, optimize_mode: OptimizeMode) bool { | 2494 | pub fn wouldUseLlvm(use_llvm: ?bool, query: std.Target.Query, optimize_mode: OptimizeMode) bool { |
Andrew Kelley <andrew@ziglang.org> 2025-10-08 14:08:35-07:00