authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-06 14:35:52-05:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-03-06 14:35:52-05:00
log9154a8606996ce34e5f1d805672c83e2b733f5a7
tree3ba5b928b4d7476540d408f150a69b40eaa29c63
parente535521619d474fb5d819d0e5cafa3e197bba7af
parentc3a2b51a2cdd5a64401df2ad326c20f151455f00
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11065 from hexops/sg/responsefiles-2

Do not fail to build if 'zig build-lib' etc. arguments exceed OS limits (take 2)

2 files changed, 204 insertions(+), 146 deletions(-)

lib/std/build.zig+36
......@@ -17,6 +17,7 @@ const fmt_lib = std.fmt;
1717const File = std.fs.File;
1818const CrossTarget = std.zig.CrossTarget;
1919const NativeTargetInfo = std.zig.system.NativeTargetInfo;
20const Sha256 = std.crypto.hash.sha2.Sha256;
2021
2122pub const FmtStep = @import("build/FmtStep.zig");
2223pub const TranslateCStep = @import("build/TranslateCStep.zig");
......@@ -2892,6 +2893,41 @@ pub const LibExeObjStep = struct {
28922893
28932894 try zig_args.append("--enable-cache");
28942895
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
28952931 const output_dir_nl = try builder.execFromStep(zig_args.items, &self.step);
28962932 const build_output_dir = mem.trimRight(u8, output_dir_nl, "\r\n");
28972933
src/main.zig+168-146
......@@ -767,85 +767,105 @@ fn buildOutputType(
767767 }
768768
769769 soname = .yes_default_value;
770 const args = all_args[2..];
771 var i: usize = 0;
772 args_loop: while (i < args.len) : (i += 1) {
773 const arg = args[i];
774 if (mem.startsWith(u8, arg, "-")) {
770
771 const Iterator = struct {
772 resp_file: ?ArgIteratorResponseFile = null,
773 args: []const []const u8,
774 i: usize = 0,
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, "-")) {
775797 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
776798 try io.getStdOut().writeAll(usage_build_generic);
777799 return cleanExit();
778800 } else if (mem.eql(u8, arg, "--")) {
779801 if (arg_mode == .run) {
780 // The index refers to all_args so skip `zig` `run`
781 // and `--`
782 runtime_args_start = i + 3;
802 // args_iter.i is 1, referring the next arg after "--" in ["--", ...]
803 // Add +2 to the index so it is relative to all_args
804 runtime_args_start = args_iter.i + 2;
783805 break :args_loop;
784806 } else {
785807 fatal("unexpected end-of-parameter mark: --", .{});
786808 }
787809 } else if (mem.eql(u8, arg, "--pkg-begin")) {
788 if (i + 2 >= args.len) fatal("Expected 2 arguments after {s}", .{arg});
789 i += 1;
790 const pkg_name = args[i];
791 i += 1;
792 const pkg_path = args[i];
810 const pkg_name = args_iter.next();
811 const pkg_path = args_iter.next();
812 if (pkg_name == null or pkg_path == null) fatal("Expected 2 arguments after {s}", .{arg});
793813
794814 const new_cur_pkg = Package.create(
795815 gpa,
796 fs.path.dirname(pkg_path),
797 fs.path.basename(pkg_path),
816 fs.path.dirname(pkg_path.?),
817 fs.path.basename(pkg_path.?),
798818 ) catch |err| {
799 fatal("Failed to add package at path {s}: {s}", .{ pkg_path, @errorName(err) });
819 fatal("Failed to add package at path {s}: {s}", .{ pkg_path.?, @errorName(err) });
800820 };
801 try cur_pkg.addAndAdopt(gpa, pkg_name, new_cur_pkg);
821 try cur_pkg.addAndAdopt(gpa, pkg_name.?, new_cur_pkg);
802822 cur_pkg = new_cur_pkg;
803823 } else if (mem.eql(u8, arg, "--pkg-end")) {
804824 cur_pkg = cur_pkg.parent orelse
805825 fatal("encountered --pkg-end with no matching --pkg-begin", .{});
806826 } else if (mem.eql(u8, arg, "--main-pkg-path")) {
807 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
808 i += 1;
809 main_pkg_path = args[i];
827 main_pkg_path = args_iter.next() orelse {
828 fatal("expected parameter after {s}", .{arg});
829 };
810830 } else if (mem.eql(u8, arg, "-cflags")) {
811831 extra_cflags.shrinkRetainingCapacity(0);
812832 while (true) {
813 i += 1;
814 if (i >= args.len) fatal("expected -- after -cflags", .{});
815 if (mem.eql(u8, args[i], "--")) break;
816 try extra_cflags.append(args[i]);
833 const next_arg = args_iter.next() orelse {
834 fatal("expected -- after -cflags", .{});
835 };
836 if (mem.eql(u8, next_arg, "--")) break;
837 try extra_cflags.append(next_arg);
817838 }
818839 } else if (mem.eql(u8, arg, "--color")) {
819 if (i + 1 >= args.len) {
840 const next_arg = args_iter.next() orelse {
820841 fatal("expected [auto|on|off] after --color", .{});
821 }
822 i += 1;
823 const next_arg = args[i];
842 };
824843 color = std.meta.stringToEnum(Color, next_arg) orelse {
825844 fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg});
826845 };
827846 } else if (mem.eql(u8, arg, "--subsystem")) {
828 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
829 i += 1;
830 if (mem.eql(u8, args[i], "console")) {
847 const next_arg = args_iter.next() orelse {
848 fatal("expected parameter after {s}", .{arg});
849 };
850 if (mem.eql(u8, next_arg, "console")) {
831851 subsystem = .Console;
832 } else if (mem.eql(u8, args[i], "windows")) {
852 } else if (mem.eql(u8, next_arg, "windows")) {
833853 subsystem = .Windows;
834 } else if (mem.eql(u8, args[i], "posix")) {
854 } else if (mem.eql(u8, next_arg, "posix")) {
835855 subsystem = .Posix;
836 } else if (mem.eql(u8, args[i], "native")) {
856 } else if (mem.eql(u8, next_arg, "native")) {
837857 subsystem = .Native;
838 } else if (mem.eql(u8, args[i], "efi_application")) {
858 } else if (mem.eql(u8, next_arg, "efi_application")) {
839859 subsystem = .EfiApplication;
840 } else if (mem.eql(u8, args[i], "efi_boot_service_driver")) {
860 } else if (mem.eql(u8, next_arg, "efi_boot_service_driver")) {
841861 subsystem = .EfiBootServiceDriver;
842 } else if (mem.eql(u8, args[i], "efi_rom")) {
862 } else if (mem.eql(u8, next_arg, "efi_rom")) {
843863 subsystem = .EfiRom;
844 } else if (mem.eql(u8, args[i], "efi_runtime_driver")) {
864 } else if (mem.eql(u8, next_arg, "efi_runtime_driver")) {
845865 subsystem = .EfiRuntimeDriver;
846866 } else {
847867 fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{
848 args[i],
868 next_arg,
849869 \\ console
850870 \\ windows
851871 \\ posix
......@@ -858,67 +878,71 @@ fn buildOutputType(
858878 });
859879 }
860880 } else if (mem.eql(u8, arg, "-O")) {
861 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
862 i += 1;
863 optimize_mode_string = args[i];
881 optimize_mode_string = args_iter.next() orelse {
882 fatal("expected parameter after {s}", .{arg});
883 };
864884 } else if (mem.eql(u8, arg, "--entry")) {
865 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
866 i += 1;
867 entry = args[i];
885 entry = args_iter.next() orelse {
886 fatal("expected parameter after {s}", .{arg});
887 };
868888 } else if (mem.eql(u8, arg, "--stack")) {
869 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
870 i += 1;
871 stack_size_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
889 const next_arg = args_iter.next() orelse {
890 fatal("expected parameter after {s}", .{arg});
891 };
892 stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
872893 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
873894 };
874895 } else if (mem.eql(u8, arg, "--image-base")) {
875 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
876 i += 1;
877 image_base_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
896 const next_arg = args_iter.next() orelse {
897 fatal("expected parameter after {s}", .{arg});
898 };
899 image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
878900 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
879901 };
880902 } else if (mem.eql(u8, arg, "--name")) {
881 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
882 i += 1;
883 provided_name = args[i];
903 provided_name = args_iter.next() orelse {
904 fatal("expected parameter after {s}", .{arg});
905 };
884906 } else if (mem.eql(u8, arg, "-rpath")) {
885 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
886 i += 1;
887 try rpath_list.append(args[i]);
907 try rpath_list.append(args_iter.next() orelse {
908 fatal("expected parameter after {s}", .{arg});
909 });
888910 } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) {
889 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
890 i += 1;
891 try lib_dirs.append(args[i]);
911 try lib_dirs.append(args_iter.next() orelse {
912 fatal("expected parameter after {s}", .{arg});
913 });
892914 } else if (mem.eql(u8, arg, "-F")) {
893 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
894 i += 1;
895 try framework_dirs.append(args[i]);
915 try framework_dirs.append(args_iter.next() orelse {
916 fatal("expected parameter after {s}", .{arg});
917 });
896918 } else if (mem.eql(u8, arg, "-framework")) {
897 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
898 i += 1;
899 try frameworks.append(args[i]);
919 try frameworks.append(args_iter.next() orelse {
920 fatal("expected parameter after {s}", .{arg});
921 });
900922 } else if (mem.eql(u8, arg, "-install_name")) {
901 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
902 i += 1;
903 install_name = args[i];
923 install_name = args_iter.next() orelse {
924 fatal("expected parameter after {s}", .{arg});
925 };
904926 } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) {
905 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
906 i += 1;
907 linker_script = args[i];
927 linker_script = args_iter.next() orelse {
928 fatal("expected parameter after {s}", .{arg});
929 };
908930 } else if (mem.eql(u8, arg, "--version-script")) {
909 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
910 i += 1;
911 version_script = args[i];
931 version_script = args_iter.next() orelse {
932 fatal("expected parameter after {s}", .{arg});
933 };
912934 } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) {
913 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
935 const next_arg = args_iter.next() orelse {
936 fatal("expected parameter after {s}", .{arg});
937 };
914938 // We don't know whether this library is part of libc or libc++ until
915939 // we resolve the target, so we simply append to the list for now.
916 i += 1;
917 try system_libs.put(args[i], .{ .needed = false });
940 try system_libs.put(next_arg, .{ .needed = false });
918941 } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) {
919 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
920 i += 1;
921 try system_libs.put(args[i], .{ .needed = true });
942 const next_arg = args_iter.next() orelse {
943 fatal("expected parameter after {s}", .{arg});
944 };
945 try system_libs.put(next_arg, .{ .needed = true });
922946 } else if (mem.eql(u8, arg, "-D") or
923947 mem.eql(u8, arg, "-isystem") or
924948 mem.eql(u8, arg, "-I") or
......@@ -927,31 +951,30 @@ fn buildOutputType(
927951 mem.eql(u8, arg, "-iframework") or
928952 mem.eql(u8, arg, "-iframeworkwithsysroot"))
929953 {
930 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
931 i += 1;
932954 try clang_argv.append(arg);
933 try clang_argv.append(args[i]);
955 try clang_argv.append(args_iter.next() orelse {
956 fatal("expected parameter after {s}", .{arg});
957 });
934958 } else if (mem.eql(u8, arg, "--version")) {
935 if (i + 1 >= args.len) {
936 fatal("expected parameter after --version", .{});
937 }
938 i += 1;
939 version = std.builtin.Version.parse(args[i]) catch |err| {
940 fatal("unable to parse --version '{s}': {s}", .{ args[i], @errorName(err) });
959 const next_arg = args_iter.next() orelse {
960 fatal("expected parameter after {s}", .{arg});
961 };
962 version = std.builtin.Version.parse(next_arg) catch |err| {
963 fatal("unable to parse --version '{s}': {s}", .{ next_arg, @errorName(err) });
941964 };
942965 have_version = true;
943966 } else if (mem.eql(u8, arg, "-target")) {
944 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
945 i += 1;
946 target_arch_os_abi = args[i];
967 target_arch_os_abi = args_iter.next() orelse {
968 fatal("expected parameter after {s}", .{arg});
969 };
947970 } else if (mem.eql(u8, arg, "-mcpu")) {
948 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
949 i += 1;
950 target_mcpu = args[i];
971 target_mcpu = args_iter.next() orelse {
972 fatal("expected parameter after {s}", .{arg});
973 };
951974 } else if (mem.eql(u8, arg, "-mcmodel")) {
952 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
953 i += 1;
954 machine_code_model = parseCodeModel(args[i]);
975 machine_code_model = parseCodeModel(args_iter.next() orelse {
976 fatal("expected parameter after {s}", .{arg});
977 });
955978 } else if (mem.startsWith(u8, arg, "-ofmt=")) {
956979 target_ofmt = arg["-ofmt=".len..];
957980 } else if (mem.startsWith(u8, arg, "-mcpu=")) {
......@@ -961,50 +984,51 @@ fn buildOutputType(
961984 } else if (mem.startsWith(u8, arg, "-O")) {
962985 optimize_mode_string = arg["-O".len..];
963986 } else if (mem.eql(u8, arg, "--dynamic-linker")) {
964 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
965 i += 1;
966 target_dynamic_linker = args[i];
987 target_dynamic_linker = args_iter.next() orelse {
988 fatal("expected parameter after {s}", .{arg});
989 };
967990 } else if (mem.eql(u8, arg, "--sysroot")) {
968 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
969 i += 1;
970 sysroot = args[i];
991 sysroot = args_iter.next() orelse {
992 fatal("expected parameter after {s}", .{arg});
993 };
971994 try clang_argv.append("-isysroot");
972 try clang_argv.append(args[i]);
995 try clang_argv.append(sysroot.?);
973996 } else if (mem.eql(u8, arg, "--libc")) {
974 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
975 i += 1;
976 libc_paths_file = args[i];
997 libc_paths_file = args_iter.next() orelse {
998 fatal("expected parameter after {s}", .{arg});
999 };
9771000 } else if (mem.eql(u8, arg, "--test-filter")) {
978 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
979 i += 1;
980 test_filter = args[i];
1001 test_filter = args_iter.next() orelse {
1002 fatal("expected parameter after {s}", .{arg});
1003 };
9811004 } else if (mem.eql(u8, arg, "--test-name-prefix")) {
982 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
983 i += 1;
984 test_name_prefix = args[i];
1005 test_name_prefix = args_iter.next() orelse {
1006 fatal("expected parameter after {s}", .{arg});
1007 };
9851008 } else if (mem.eql(u8, arg, "--test-cmd")) {
986 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
987 i += 1;
988 try test_exec_args.append(args[i]);
1009 try test_exec_args.append(args_iter.next() orelse {
1010 fatal("expected parameter after {s}", .{arg});
1011 });
9891012 } else if (mem.eql(u8, arg, "--cache-dir")) {
990 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
991 i += 1;
992 override_local_cache_dir = args[i];
1013 override_local_cache_dir = args_iter.next() orelse {
1014 fatal("expected parameter after {s}", .{arg});
1015 };
9931016 } else if (mem.eql(u8, arg, "--global-cache-dir")) {
994 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
995 i += 1;
996 override_global_cache_dir = args[i];
1017 override_global_cache_dir = args_iter.next() orelse {
1018 fatal("expected parameter after {s}", .{arg});
1019 };
9971020 } else if (mem.eql(u8, arg, "--zig-lib-dir")) {
998 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
999 i += 1;
1000 override_lib_dir = args[i];
1021 override_lib_dir = args_iter.next() orelse {
1022 fatal("expected parameter after {s}", .{arg});
1023 };
10011024 } else if (mem.eql(u8, arg, "--debug-log")) {
1002 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1003 i += 1;
1025 const next_arg = args_iter.next() orelse {
1026 fatal("expected parameter after {s}", .{arg});
1027 };
10041028 if (!build_options.enable_logging) {
10051029 std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{});
10061030 } else {
1007 try log_scopes.append(gpa, args[i]);
1031 try log_scopes.append(gpa, next_arg);
10081032 }
10091033 } else if (mem.eql(u8, arg, "--debug-link-snapshot")) {
10101034 if (!build_options.enable_link_snapshots) {
......@@ -1177,11 +1201,9 @@ fn buildOutputType(
11771201 } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) {
11781202 linker_allow_shlib_undefined = false;
11791203 } else if (mem.eql(u8, arg, "-z")) {
1180 i += 1;
1181 if (i >= args.len) {
1182 fatal("expected linker extension flag after '{s}'", .{arg});
1183 }
1184 const z_arg = args[i];
1204 const z_arg = args_iter.next() orelse {
1205 fatal("expected parameter after {s}", .{arg});
1206 };
11851207 if (mem.eql(u8, z_arg, "nodelete")) {
11861208 linker_z_nodelete = true;
11871209 } else if (mem.eql(u8, z_arg, "notext")) {
......@@ -4300,6 +4322,17 @@ pub fn lldMain(
43004322 return @bitCast(u8, @truncate(i8, exit_code));
43014323}
43024324
4325const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true });
4326
4327/// Initialize the arguments from a Response File. "*.rsp"
4328fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
4329 const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
4330 var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes);
4331 errdefer allocator.free(cmd_line);
4332
4333 return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
4334}
4335
43034336const clang_args = @import("clang_options.zig").list;
43044337
43054338pub const ClangArgIterator = struct {
......@@ -4391,17 +4424,6 @@ pub const ClangArgIterator = struct {
43914424 };
43924425 }
43934426
4394 const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true });
4395
4396 /// Initialize the arguments from a Response File. "*.rsp"
4397 fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
4398 const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
4399 var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes);
4400 errdefer allocator.free(cmd_line);
4401
4402 return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
4403 }
4404
44054427 fn next(self: *ClangArgIterator) !void {
44064428 assert(self.has_next);
44074429 assert(self.next_index < self.argv.len);