| ... | @@ -478,11 +478,13 @@ fn lowerZigArgs( | ... | @@ -478,11 +478,13 @@ fn lowerZigArgs( |
| 478 | if (!my_responsibility) continue; | 478 | if (!my_responsibility) continue; |
| 479 | if (cli_named_modules.modules.getIndex(mod_index)) |module_cli_index| { | 479 | if (cli_named_modules.modules.getIndex(mod_index)) |module_cli_index| { |
| 480 | const module_cli_name = cli_named_modules.names.keys()[module_cli_index]; | 480 | const module_cli_name = cli_named_modules.names.keys()[module_cli_index]; |
| | 481 | const module_index = cli_named_modules.modules.keys()[module_cli_index]; |
| | 482 | try appendModuleFlags(module_index, zig_args, compile_index, maker); |
| | 483 | |
| 481 | if (true) @panic("TODO"); | 484 | if (true) @panic("TODO"); |
| 482 | try appendModuleFlags(zig_args, step); | | |
| 483 | | 485 | |
| 484 | // --dep arguments | 486 | // --dep arguments |
| 485 | try zig_args.ensureUnusedCapacity(mod.import_table.count() * 2); | 487 | try zig_args.ensureUnusedCapacity(gpa, mod.import_table.count() * 2); |
| 486 | for (mod.import_table.keys(), mod.import_table.values()) |name, import| { | 488 | for (mod.import_table.keys(), mod.import_table.values()) |name, import| { |
| 487 | const import_index = cli_named_modules.modules.getIndex(import).?; | 489 | const import_index = cli_named_modules.modules.getIndex(import).?; |
| 488 | const import_cli_name = cli_named_modules.names.keys()[import_index]; | 490 | const import_cli_name = cli_named_modules.names.keys()[import_index]; |
| ... | @@ -1389,129 +1391,170 @@ fn getModuleList( | ... | @@ -1389,129 +1391,170 @@ fn getModuleList( |
| 1389 | } | 1391 | } |
| 1390 | | 1392 | |
| 1391 | fn appendModuleFlags( | 1393 | fn appendModuleFlags( |
| 1392 | m: *Module, | 1394 | module_index: Configuration.Module.Index, |
| 1393 | zig_args: *std.array_list.Managed([]const u8), | 1395 | zig_args: *std.ArrayList([]const u8), |
| 1394 | asking_step: ?*Step, | 1396 | asking_step: Configuration.Step.Index, |
| | 1397 | maker: *const Maker, |
| 1395 | ) !void { | 1398 | ) !void { |
| 1396 | const b = m.owner; | 1399 | const gpa = maker.gpa; |
| 1397 | | 1400 | const graph = maker.graph; |
| 1398 | try addFlag(zig_args, m.strip, "-fstrip", "-fno-strip"); | 1401 | const arena = graph.arena; // TODO don't leak into the process arena |
| 1399 | try addFlag(zig_args, m.single_threaded, "-fsingle-threaded", "-fno-single-threaded"); | 1402 | const conf = &maker.scanned_config.configuration; |
| 1400 | try addFlag(zig_args, m.stack_check, "-fstack-check", "-fno-stack-check"); | 1403 | const m = module_index.get(conf); |
| 1401 | try addFlag(zig_args, m.stack_protector, "-fstack-protector", "-fno-stack-protector"); | 1404 | |
| 1402 | try addFlag(zig_args, m.omit_frame_pointer, "-fomit-frame-pointer", "-fno-omit-frame-pointer"); | 1405 | try addFlag(gpa, zig_args, "strip", m.flags.strip.toBool()); |
| 1403 | try addFlag(zig_args, m.error_tracing, "-ferror-tracing", "-fno-error-tracing"); | 1406 | try addFlag(gpa, zig_args, "single-threaded", m.flags.single_threaded.toBool()); |
| 1404 | try addFlag(zig_args, m.sanitize_thread, "-fsanitize-thread", "-fno-sanitize-thread"); | 1407 | try addFlag(gpa, zig_args, "stack-check", m.flags.stack_check.toBool()); |
| 1405 | try addFlag(zig_args, m.fuzz, "-ffuzz", "-fno-fuzz"); | 1408 | try addFlag(gpa, zig_args, "stack-protector", m.flags.stack_protector.toBool()); |
| 1406 | try addFlag(zig_args, m.valgrind, "-fvalgrind", "-fno-valgrind"); | 1409 | try addFlag(gpa, zig_args, "omit-frame-pointer", m.flags2.omit_frame_pointer.toBool()); |
| 1407 | try addFlag(zig_args, m.pic, "-fPIC", "-fno-PIC"); | 1410 | try addFlag(gpa, zig_args, "error-tracing", m.flags2.error_tracing.toBool()); |
| 1408 | try addFlag(zig_args, m.red_zone, "-mred-zone", "-mno-red-zone"); | 1411 | try addFlag(gpa, zig_args, "sanitize-thread", m.flags.sanitize_thread.toBool()); |
| 1409 | try addFlag(zig_args, m.no_builtin, "-fno-builtin", "-fbuiltin"); | 1412 | try addFlag(gpa, zig_args, "fuzz", m.flags.fuzz.toBool()); |
| 1410 | | 1413 | try addFlag(gpa, zig_args, "valgrind", m.flags2.valgrind.toBool()); |
| 1411 | if (m.sanitize_c) |sc| switch (sc) { | 1414 | try addFlag(gpa, zig_args, "PIC", m.flags2.pic.toBool()); |
| 1412 | .off => try zig_args.append("-fno-sanitize-c"), | 1415 | try addFlag(gpa, zig_args, "red-zone", m.flags2.red_zone.toBool()); |
| 1413 | .trap => try zig_args.append("-fsanitize-c=trap"), | 1416 | try addFlag(gpa, zig_args, "no-builtin", m.flags2.no_builtin.toBool()); |
| 1414 | .full => try zig_args.append("-fsanitize-c=full"), | | |
| 1415 | }; | | |
| 1416 | | 1417 | |
| 1417 | if (m.dwarf_format) |dwarf_format| { | 1418 | { |
| 1418 | try zig_args.append(switch (dwarf_format) { | 1419 | try zig_args.ensureUnusedCapacity(gpa, 6); |
| 1419 | .@"32" => "-gdwarf32", | | |
| 1420 | .@"64" => "-gdwarf64", | | |
| 1421 | }); | | |
| 1422 | } | | |
| 1423 | | 1420 | |
| 1424 | if (m.unwind_tables) |unwind_tables| { | 1421 | switch (m.flags.sanitize_c) { |
| 1425 | try zig_args.append(switch (unwind_tables) { | 1422 | .off => zig_args.appendAssumeCapacity("-fno-sanitize-c"), |
| 1426 | .none => "-fno-unwind-tables", | 1423 | .trap => zig_args.appendAssumeCapacity("-fsanitize-c=trap"), |
| 1427 | .sync => "-funwind-tables", | 1424 | .full => zig_args.appendAssumeCapacity("-fsanitize-c=full"), |
| 1428 | .async => "-fasync-unwind-tables", | 1425 | .default => {}, |
| 1429 | }); | 1426 | } |
| 1430 | } | | |
| 1431 | | 1427 | |
| 1432 | try zig_args.ensureUnusedCapacity(1); | 1428 | switch (m.flags.dwarf_format) { |
| 1433 | if (m.optimize) |optimize| switch (optimize) { | 1429 | .@"32" => zig_args.appendAssumeCapacity("-gdwarf32"), |
| 1434 | .Debug => zig_args.appendAssumeCapacity("-ODebug"), | 1430 | .@"64" => zig_args.appendAssumeCapacity("-gdwarf64"), |
| 1435 | .ReleaseSmall => zig_args.appendAssumeCapacity("-OReleaseSmall"), | 1431 | .default => {}, |
| 1436 | .ReleaseFast => zig_args.appendAssumeCapacity("-OReleaseFast"), | 1432 | } |
| 1437 | .ReleaseSafe => zig_args.appendAssumeCapacity("-OReleaseSafe"), | | |
| 1438 | }; | | |
| 1439 | | 1433 | |
| 1440 | if (m.code_model != .default) { | 1434 | switch (m.flags.unwind_tables) { |
| 1441 | try zig_args.append("-mcmodel"); | 1435 | .none => zig_args.appendAssumeCapacity("-fno-unwind-tables"), |
| 1442 | try zig_args.append(@tagName(m.code_model)); | 1436 | .sync => zig_args.appendAssumeCapacity("-funwind-tables"), |
| | 1437 | .async => zig_args.appendAssumeCapacity("-fasync-unwind-tables"), |
| | 1438 | .default => {}, |
| | 1439 | } |
| | 1440 | |
| | 1441 | switch (m.flags.optimize) { |
| | 1442 | .debug => zig_args.appendAssumeCapacity("-ODebug"), |
| | 1443 | .safe => zig_args.appendAssumeCapacity("-OReleaseSafe"), |
| | 1444 | .fast => zig_args.appendAssumeCapacity("-OReleaseFast"), |
| | 1445 | .small => zig_args.appendAssumeCapacity("-OReleaseSmall"), |
| | 1446 | .default => {}, |
| | 1447 | } |
| | 1448 | |
| | 1449 | if (m.flags.code_model != .default) { |
| | 1450 | zig_args.appendAssumeCapacity("-mcmodel"); |
| | 1451 | zig_args.appendAssumeCapacity(@tagName(m.flags.code_model)); |
| | 1452 | } |
| 1443 | } | 1453 | } |
| 1444 | | 1454 | |
| 1445 | if (m.resolved_target) |*target| { | 1455 | if (m.resolved_target.get(conf)) |target| { |
| 1446 | // Communicate the query via CLI since it's more compact. | 1456 | // Communicate the query via CLI since it's more compact. |
| 1447 | if (!target.query.isNative()) { | 1457 | if (target.query.get(conf)) |query| { |
| 1448 | try zig_args.appendSlice(&.{ | 1458 | try zig_args.ensureUnusedCapacity(gpa, 6); |
| 1449 | "-target", try target.query.zigTriple(b.allocator), | 1459 | |
| 1450 | "-mcpu", try target.query.serializeCpuAlloc(b.allocator), | 1460 | if (true) @panic("TODO"); |
| 1451 | }); | 1461 | |
| 1452 | if (target.query.dynamic_linker) |*dynamic_linker| { | 1462 | zig_args.appendAssumeCapacity("-target"); |
| 1453 | if (dynamic_linker.get()) |dynamic_linker_path| { | 1463 | zig_args.appendAssumeCapacity(try query.zigTriple(arena)); |
| 1454 | try zig_args.append("--dynamic-linker"); | 1464 | zig_args.appendAssumeCapacity("-mcpu"); |
| 1455 | try zig_args.append(dynamic_linker_path); | 1465 | zig_args.appendAssumeCapacity(try query.serializeCpuAlloc(arena)); |
| | 1466 | |
| | 1467 | if (query.dynamic_linker) |dynamic_linker| { |
| | 1468 | const dynamic_linker_slice = dynamic_linker.slice(conf); |
| | 1469 | if (dynamic_linker_slice.len != 0) { |
| | 1470 | zig_args.appendAssumeCapacity("--dynamic-linker"); |
| | 1471 | zig_args.appendAssumeCapacity(dynamic_linker_slice); |
| 1456 | } else { | 1472 | } else { |
| 1457 | try zig_args.append("--no-dynamic-linker"); | 1473 | zig_args.appendAssumeCapacity("--no-dynamic-linker"); |
| 1458 | } | 1474 | } |
| 1459 | } | 1475 | } |
| 1460 | } | 1476 | } |
| 1461 | } | 1477 | } |
| 1462 | | 1478 | |
| 1463 | for (m.export_symbol_names) |symbol_name| { | 1479 | for (m.export_symbol_names.slice) |symbol_name| { |
| 1464 | try zig_args.append(b.fmt("--export={s}", .{symbol_name})); | 1480 | try zig_args.append(gpa, try allocPrint(arena, "--export={s}", .{symbol_name.slice(conf)})); |
| 1465 | } | 1481 | } |
| 1466 | | 1482 | |
| 1467 | for (m.include_dirs.items) |include_dir| { | 1483 | for (0..m.include_dirs.len) |i| |
| 1468 | try appendIncludeDirFlags(include_dir, b, zig_args, asking_step); | 1484 | try appendIncludeDirFlags(m.include_dirs.get(conf.extra, i), zig_args, asking_step, maker); |
| 1469 | } | | |
| 1470 | | 1485 | |
| 1471 | try zig_args.appendSlice(m.c_macros.items); | 1486 | try zig_args.ensureUnusedCapacity(gpa, m.c_macros.slice.len); |
| | 1487 | for (m.c_macros.slice) |c_macro| |
| | 1488 | zig_args.appendAssumeCapacity(c_macro.slice(conf)); |
| 1472 | | 1489 | |
| 1473 | try zig_args.ensureUnusedCapacity(2 * m.lib_paths.items.len); | 1490 | try zig_args.ensureUnusedCapacity(gpa, 2 * m.lib_paths.slice.len); |
| 1474 | for (m.lib_paths.items) |lib_path| { | 1491 | for (m.lib_paths.slice) |lib_path| { |
| 1475 | zig_args.appendAssumeCapacity("-L"); | 1492 | zig_args.appendAssumeCapacity("-L"); |
| 1476 | zig_args.appendAssumeCapacity(lib_path.getPath2(b, asking_step)); | 1493 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lib_path, asking_step)); |
| 1477 | } | 1494 | } |
| 1478 | | 1495 | |
| 1479 | try zig_args.ensureUnusedCapacity(2 * m.rpaths.items.len); | 1496 | try zig_args.ensureUnusedCapacity(gpa, 2 * m.rpaths.len); |
| 1480 | for (m.rpaths.items) |rpath| switch (rpath) { | 1497 | for (0..m.rpaths.len) |i| switch (m.rpaths.get(conf.extra, i)) { |
| 1481 | .lazy_path => |lp| { | 1498 | .lazy_path => |lp| { |
| 1482 | zig_args.appendAssumeCapacity("-rpath"); | 1499 | zig_args.appendAssumeCapacity("-rpath"); |
| 1483 | zig_args.appendAssumeCapacity(lp.getPath2(b, asking_step)); | 1500 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step)); |
| 1484 | }, | 1501 | }, |
| 1485 | .special => |bytes| { | 1502 | .special => |string| { |
| 1486 | zig_args.appendAssumeCapacity("-rpath"); | 1503 | zig_args.appendAssumeCapacity("-rpath"); |
| 1487 | zig_args.appendAssumeCapacity(bytes); | 1504 | zig_args.appendAssumeCapacity(string.slice(conf)); |
| 1488 | }, | 1505 | }, |
| 1489 | }; | 1506 | }; |
| 1490 | } | 1507 | } |
| 1491 | | 1508 | |
| 1492 | fn appendIncludeDirFlags( | 1509 | fn appendIncludeDirFlags( |
| 1493 | include_dir: Configuration.Module.IncludeDir, | 1510 | include_dir: Configuration.Module.IncludeDir, |
| 1494 | b: *std.Build, | 1511 | zig_args: *std.ArrayList([]const u8), |
| 1495 | zig_args: *std.array_list.Managed([]const u8), | 1512 | asking_step: Configuration.Step.Index, |
| 1496 | asking_step: ?*Step, | 1513 | maker: *const Maker, |
| 1497 | ) !void { | 1514 | ) !void { |
| 1498 | const flag: []const u8, const lazy_path: Configuration.LazyPath = switch (include_dir) { | 1515 | const gpa = maker.gpa; |
| 1499 | // zig fmt: off | 1516 | const graph = maker.graph; |
| 1500 | .path => |lp| .{ "-I", lp }, | 1517 | const arena = graph.arena; // TODO don't leak into the process arena |
| 1501 | .path_system => |lp| .{ "-isystem", lp }, | 1518 | |
| 1502 | .path_after => |lp| .{ "-idirafter", lp }, | 1519 | try zig_args.ensureUnusedCapacity(gpa, 2); |
| 1503 | .framework_path => |lp| .{ "-F", lp }, | 1520 | switch (include_dir) { |
| 1504 | .framework_path_system => |lp| .{ "-iframework", lp }, | 1521 | .path => |lp| { |
| 1505 | .config_header_step => |ch| .{ "-I", ch.getOutputDir() }, | 1522 | zig_args.appendAssumeCapacity("-I"); |
| 1506 | .other_step => |comp| .{ "-I", comp.installed_headers_include_tree.?.getDirectory() }, | 1523 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step)); |
| 1507 | // zig fmt: on | 1524 | }, |
| | 1525 | .path_system => |lp| { |
| | 1526 | zig_args.appendAssumeCapacity("-isystem"); |
| | 1527 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step)); |
| | 1528 | }, |
| | 1529 | .path_after => |lp| { |
| | 1530 | zig_args.appendAssumeCapacity("-idirafter"); |
| | 1531 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step)); |
| | 1532 | }, |
| | 1533 | .framework_path => |lp| { |
| | 1534 | zig_args.appendAssumeCapacity("-F"); |
| | 1535 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step)); |
| | 1536 | }, |
| | 1537 | .framework_path_system => |lp| { |
| | 1538 | zig_args.appendAssumeCapacity("-iframework"); |
| | 1539 | zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step)); |
| | 1540 | }, |
| | 1541 | .config_header_step => |ch| { |
| | 1542 | zig_args.appendAssumeCapacity("-I"); |
| | 1543 | if (true) @panic("TODO"); |
| | 1544 | ch.getOutputDir(); |
| | 1545 | }, |
| | 1546 | .other_step => |comp| { |
| | 1547 | zig_args.appendAssumeCapacity("-I"); |
| | 1548 | if (true) @panic("TODO"); |
| | 1549 | comp.installed_headers_include_tree.?.getDirectory(); |
| | 1550 | }, |
| 1508 | .embed_path => |lazy_path| { | 1551 | .embed_path => |lazy_path| { |
| 1509 | // Special case: this is a single arg. | 1552 | try zig_args.append( |
| 1510 | const resolved = lazy_path.getPath3(b, asking_step); | 1553 | gpa, |
| 1511 | const arg = b.fmt("--embed-dir={f}", .{resolved}); | 1554 | try allocPrint(arena, "--embed-dir={f}", .{ |
| 1512 | return zig_args.append(arg); | 1555 | try maker.resolveLazyPathIndex(arena, lazy_path, asking_step), |
| | 1556 | }), |
| | 1557 | ); |
| 1513 | }, | 1558 | }, |
| 1514 | }; | 1559 | } |
| 1515 | const resolved_str = try lazy_path.getPath3(b, asking_step).toString(b.graph.arena); | | |
| 1516 | return zig_args.appendSlice(&.{ flag, resolved_str }); | | |
| 1517 | } | 1560 | } |
Andrew Kelley <andrew@ziglang.org> 2026-03-11 21:09:22-07:00
lib