authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-02-24 12:11:11-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-02-24 12:11:11-07:00
log5ab5e2e6731a9f1198df6c53134545ccc6a6bbd3
tree7b1e8bdc0fb357036d6827639d17f1a043d50e6d
parent6249a24e81b9b3df3d5ca99b57f22470b9ac486c

Revert "Merge pull request #10950 from hexops/sg/responsefiles"

This reverts commit 136a43934bc08dc3aee85f1182904b97456601d3, reversing changes made to 9dd839b7ed15d1191f3303d069cffe0473e03e83. This broke the behavior of `zig run`.

2 files changed, 144 insertions(+), 202 deletions(-)

lib/std/build.zig-36
...@@ -17,7 +17,6 @@ const fmt_lib = std.fmt;...@@ -17,7 +17,6 @@ const fmt_lib = std.fmt;
17const File = std.fs.File;17const File = std.fs.File;
18const CrossTarget = std.zig.CrossTarget;18const CrossTarget = std.zig.CrossTarget;
19const NativeTargetInfo = std.zig.system.NativeTargetInfo;19const NativeTargetInfo = std.zig.system.NativeTargetInfo;
20const Sha256 = std.crypto.hash.sha2.Sha256;
2120
22pub const FmtStep = @import("build/FmtStep.zig");21pub const FmtStep = @import("build/FmtStep.zig");
23pub const TranslateCStep = @import("build/TranslateCStep.zig");22pub const TranslateCStep = @import("build/TranslateCStep.zig");
...@@ -2893,41 +2892,6 @@ pub const LibExeObjStep = struct {...@@ -2893,41 +2892,6 @@ pub const LibExeObjStep = struct {
28932892
2894 try zig_args.append("--enable-cache");2893 try zig_args.append("--enable-cache");
28952894
2896 // Windows has an argument length limit of 32,766 characters, macOS 262,144 and Linux
2897 // 2,097,152. If our args exceed 30 KiB, we instead write them to a "response file" and
2898 // pass that to zig, e.g. via 'zig build-lib @args.rsp'
2899 var args_length: usize = 0;
2900 for (zig_args.items) |arg| {
2901 args_length += arg.len + 1; // +1 to account for null terminator
2902 }
2903 if (args_length >= 30 * 1024) {
2904 const args_dir = try fs.path.join(
2905 builder.allocator,
2906 &[_][]const u8{ builder.pathFromRoot("zig-cache"), "args" },
2907 );
2908 try std.fs.cwd().makePath(args_dir);
2909
2910 // Write the args to zig-cache/args/<SHA256 hash of args> to avoid conflicts with
2911 // other zig build commands running in parallel.
2912 const partially_quoted = try std.mem.join(builder.allocator, "\" \"", zig_args.items[2..]);
2913 const args = try std.mem.concat(builder.allocator, u8, &[_][]const u8{ "\"", partially_quoted, "\"" });
2914
2915 var args_hash: [Sha256.digest_length]u8 = undefined;
2916 Sha256.hash(args, &args_hash, .{});
2917 var args_hex_hash: [Sha256.digest_length * 2]u8 = undefined;
2918 _ = try std.fmt.bufPrint(
2919 &args_hex_hash,
2920 "{s}",
2921 .{std.fmt.fmtSliceHexLower(&args_hash)},
2922 );
2923
2924 const args_file = try fs.path.join(builder.allocator, &[_][]const u8{ args_dir, args_hex_hash[0..] });
2925 try std.fs.cwd().writeFile(args_file, args);
2926
2927 zig_args.shrinkRetainingCapacity(2);
2928 try zig_args.append(try std.mem.concat(builder.allocator, u8, &[_][]const u8{ "@", args_file }));
2929 }
2930
2931 const output_dir_nl = try builder.execFromStep(zig_args.items, &self.step);2895 const output_dir_nl = try builder.execFromStep(zig_args.items, &self.step);
2932 const build_output_dir = mem.trimRight(u8, output_dir_nl, "\r\n");2896 const build_output_dir = mem.trimRight(u8, output_dir_nl, "\r\n");
29332897
src/main.zig+144-166
...@@ -767,33 +767,11 @@ fn buildOutputType(...@@ -767,33 +767,11 @@ fn buildOutputType(
767 }767 }
768768
769 soname = .yes_default_value;769 soname = .yes_default_value;
770770 const args = all_args[2..];
771 const Iterator = struct {771 var i: usize = 0;
772 resp_file: ?ArgIteratorResponseFile = null,772 args_loop: while (i < args.len) : (i += 1) {
773 args: []const []const u8,773 const arg = args[i];
774 i: usize = 0,774 if (mem.startsWith(u8, arg, "-")) {
775 fn next(it: *@This()) ?[]const u8 {
776 if (it.i >= it.args.len) {
777 if (it.resp_file) |*resp| return if (resp.next()) |sentinel| std.mem.span(sentinel) else null;
778 return null;
779 }
780 defer it.i += 1;
781 return it.args[it.i];
782 }
783 };
784 var args_iter = Iterator{
785 .args = all_args[2..],
786 };
787
788 args_loop: while (args_iter.next()) |arg| {
789 if (mem.startsWith(u8, arg, "@")) {
790 // This is a "compiler response file". We must parse the file and treat its
791 // contents as command line parameters.
792 const resp_file_path = arg[1..];
793 args_iter.resp_file = initArgIteratorResponseFile(arena, resp_file_path) catch |err| {
794 fatal("unable to read response file '{s}': {s}", .{ resp_file_path, @errorName(err) });
795 };
796 } else if (mem.startsWith(u8, arg, "-")) {
797 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {775 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
798 try io.getStdOut().writeAll(usage_build_generic);776 try io.getStdOut().writeAll(usage_build_generic);
799 return cleanExit();777 return cleanExit();
...@@ -801,71 +779,73 @@ fn buildOutputType(...@@ -801,71 +779,73 @@ fn buildOutputType(
801 if (arg_mode == .run) {779 if (arg_mode == .run) {
802 // The index refers to all_args so skip `zig` `run`780 // The index refers to all_args so skip `zig` `run`
803 // and `--`781 // and `--`
804 runtime_args_start = args_iter.i + 3;782 runtime_args_start = i + 3;
805 break :args_loop;783 break :args_loop;
806 } else {784 } else {
807 fatal("unexpected end-of-parameter mark: --", .{});785 fatal("unexpected end-of-parameter mark: --", .{});
808 }786 }
809 } else if (mem.eql(u8, arg, "--pkg-begin")) {787 } else if (mem.eql(u8, arg, "--pkg-begin")) {
810 const pkg_name = args_iter.next();788 if (i + 2 >= args.len) fatal("Expected 2 arguments after {s}", .{arg});
811 const pkg_path = args_iter.next();789 i += 1;
812 if (pkg_name == null or pkg_path == null) fatal("Expected 2 arguments after {s}", .{arg});790 const pkg_name = args[i];
791 i += 1;
792 const pkg_path = args[i];
813793
814 const new_cur_pkg = Package.create(794 const new_cur_pkg = Package.create(
815 gpa,795 gpa,
816 fs.path.dirname(pkg_path.?),796 fs.path.dirname(pkg_path),
817 fs.path.basename(pkg_path.?),797 fs.path.basename(pkg_path),
818 ) catch |err| {798 ) catch |err| {
819 fatal("Failed to add package at path {s}: {s}", .{ pkg_path.?, @errorName(err) });799 fatal("Failed to add package at path {s}: {s}", .{ pkg_path, @errorName(err) });
820 };800 };
821 try cur_pkg.addAndAdopt(gpa, pkg_name.?, new_cur_pkg);801 try cur_pkg.addAndAdopt(gpa, pkg_name, new_cur_pkg);
822 cur_pkg = new_cur_pkg;802 cur_pkg = new_cur_pkg;
823 } else if (mem.eql(u8, arg, "--pkg-end")) {803 } else if (mem.eql(u8, arg, "--pkg-end")) {
824 cur_pkg = cur_pkg.parent orelse804 cur_pkg = cur_pkg.parent orelse
825 fatal("encountered --pkg-end with no matching --pkg-begin", .{});805 fatal("encountered --pkg-end with no matching --pkg-begin", .{});
826 } else if (mem.eql(u8, arg, "--main-pkg-path")) {806 } else if (mem.eql(u8, arg, "--main-pkg-path")) {
827 main_pkg_path = args_iter.next() orelse {807 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
828 fatal("expected parameter after {s}", .{arg});808 i += 1;
829 };809 main_pkg_path = args[i];
830 } else if (mem.eql(u8, arg, "-cflags")) {810 } else if (mem.eql(u8, arg, "-cflags")) {
831 extra_cflags.shrinkRetainingCapacity(0);811 extra_cflags.shrinkRetainingCapacity(0);
832 while (true) {812 while (true) {
833 const next_arg = args_iter.next() orelse {813 i += 1;
834 fatal("expected -- after -cflags", .{});814 if (i >= args.len) fatal("expected -- after -cflags", .{});
835 };815 if (mem.eql(u8, args[i], "--")) break;
836 if (mem.eql(u8, next_arg, "--")) break;816 try extra_cflags.append(args[i]);
837 try extra_cflags.append(next_arg);
838 }817 }
839 } else if (mem.eql(u8, arg, "--color")) {818 } else if (mem.eql(u8, arg, "--color")) {
840 const next_arg = args_iter.next() orelse {819 if (i + 1 >= args.len) {
841 fatal("expected [auto|on|off] after --color", .{});820 fatal("expected [auto|on|off] after --color", .{});
842 };821 }
822 i += 1;
823 const next_arg = args[i];
843 color = std.meta.stringToEnum(Color, next_arg) orelse {824 color = std.meta.stringToEnum(Color, next_arg) orelse {
844 fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg});825 fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg});
845 };826 };
846 } else if (mem.eql(u8, arg, "--subsystem")) {827 } else if (mem.eql(u8, arg, "--subsystem")) {
847 const next_arg = args_iter.next() orelse {828 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
848 fatal("expected parameter after {s}", .{arg});829 i += 1;
849 };830 if (mem.eql(u8, args[i], "console")) {
850 if (mem.eql(u8, next_arg, "console")) {
851 subsystem = .Console;831 subsystem = .Console;
852 } else if (mem.eql(u8, next_arg, "windows")) {832 } else if (mem.eql(u8, args[i], "windows")) {
853 subsystem = .Windows;833 subsystem = .Windows;
854 } else if (mem.eql(u8, next_arg, "posix")) {834 } else if (mem.eql(u8, args[i], "posix")) {
855 subsystem = .Posix;835 subsystem = .Posix;
856 } else if (mem.eql(u8, next_arg, "native")) {836 } else if (mem.eql(u8, args[i], "native")) {
857 subsystem = .Native;837 subsystem = .Native;
858 } else if (mem.eql(u8, next_arg, "efi_application")) {838 } else if (mem.eql(u8, args[i], "efi_application")) {
859 subsystem = .EfiApplication;839 subsystem = .EfiApplication;
860 } else if (mem.eql(u8, next_arg, "efi_boot_service_driver")) {840 } else if (mem.eql(u8, args[i], "efi_boot_service_driver")) {
861 subsystem = .EfiBootServiceDriver;841 subsystem = .EfiBootServiceDriver;
862 } else if (mem.eql(u8, next_arg, "efi_rom")) {842 } else if (mem.eql(u8, args[i], "efi_rom")) {
863 subsystem = .EfiRom;843 subsystem = .EfiRom;
864 } else if (mem.eql(u8, next_arg, "efi_runtime_driver")) {844 } else if (mem.eql(u8, args[i], "efi_runtime_driver")) {
865 subsystem = .EfiRuntimeDriver;845 subsystem = .EfiRuntimeDriver;
866 } else {846 } else {
867 fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{847 fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{
868 next_arg,848 args[i],
869 \\ console849 \\ console
870 \\ windows850 \\ windows
871 \\ posix851 \\ posix
...@@ -878,71 +858,67 @@ fn buildOutputType(...@@ -878,71 +858,67 @@ fn buildOutputType(
878 });858 });
879 }859 }
880 } else if (mem.eql(u8, arg, "-O")) {860 } else if (mem.eql(u8, arg, "-O")) {
881 optimize_mode_string = args_iter.next() orelse {861 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
882 fatal("expected parameter after {s}", .{arg});862 i += 1;
883 };863 optimize_mode_string = args[i];
884 } else if (mem.eql(u8, arg, "--entry")) {864 } else if (mem.eql(u8, arg, "--entry")) {
885 entry = args_iter.next() orelse {865 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
886 fatal("expected parameter after {s}", .{arg});866 i += 1;
887 };867 entry = args[i];
888 } else if (mem.eql(u8, arg, "--stack")) {868 } else if (mem.eql(u8, arg, "--stack")) {
889 const next_arg = args_iter.next() orelse {869 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
890 fatal("expected parameter after {s}", .{arg});870 i += 1;
891 };871 stack_size_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
892 stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
893 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });872 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
894 };873 };
895 } else if (mem.eql(u8, arg, "--image-base")) {874 } else if (mem.eql(u8, arg, "--image-base")) {
896 const next_arg = args_iter.next() orelse {875 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
897 fatal("expected parameter after {s}", .{arg});876 i += 1;
898 };877 image_base_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
899 image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
900 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });878 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
901 };879 };
902 } else if (mem.eql(u8, arg, "--name")) {880 } else if (mem.eql(u8, arg, "--name")) {
903 provided_name = args_iter.next() orelse {881 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
904 fatal("expected parameter after {s}", .{arg});882 i += 1;
905 };883 provided_name = args[i];
906 } else if (mem.eql(u8, arg, "-rpath")) {884 } else if (mem.eql(u8, arg, "-rpath")) {
907 try rpath_list.append(args_iter.next() orelse {885 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
908 fatal("expected parameter after {s}", .{arg});886 i += 1;
909 });887 try rpath_list.append(args[i]);
910 } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) {888 } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) {
911 try lib_dirs.append(args_iter.next() orelse {889 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
912 fatal("expected parameter after {s}", .{arg});890 i += 1;
913 });891 try lib_dirs.append(args[i]);
914 } else if (mem.eql(u8, arg, "-F")) {892 } else if (mem.eql(u8, arg, "-F")) {
915 try framework_dirs.append(args_iter.next() orelse {893 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
916 fatal("expected parameter after {s}", .{arg});894 i += 1;
917 });895 try framework_dirs.append(args[i]);
918 } else if (mem.eql(u8, arg, "-framework")) {896 } else if (mem.eql(u8, arg, "-framework")) {
919 try frameworks.append(args_iter.next() orelse {897 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
920 fatal("expected parameter after {s}", .{arg});898 i += 1;
921 });899 try frameworks.append(args[i]);
922 } else if (mem.eql(u8, arg, "-install_name")) {900 } else if (mem.eql(u8, arg, "-install_name")) {
923 install_name = args_iter.next() orelse {901 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
924 fatal("expected parameter after {s}", .{arg});902 i += 1;
925 };903 install_name = args[i];
926 } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) {904 } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) {
927 linker_script = args_iter.next() orelse {905 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
928 fatal("expected parameter after {s}", .{arg});906 i += 1;
929 };907 linker_script = args[i];
930 } else if (mem.eql(u8, arg, "--version-script")) {908 } else if (mem.eql(u8, arg, "--version-script")) {
931 version_script = args_iter.next() orelse {909 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
932 fatal("expected parameter after {s}", .{arg});910 i += 1;
933 };911 version_script = args[i];
934 } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) {912 } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) {
935 const next_arg = args_iter.next() orelse {913 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
936 fatal("expected parameter after {s}", .{arg});
937 };
938 // We don't know whether this library is part of libc or libc++ until914 // We don't know whether this library is part of libc or libc++ until
939 // we resolve the target, so we simply append to the list for now.915 // we resolve the target, so we simply append to the list for now.
940 try system_libs.put(next_arg, .{ .needed = false });916 i += 1;
917 try system_libs.put(args[i], .{ .needed = false });
941 } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) {918 } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) {
942 const next_arg = args_iter.next() orelse {919 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
943 fatal("expected parameter after {s}", .{arg});920 i += 1;
944 };921 try system_libs.put(args[i], .{ .needed = true });
945 try system_libs.put(next_arg, .{ .needed = true });
946 } else if (mem.eql(u8, arg, "-D") or922 } else if (mem.eql(u8, arg, "-D") or
947 mem.eql(u8, arg, "-isystem") or923 mem.eql(u8, arg, "-isystem") or
948 mem.eql(u8, arg, "-I") or924 mem.eql(u8, arg, "-I") or
...@@ -951,30 +927,31 @@ fn buildOutputType(...@@ -951,30 +927,31 @@ fn buildOutputType(
951 mem.eql(u8, arg, "-iframework") or927 mem.eql(u8, arg, "-iframework") or
952 mem.eql(u8, arg, "-iframeworkwithsysroot"))928 mem.eql(u8, arg, "-iframeworkwithsysroot"))
953 {929 {
930 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
931 i += 1;
954 try clang_argv.append(arg);932 try clang_argv.append(arg);
955 try clang_argv.append(args_iter.next() orelse {933 try clang_argv.append(args[i]);
956 fatal("expected parameter after {s}", .{arg});
957 });
958 } else if (mem.eql(u8, arg, "--version")) {934 } else if (mem.eql(u8, arg, "--version")) {
959 const next_arg = args_iter.next() orelse {935 if (i + 1 >= args.len) {
960 fatal("expected parameter after {s}", .{arg});936 fatal("expected parameter after --version", .{});
961 };937 }
962 version = std.builtin.Version.parse(next_arg) catch |err| {938 i += 1;
963 fatal("unable to parse --version '{s}': {s}", .{ next_arg, @errorName(err) });939 version = std.builtin.Version.parse(args[i]) catch |err| {
940 fatal("unable to parse --version '{s}': {s}", .{ args[i], @errorName(err) });
964 };941 };
965 have_version = true;942 have_version = true;
966 } else if (mem.eql(u8, arg, "-target")) {943 } else if (mem.eql(u8, arg, "-target")) {
967 target_arch_os_abi = args_iter.next() orelse {944 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
968 fatal("expected parameter after {s}", .{arg});945 i += 1;
969 };946 target_arch_os_abi = args[i];
970 } else if (mem.eql(u8, arg, "-mcpu")) {947 } else if (mem.eql(u8, arg, "-mcpu")) {
971 target_mcpu = args_iter.next() orelse {948 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
972 fatal("expected parameter after {s}", .{arg});949 i += 1;
973 };950 target_mcpu = args[i];
974 } else if (mem.eql(u8, arg, "-mcmodel")) {951 } else if (mem.eql(u8, arg, "-mcmodel")) {
975 machine_code_model = parseCodeModel(args_iter.next() orelse {952 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
976 fatal("expected parameter after {s}", .{arg});953 i += 1;
977 });954 machine_code_model = parseCodeModel(args[i]);
978 } else if (mem.startsWith(u8, arg, "-ofmt=")) {955 } else if (mem.startsWith(u8, arg, "-ofmt=")) {
979 target_ofmt = arg["-ofmt=".len..];956 target_ofmt = arg["-ofmt=".len..];
980 } else if (mem.startsWith(u8, arg, "-mcpu=")) {957 } else if (mem.startsWith(u8, arg, "-mcpu=")) {
...@@ -984,51 +961,50 @@ fn buildOutputType(...@@ -984,51 +961,50 @@ fn buildOutputType(
984 } else if (mem.startsWith(u8, arg, "-O")) {961 } else if (mem.startsWith(u8, arg, "-O")) {
985 optimize_mode_string = arg["-O".len..];962 optimize_mode_string = arg["-O".len..];
986 } else if (mem.eql(u8, arg, "--dynamic-linker")) {963 } else if (mem.eql(u8, arg, "--dynamic-linker")) {
987 target_dynamic_linker = args_iter.next() orelse {964 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
988 fatal("expected parameter after {s}", .{arg});965 i += 1;
989 };966 target_dynamic_linker = args[i];
990 } else if (mem.eql(u8, arg, "--sysroot")) {967 } else if (mem.eql(u8, arg, "--sysroot")) {
991 sysroot = args_iter.next() orelse {968 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
992 fatal("expected parameter after {s}", .{arg});969 i += 1;
993 };970 sysroot = args[i];
994 try clang_argv.append("-isysroot");971 try clang_argv.append("-isysroot");
995 try clang_argv.append(sysroot.?);972 try clang_argv.append(args[i]);
996 } else if (mem.eql(u8, arg, "--libc")) {973 } else if (mem.eql(u8, arg, "--libc")) {
997 libc_paths_file = args_iter.next() orelse {974 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
998 fatal("expected parameter after {s}", .{arg});975 i += 1;
999 };976 libc_paths_file = args[i];
1000 } else if (mem.eql(u8, arg, "--test-filter")) {977 } else if (mem.eql(u8, arg, "--test-filter")) {
1001 test_filter = args_iter.next() orelse {978 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1002 fatal("expected parameter after {s}", .{arg});979 i += 1;
1003 };980 test_filter = args[i];
1004 } else if (mem.eql(u8, arg, "--test-name-prefix")) {981 } else if (mem.eql(u8, arg, "--test-name-prefix")) {
1005 test_name_prefix = args_iter.next() orelse {982 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1006 fatal("expected parameter after {s}", .{arg});983 i += 1;
1007 };984 test_name_prefix = args[i];
1008 } else if (mem.eql(u8, arg, "--test-cmd")) {985 } else if (mem.eql(u8, arg, "--test-cmd")) {
1009 try test_exec_args.append(args_iter.next() orelse {986 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1010 fatal("expected parameter after {s}", .{arg});987 i += 1;
1011 });988 try test_exec_args.append(args[i]);
1012 } else if (mem.eql(u8, arg, "--cache-dir")) {989 } else if (mem.eql(u8, arg, "--cache-dir")) {
1013 override_local_cache_dir = args_iter.next() orelse {990 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1014 fatal("expected parameter after {s}", .{arg});991 i += 1;
1015 };992 override_local_cache_dir = args[i];
1016 } else if (mem.eql(u8, arg, "--global-cache-dir")) {993 } else if (mem.eql(u8, arg, "--global-cache-dir")) {
1017 override_global_cache_dir = args_iter.next() orelse {994 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1018 fatal("expected parameter after {s}", .{arg});995 i += 1;
1019 };996 override_global_cache_dir = args[i];
1020 } else if (mem.eql(u8, arg, "--zig-lib-dir")) {997 } else if (mem.eql(u8, arg, "--zig-lib-dir")) {
1021 override_lib_dir = args_iter.next() orelse {998 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1022 fatal("expected parameter after {s}", .{arg});999 i += 1;
1023 };1000 override_lib_dir = args[i];
1024 } else if (mem.eql(u8, arg, "--debug-log")) {1001 } else if (mem.eql(u8, arg, "--debug-log")) {
1025 const next_arg = args_iter.next() orelse {1002 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1026 fatal("expected parameter after {s}", .{arg});1003 i += 1;
1027 };
1028 if (!build_options.enable_logging) {1004 if (!build_options.enable_logging) {
1029 std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{});1005 std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{});
1030 } else {1006 } else {
1031 try log_scopes.append(gpa, next_arg);1007 try log_scopes.append(gpa, args[i]);
1032 }1008 }
1033 } else if (mem.eql(u8, arg, "--debug-link-snapshot")) {1009 } else if (mem.eql(u8, arg, "--debug-link-snapshot")) {
1034 if (!build_options.enable_link_snapshots) {1010 if (!build_options.enable_link_snapshots) {
...@@ -1201,9 +1177,11 @@ fn buildOutputType(...@@ -1201,9 +1177,11 @@ fn buildOutputType(
1201 } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) {1177 } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) {
1202 linker_allow_shlib_undefined = false;1178 linker_allow_shlib_undefined = false;
1203 } else if (mem.eql(u8, arg, "-z")) {1179 } else if (mem.eql(u8, arg, "-z")) {
1204 const z_arg = args_iter.next() orelse {1180 i += 1;
1205 fatal("expected parameter after {s}", .{arg});1181 if (i >= args.len) {
1206 };1182 fatal("expected linker extension flag after '{s}'", .{arg});
1183 }
1184 const z_arg = args[i];
1207 if (mem.eql(u8, z_arg, "nodelete")) {1185 if (mem.eql(u8, z_arg, "nodelete")) {
1208 linker_z_nodelete = true;1186 linker_z_nodelete = true;
1209 } else if (mem.eql(u8, z_arg, "notext")) {1187 } else if (mem.eql(u8, z_arg, "notext")) {
...@@ -4311,17 +4289,6 @@ pub fn lldMain(...@@ -4311,17 +4289,6 @@ pub fn lldMain(
4311 return @bitCast(u8, @truncate(i8, exit_code));4289 return @bitCast(u8, @truncate(i8, exit_code));
4312}4290}
43134291
4314const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true });
4315
4316/// Initialize the arguments from a Response File. "*.rsp"
4317fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
4318 const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
4319 var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes);
4320 errdefer allocator.free(cmd_line);
4321
4322 return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
4323}
4324
4325const clang_args = @import("clang_options.zig").list;4292const clang_args = @import("clang_options.zig").list;
43264293
4327pub const ClangArgIterator = struct {4294pub const ClangArgIterator = struct {
...@@ -4411,6 +4378,17 @@ pub const ClangArgIterator = struct {...@@ -4411,6 +4378,17 @@ pub const ClangArgIterator = struct {
4411 };4378 };
4412 }4379 }
44134380
4381 const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true });
4382
4383 /// Initialize the arguments from a Response File. "*.rsp"
4384 fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
4385 const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
4386 var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes);
4387 errdefer allocator.free(cmd_line);
4388
4389 return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
4390 }
4391
4414 fn next(self: *ClangArgIterator) !void {4392 fn next(self: *ClangArgIterator) !void {
4415 assert(self.has_next);4393 assert(self.has_next);
4416 assert(self.next_index < self.argv.len);4394 assert(self.next_index < self.argv.len);