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