zig

blob bd24ffb3 (45226B) - Raw

---

 // This is Zig code that is used by both stage1 and stage2.
 // The prototypes in src/userland.h must match these definitions.
 
 const std = @import("std");
 const io = std.io;
 const mem = std.mem;
 const fs = std.fs;
 const process = std.process;
 const Allocator = mem.Allocator;
 const ArrayList = std.ArrayList;
 const ArrayListSentineled = std.ArrayListSentineled;
 const Target = std.Target;
 const CrossTarget = std.zig.CrossTarget;
 const self_hosted_main = @import("main.zig");
 const DepTokenizer = @import("dep_tokenizer.zig").Tokenizer;
 const assert = std.debug.assert;
 const LibCInstallation = @import("libc_installation.zig").LibCInstallation;
 
 var stderr_file: fs.File = undefined;
 var stderr: fs.File.OutStream = undefined;
 var stdout: fs.File.OutStream = undefined;
 
 comptime {
     _ = @import("dep_tokenizer.zig");
 }
 
 // ABI warning
 export fn stage2_zen(ptr: *[*]const u8, len: *usize) void {
     const info_zen = @import("main.zig").info_zen;
     ptr.* = info_zen;
     len.* = info_zen.len;
 }
 
 // ABI warning
 export fn stage2_panic(ptr: [*]const u8, len: usize) void {
     @panic(ptr[0..len]);
 }
 
 // ABI warning
 const Error = extern enum {
     None,
     OutOfMemory,
     InvalidFormat,
     SemanticAnalyzeFail,
     AccessDenied,
     Interrupted,
     SystemResources,
     FileNotFound,
     FileSystem,
     FileTooBig,
     DivByZero,
     Overflow,
     PathAlreadyExists,
     Unexpected,
     ExactDivRemainder,
     NegativeDenominator,
     ShiftedOutOneBits,
     CCompileErrors,
     EndOfFile,
     IsDir,
     NotDir,
     UnsupportedOperatingSystem,
     SharingViolation,
     PipeBusy,
     PrimitiveTypeNotFound,
     CacheUnavailable,
     PathTooLong,
     CCompilerCannotFindFile,
     NoCCompilerInstalled,
     ReadingDepFile,
     InvalidDepFile,
     MissingArchitecture,
     MissingOperatingSystem,
     UnknownArchitecture,
     UnknownOperatingSystem,
     UnknownABI,
     InvalidFilename,
     DiskQuota,
     DiskSpace,
     UnexpectedWriteFailure,
     UnexpectedSeekFailure,
     UnexpectedFileTruncationFailure,
     Unimplemented,
     OperationAborted,
     BrokenPipe,
     NoSpaceLeft,
     NotLazy,
     IsAsync,
     ImportOutsidePkgPath,
     UnknownCpuModel,
     UnknownCpuFeature,
     InvalidCpuFeatures,
     InvalidLlvmCpuFeaturesFormat,
     UnknownApplicationBinaryInterface,
     ASTUnitFailure,
     BadPathName,
     SymLinkLoop,
     ProcessFdQuotaExceeded,
     SystemFdQuotaExceeded,
     NoDevice,
     DeviceBusy,
     UnableToSpawnCCompiler,
     CCompilerExitCode,
     CCompilerCrashed,
     CCompilerCannotFindHeaders,
     LibCRuntimeNotFound,
     LibCStdLibHeaderNotFound,
     LibCKernel32LibNotFound,
     UnsupportedArchitecture,
     WindowsSdkNotFound,
     UnknownDynamicLinkerPath,
     TargetHasNoDynamicLinker,
     InvalidAbiVersion,
     InvalidOperatingSystemVersion,
     UnknownClangOption,
     NestedResponseFile,
     ZigIsTheCCompiler,
     FileBusy,
     Locked,
 };
 
 const FILE = std.c.FILE;
 const ast = std.zig.ast;
 const translate_c = @import("translate_c.zig");
 
 /// Args should have a null terminating last arg.
 export fn stage2_translate_c(
     out_ast: **ast.Tree,
     out_errors_ptr: *[*]translate_c.ClangErrMsg,
     out_errors_len: *usize,
     args_begin: [*]?[*]const u8,
     args_end: [*]?[*]const u8,
     resources_path: [*:0]const u8,
 ) Error {
     var errors: []translate_c.ClangErrMsg = &[0]translate_c.ClangErrMsg{};
     out_ast.* = translate_c.translate(std.heap.c_allocator, args_begin, args_end, &errors, resources_path) catch |err| switch (err) {
         error.SemanticAnalyzeFail => {
             out_errors_ptr.* = errors.ptr;
             out_errors_len.* = errors.len;
             return .CCompileErrors;
         },
         error.ASTUnitFailure => return .ASTUnitFailure,
         error.OutOfMemory => return .OutOfMemory,
     };
     return .None;
 }
 
 export fn stage2_free_clang_errors(errors_ptr: [*]translate_c.ClangErrMsg, errors_len: usize) void {
     translate_c.freeErrors(errors_ptr[0..errors_len]);
 }
 
 export fn stage2_render_ast(tree: *ast.Tree, output_file: *FILE) Error {
     const c_out_stream = std.io.cOutStream(output_file);
     _ = std.zig.render(std.heap.c_allocator, c_out_stream, tree) catch |e| switch (e) {
         error.WouldBlock => unreachable, // stage1 opens stuff in exclusively blocking mode
         error.SystemResources => return .SystemResources,
         error.OperationAborted => return .OperationAborted,
         error.BrokenPipe => return .BrokenPipe,
         error.DiskQuota => return .DiskQuota,
         error.FileTooBig => return .FileTooBig,
         error.NoSpaceLeft => return .NoSpaceLeft,
         error.AccessDenied => return .AccessDenied,
         error.OutOfMemory => return .OutOfMemory,
         error.Unexpected => return .Unexpected,
         error.InputOutput => return .FileSystem,
     };
     return .None;
 }
 
 export fn stage2_fmt(argc: c_int, argv: [*]const [*:0]const u8) c_int {
     if (std.debug.runtime_safety) {
         fmtMain(argc, argv) catch unreachable;
     } else {
         fmtMain(argc, argv) catch |e| {
             std.debug.warn("{}\n", .{@errorName(e)});
             return -1;
         };
     }
     return 0;
 }
 
 fn fmtMain(argc: c_int, argv: [*]const [*:0]const u8) !void {
     const allocator = std.heap.c_allocator;
     var args_list = std.ArrayList([]const u8).init(allocator);
     const argc_usize = @intCast(usize, argc);
     var arg_i: usize = 0;
     while (arg_i < argc_usize) : (arg_i += 1) {
         try args_list.append(mem.spanZ(argv[arg_i]));
     }
 
     const args = args_list.span()[2..];
 
     return self_hosted_main.cmdFmt(allocator, args);
 }
 
 export fn stage2_DepTokenizer_init(input: [*]const u8, len: usize) stage2_DepTokenizer {
     const t = std.heap.c_allocator.create(DepTokenizer) catch @panic("failed to create .d tokenizer");
     t.* = DepTokenizer.init(std.heap.c_allocator, input[0..len]);
     return stage2_DepTokenizer{
         .handle = t,
     };
 }
 
 export fn stage2_DepTokenizer_deinit(self: *stage2_DepTokenizer) void {
     self.handle.deinit();
 }
 
 export fn stage2_DepTokenizer_next(self: *stage2_DepTokenizer) stage2_DepNextResult {
     const otoken = self.handle.next() catch {
         const textz = std.ArrayListSentineled(u8, 0).init(&self.handle.arena.allocator, self.handle.error_text) catch @panic("failed to create .d tokenizer error text");
         return stage2_DepNextResult{
             .type_id = .error_,
             .textz = textz.span().ptr,
         };
     };
     const token = otoken orelse {
         return stage2_DepNextResult{
             .type_id = .null_,
             .textz = undefined,
         };
     };
     const textz = std.ArrayListSentineled(u8, 0).init(&self.handle.arena.allocator, token.bytes) catch @panic("failed to create .d tokenizer token text");
     return stage2_DepNextResult{
         .type_id = switch (token.id) {
             .target => .target,
             .prereq => .prereq,
         },
         .textz = textz.span().ptr,
     };
 }
 
 const stage2_DepTokenizer = extern struct {
     handle: *DepTokenizer,
 };
 
 const stage2_DepNextResult = extern struct {
     type_id: TypeId,
 
     // when type_id == error --> error text
     // when type_id == null --> undefined
     // when type_id == target --> target pathname
     // when type_id == prereq --> prereq pathname
     textz: [*]const u8,
 
     const TypeId = extern enum {
         error_,
         null_,
         target,
         prereq,
     };
 };
 
 // ABI warning
 export fn stage2_attach_segfault_handler() void {
     if (std.debug.runtime_safety and std.debug.have_segfault_handling_support) {
         std.debug.attachSegfaultHandler();
     }
 }
 
 // ABI warning
 export fn stage2_progress_create() *std.Progress {
     const ptr = std.heap.c_allocator.create(std.Progress) catch @panic("out of memory");
     ptr.* = std.Progress{};
     return ptr;
 }
 
 // ABI warning
 export fn stage2_progress_destroy(progress: *std.Progress) void {
     std.heap.c_allocator.destroy(progress);
 }
 
 // ABI warning
 export fn stage2_progress_start_root(
     progress: *std.Progress,
     name_ptr: [*]const u8,
     name_len: usize,
     estimated_total_items: usize,
 ) *std.Progress.Node {
     return progress.start(
         name_ptr[0..name_len],
         if (estimated_total_items == 0) null else estimated_total_items,
     ) catch @panic("timer unsupported");
 }
 
 // ABI warning
 export fn stage2_progress_disable_tty(progress: *std.Progress) void {
     progress.terminal = null;
 }
 
 // ABI warning
 export fn stage2_progress_start(
     node: *std.Progress.Node,
     name_ptr: [*]const u8,
     name_len: usize,
     estimated_total_items: usize,
 ) *std.Progress.Node {
     const child_node = std.heap.c_allocator.create(std.Progress.Node) catch @panic("out of memory");
     child_node.* = node.start(
         name_ptr[0..name_len],
         if (estimated_total_items == 0) null else estimated_total_items,
     );
     child_node.activate();
     return child_node;
 }
 
 // ABI warning
 export fn stage2_progress_end(node: *std.Progress.Node) void {
     node.end();
     if (&node.context.root != node) {
         std.heap.c_allocator.destroy(node);
     }
 }
 
 // ABI warning
 export fn stage2_progress_complete_one(node: *std.Progress.Node) void {
     node.completeOne();
 }
 
 // ABI warning
 export fn stage2_progress_update_node(node: *std.Progress.Node, done_count: usize, total_count: usize) void {
     node.completed_items = done_count;
     node.estimated_total_items = total_count;
     node.activate();
     node.context.maybeRefresh();
 }
 
 fn detectNativeCpuWithLLVM(
     arch: Target.Cpu.Arch,
     llvm_cpu_name_z: ?[*:0]const u8,
     llvm_cpu_features_opt: ?[*:0]const u8,
 ) !Target.Cpu {
     var result = Target.Cpu.baseline(arch);
 
     if (llvm_cpu_name_z) |cpu_name_z| {
         const llvm_cpu_name = mem.spanZ(cpu_name_z);
 
         for (arch.allCpuModels()) |model| {
             const this_llvm_name = model.llvm_name orelse continue;
             if (mem.eql(u8, this_llvm_name, llvm_cpu_name)) {
                 // Here we use the non-dependencies-populated set,
                 // so that subtracting features later in this function
                 // affect the prepopulated set.
                 result = Target.Cpu{
                     .arch = arch,
                     .model = model,
                     .features = model.features,
                 };
                 break;
             }
         }
     }
 
     const all_features = arch.allFeaturesList();
 
     if (llvm_cpu_features_opt) |llvm_cpu_features| {
         var it = mem.tokenize(mem.spanZ(llvm_cpu_features), ",");
         while (it.next()) |decorated_llvm_feat| {
             var op: enum {
                 add,
                 sub,
             } = undefined;
             var llvm_feat: []const u8 = undefined;
             if (mem.startsWith(u8, decorated_llvm_feat, "+")) {
                 op = .add;
                 llvm_feat = decorated_llvm_feat[1..];
             } else if (mem.startsWith(u8, decorated_llvm_feat, "-")) {
                 op = .sub;
                 llvm_feat = decorated_llvm_feat[1..];
             } else {
                 return error.InvalidLlvmCpuFeaturesFormat;
             }
             for (all_features) |feature, index_usize| {
                 const this_llvm_name = feature.llvm_name orelse continue;
                 if (mem.eql(u8, llvm_feat, this_llvm_name)) {
                     const index = @intCast(Target.Cpu.Feature.Set.Index, index_usize);
                     switch (op) {
                         .add => result.features.addFeature(index),
                         .sub => result.features.removeFeature(index),
                     }
                     break;
                 }
             }
         }
     }
 
     result.features.populateDependencies(all_features);
     return result;
 }
 
 // ABI warning
 export fn stage2_cmd_targets(
     zig_triple: ?[*:0]const u8,
     mcpu: ?[*:0]const u8,
     dynamic_linker: ?[*:0]const u8,
 ) c_int {
     cmdTargets(zig_triple, mcpu, dynamic_linker) catch |err| {
         std.debug.warn("unable to list targets: {}\n", .{@errorName(err)});
         return -1;
     };
     return 0;
 }
 
 fn cmdTargets(
     zig_triple_oz: ?[*:0]const u8,
     mcpu_oz: ?[*:0]const u8,
     dynamic_linker_oz: ?[*:0]const u8,
 ) !void {
     const cross_target = try stage2CrossTarget(zig_triple_oz, mcpu_oz, dynamic_linker_oz);
     var dynamic_linker: ?[*:0]u8 = null;
     const target = try crossTargetToTarget(cross_target, &dynamic_linker);
     return @import("print_targets.zig").cmdTargets(
         std.heap.c_allocator,
         &[0][]u8{},
         std.io.getStdOut().outStream(),
         target,
     );
 }
 
 // ABI warning
 export fn stage2_target_parse(
     target: *Stage2Target,
     zig_triple: ?[*:0]const u8,
     mcpu: ?[*:0]const u8,
     dynamic_linker: ?[*:0]const u8,
 ) Error {
     stage2TargetParse(target, zig_triple, mcpu, dynamic_linker) catch |err| switch (err) {
         error.OutOfMemory => return .OutOfMemory,
         error.UnknownArchitecture => return .UnknownArchitecture,
         error.UnknownOperatingSystem => return .UnknownOperatingSystem,
         error.UnknownApplicationBinaryInterface => return .UnknownApplicationBinaryInterface,
         error.MissingOperatingSystem => return .MissingOperatingSystem,
         error.InvalidLlvmCpuFeaturesFormat => return .InvalidLlvmCpuFeaturesFormat,
         error.UnexpectedExtraField => return .SemanticAnalyzeFail,
         error.InvalidAbiVersion => return .InvalidAbiVersion,
         error.InvalidOperatingSystemVersion => return .InvalidOperatingSystemVersion,
         error.FileSystem => return .FileSystem,
         error.SymLinkLoop => return .SymLinkLoop,
         error.SystemResources => return .SystemResources,
         error.ProcessFdQuotaExceeded => return .ProcessFdQuotaExceeded,
         error.SystemFdQuotaExceeded => return .SystemFdQuotaExceeded,
         error.DeviceBusy => return .DeviceBusy,
     };
     return .None;
 }
 
 fn stage2CrossTarget(
     zig_triple_oz: ?[*:0]const u8,
     mcpu_oz: ?[*:0]const u8,
     dynamic_linker_oz: ?[*:0]const u8,
 ) !CrossTarget {
     const mcpu = mem.spanZ(mcpu_oz);
     const dynamic_linker = mem.spanZ(dynamic_linker_oz);
     var diags: CrossTarget.ParseOptions.Diagnostics = .{};
     const target: CrossTarget = CrossTarget.parse(.{
         .arch_os_abi = mem.spanZ(zig_triple_oz) orelse "native",
         .cpu_features = mcpu,
         .dynamic_linker = dynamic_linker,
         .diagnostics = &diags,
     }) catch |err| switch (err) {
         error.UnknownCpuModel => {
             std.debug.warn("Unknown CPU: '{}'\nAvailable CPUs for architecture '{}':\n", .{
                 diags.cpu_name.?,
                 @tagName(diags.arch.?),
             });
             for (diags.arch.?.allCpuModels()) |cpu| {
                 std.debug.warn(" {}\n", .{cpu.name});
             }
             process.exit(1);
         },
         error.UnknownCpuFeature => {
             std.debug.warn(
                 \\Unknown CPU feature: '{}'
                 \\Available CPU features for architecture '{}':
                 \\
             , .{
                 diags.unknown_feature_name,
                 @tagName(diags.arch.?),
             });
             for (diags.arch.?.allFeaturesList()) |feature| {
                 std.debug.warn(" {}: {}\n", .{ feature.name, feature.description });
             }
             process.exit(1);
         },
         else => |e| return e,
     };
 
     return target;
 }
 
 fn stage2TargetParse(
     stage1_target: *Stage2Target,
     zig_triple_oz: ?[*:0]const u8,
     mcpu_oz: ?[*:0]const u8,
     dynamic_linker_oz: ?[*:0]const u8,
 ) !void {
     const target = try stage2CrossTarget(zig_triple_oz, mcpu_oz, dynamic_linker_oz);
     try stage1_target.fromTarget(target);
 }
 
 // ABI warning
 const Stage2LibCInstallation = extern struct {
     include_dir: [*]const u8,
     include_dir_len: usize,
     sys_include_dir: [*]const u8,
     sys_include_dir_len: usize,
     crt_dir: [*]const u8,
     crt_dir_len: usize,
     msvc_lib_dir: [*]const u8,
     msvc_lib_dir_len: usize,
     kernel32_lib_dir: [*]const u8,
     kernel32_lib_dir_len: usize,
 
     fn initFromStage2(self: *Stage2LibCInstallation, libc: LibCInstallation) void {
         if (libc.include_dir) |s| {
             self.include_dir = s.ptr;
             self.include_dir_len = s.len;
         } else {
             self.include_dir = "";
             self.include_dir_len = 0;
         }
         if (libc.sys_include_dir) |s| {
             self.sys_include_dir = s.ptr;
             self.sys_include_dir_len = s.len;
         } else {
             self.sys_include_dir = "";
             self.sys_include_dir_len = 0;
         }
         if (libc.crt_dir) |s| {
             self.crt_dir = s.ptr;
             self.crt_dir_len = s.len;
         } else {
             self.crt_dir = "";
             self.crt_dir_len = 0;
         }
         if (libc.msvc_lib_dir) |s| {
             self.msvc_lib_dir = s.ptr;
             self.msvc_lib_dir_len = s.len;
         } else {
             self.msvc_lib_dir = "";
             self.msvc_lib_dir_len = 0;
         }
         if (libc.kernel32_lib_dir) |s| {
             self.kernel32_lib_dir = s.ptr;
             self.kernel32_lib_dir_len = s.len;
         } else {
             self.kernel32_lib_dir = "";
             self.kernel32_lib_dir_len = 0;
         }
     }
 
     fn toStage2(self: Stage2LibCInstallation) LibCInstallation {
         var libc: LibCInstallation = .{};
         if (self.include_dir_len != 0) {
             libc.include_dir = self.include_dir[0..self.include_dir_len];
         }
         if (self.sys_include_dir_len != 0) {
             libc.sys_include_dir = self.sys_include_dir[0..self.sys_include_dir_len];
         }
         if (self.crt_dir_len != 0) {
             libc.crt_dir = self.crt_dir[0..self.crt_dir_len];
         }
         if (self.msvc_lib_dir_len != 0) {
             libc.msvc_lib_dir = self.msvc_lib_dir[0..self.msvc_lib_dir_len];
         }
         if (self.kernel32_lib_dir_len != 0) {
             libc.kernel32_lib_dir = self.kernel32_lib_dir[0..self.kernel32_lib_dir_len];
         }
         return libc;
     }
 };
 
 // ABI warning
 export fn stage2_libc_parse(stage1_libc: *Stage2LibCInstallation, libc_file_z: [*:0]const u8) Error {
     stderr_file = std.io.getStdErr();
     stderr = stderr_file.outStream();
     const libc_file = mem.spanZ(libc_file_z);
     var libc = LibCInstallation.parse(std.heap.c_allocator, libc_file, stderr) catch |err| switch (err) {
         error.ParseError => return .SemanticAnalyzeFail,
         error.DiskQuota => return .DiskQuota,
         error.FileTooBig => return .FileTooBig,
         error.InputOutput => return .FileSystem,
         error.NoSpaceLeft => return .NoSpaceLeft,
         error.AccessDenied => return .AccessDenied,
         error.BrokenPipe => return .BrokenPipe,
         error.SystemResources => return .SystemResources,
         error.OperationAborted => return .OperationAborted,
         error.WouldBlock => unreachable,
         error.Unexpected => return .Unexpected,
         error.EndOfStream => return .EndOfFile,
         error.IsDir => return .IsDir,
         error.ConnectionResetByPeer => unreachable,
         error.ConnectionTimedOut => unreachable,
         error.OutOfMemory => return .OutOfMemory,
         error.Unseekable => unreachable,
         error.SharingViolation => return .SharingViolation,
         error.PathAlreadyExists => unreachable,
         error.FileNotFound => return .FileNotFound,
         error.PipeBusy => return .PipeBusy,
         error.NameTooLong => return .PathTooLong,
         error.InvalidUtf8 => return .BadPathName,
         error.BadPathName => return .BadPathName,
         error.SymLinkLoop => return .SymLinkLoop,
         error.ProcessFdQuotaExceeded => return .ProcessFdQuotaExceeded,
         error.SystemFdQuotaExceeded => return .SystemFdQuotaExceeded,
         error.NoDevice => return .NoDevice,
         error.NotDir => return .NotDir,
         error.DeviceBusy => return .DeviceBusy,
         error.FileLocksNotSupported => unreachable,
     };
     stage1_libc.initFromStage2(libc);
     return .None;
 }
 
 // ABI warning
 export fn stage2_libc_find_native(stage1_libc: *Stage2LibCInstallation) Error {
     var libc = LibCInstallation.findNative(.{
         .allocator = std.heap.c_allocator,
         .verbose = true,
     }) catch |err| switch (err) {
         error.OutOfMemory => return .OutOfMemory,
         error.FileSystem => return .FileSystem,
         error.UnableToSpawnCCompiler => return .UnableToSpawnCCompiler,
         error.CCompilerExitCode => return .CCompilerExitCode,
         error.CCompilerCrashed => return .CCompilerCrashed,
         error.CCompilerCannotFindHeaders => return .CCompilerCannotFindHeaders,
         error.LibCRuntimeNotFound => return .LibCRuntimeNotFound,
         error.LibCStdLibHeaderNotFound => return .LibCStdLibHeaderNotFound,
         error.LibCKernel32LibNotFound => return .LibCKernel32LibNotFound,
         error.UnsupportedArchitecture => return .UnsupportedArchitecture,
         error.WindowsSdkNotFound => return .WindowsSdkNotFound,
         error.ZigIsTheCCompiler => return .ZigIsTheCCompiler,
     };
     stage1_libc.initFromStage2(libc);
     return .None;
 }
 
 // ABI warning
 export fn stage2_libc_render(stage1_libc: *Stage2LibCInstallation, output_file: *FILE) Error {
     var libc = stage1_libc.toStage2();
     const c_out_stream = std.io.cOutStream(output_file);
     libc.render(c_out_stream) catch |err| switch (err) {
         error.WouldBlock => unreachable, // stage1 opens stuff in exclusively blocking mode
         error.SystemResources => return .SystemResources,
         error.OperationAborted => return .OperationAborted,
         error.BrokenPipe => return .BrokenPipe,
         error.DiskQuota => return .DiskQuota,
         error.FileTooBig => return .FileTooBig,
         error.NoSpaceLeft => return .NoSpaceLeft,
         error.AccessDenied => return .AccessDenied,
         error.Unexpected => return .Unexpected,
         error.InputOutput => return .FileSystem,
     };
     return .None;
 }
 
 fn enumToString(value: var, type_name: []const u8) ![]const u8 {
     switch (@typeInfo(@TypeOf(value))) {
         .Enum => |e| {
             if (e.is_exhaustive) {
                 return std.fmt.allocPrint(std.heap.c_allocator, ".{}", .{@tagName(value)});
             } else {
                 return std.fmt.allocPrint(
                     std.heap.c_allocator,
                     "@intToEnum({}, {})",
                     .{ type_name, @enumToInt(value) },
                 );
             }
         },
         else => unreachable,
     }
 }
 
 // ABI warning
 const Stage2Target = extern struct {
     arch: c_int,
     vendor: c_int,
 
     abi: c_int,
     os: c_int,
 
     is_native_os: bool,
     is_native_cpu: bool,
 
     glibc_or_darwin_version: ?*Stage2SemVer,
 
     llvm_cpu_name: ?[*:0]const u8,
     llvm_cpu_features: ?[*:0]const u8,
     cpu_builtin_str: ?[*:0]const u8,
     cache_hash: ?[*:0]const u8,
     cache_hash_len: usize,
     os_builtin_str: ?[*:0]const u8,
 
     dynamic_linker: ?[*:0]const u8,
     standard_dynamic_linker_path: ?[*:0]const u8,
 
     llvm_cpu_features_asm_ptr: [*]const [*:0]const u8,
     llvm_cpu_features_asm_len: usize,
 
     fn fromTarget(self: *Stage2Target, cross_target: CrossTarget) !void {
         const allocator = std.heap.c_allocator;
 
         var dynamic_linker: ?[*:0]u8 = null;
         const target = try crossTargetToTarget(cross_target, &dynamic_linker);
 
         var cache_hash = try std.ArrayListSentineled(u8, 0).allocPrint(allocator, "{}\n{}\n", .{
             target.cpu.model.name,
             target.cpu.features.asBytes(),
         });
         defer cache_hash.deinit();
 
         const generic_arch_name = target.cpu.arch.genericName();
         var cpu_builtin_str_buffer = try std.ArrayListSentineled(u8, 0).allocPrint(allocator,
             \\Cpu{{
             \\    .arch = .{},
             \\    .model = &Target.{}.cpu.{},
             \\    .features = Target.{}.featureSet(&[_]Target.{}.Feature{{
             \\
         , .{
             @tagName(target.cpu.arch),
             generic_arch_name,
             target.cpu.model.name,
             generic_arch_name,
             generic_arch_name,
         });
         defer cpu_builtin_str_buffer.deinit();
 
         var llvm_features_buffer = try std.ArrayListSentineled(u8, 0).initSize(allocator, 0);
         defer llvm_features_buffer.deinit();
 
         // Unfortunately we have to do the work twice, because Clang does not support
         // the same command line parameters for CPU features when assembling code as it does
         // when compiling C code.
         var asm_features_list = std.ArrayList([*:0]const u8).init(allocator);
         defer asm_features_list.deinit();
 
         for (target.cpu.arch.allFeaturesList()) |feature, index_usize| {
             const index = @intCast(Target.Cpu.Feature.Set.Index, index_usize);
             const is_enabled = target.cpu.features.isEnabled(index);
 
             if (feature.llvm_name) |llvm_name| {
                 const plus_or_minus = "-+"[@boolToInt(is_enabled)];
                 try llvm_features_buffer.append(plus_or_minus);
                 try llvm_features_buffer.appendSlice(llvm_name);
                 try llvm_features_buffer.appendSlice(",");
             }
 
             if (is_enabled) {
                 // TODO some kind of "zig identifier escape" function rather than
                 // unconditionally using @"" syntax
                 try cpu_builtin_str_buffer.appendSlice("        .@\"");
                 try cpu_builtin_str_buffer.appendSlice(feature.name);
                 try cpu_builtin_str_buffer.appendSlice("\",\n");
             }
         }
 
         switch (target.cpu.arch) {
             .riscv32, .riscv64 => {
                 if (std.Target.riscv.featureSetHas(target.cpu.features, .relax)) {
                     try asm_features_list.append("-mrelax");
                 } else {
                     try asm_features_list.append("-mno-relax");
                 }
             },
             else => {
                 // TODO
                 // Argh, why doesn't the assembler accept the list of CPU features?!
                 // I don't see a way to do this other than hard coding everything.
             },
         }
 
         try cpu_builtin_str_buffer.appendSlice(
             \\    }),
             \\};
             \\
         );
 
         assert(mem.endsWith(u8, llvm_features_buffer.span(), ","));
         llvm_features_buffer.shrink(llvm_features_buffer.len() - 1);
 
         var os_builtin_str_buffer = try std.ArrayListSentineled(u8, 0).allocPrint(allocator,
             \\Os{{
             \\    .tag = .{},
             \\    .version_range = .{{
         , .{@tagName(target.os.tag)});
         defer os_builtin_str_buffer.deinit();
 
         // We'll re-use the OS version range builtin string for the cache hash.
         const os_builtin_str_ver_start_index = os_builtin_str_buffer.len();
 
         @setEvalBranchQuota(2000);
         switch (target.os.tag) {
             .freestanding,
             .ananas,
             .cloudabi,
             .dragonfly,
             .fuchsia,
             .ios,
             .kfreebsd,
             .lv2,
             .solaris,
             .haiku,
             .minix,
             .rtems,
             .nacl,
             .cnk,
             .aix,
             .cuda,
             .nvcl,
             .amdhsa,
             .ps4,
             .elfiamcu,
             .tvos,
             .watchos,
             .mesa3d,
             .contiki,
             .amdpal,
             .hermit,
             .hurd,
             .wasi,
             .emscripten,
             .uefi,
             .other,
             => try os_builtin_str_buffer.appendSlice(" .none = {} }\n"),
 
             .freebsd,
             .macosx,
             .netbsd,
             .openbsd,
             => try os_builtin_str_buffer.outStream().print(
                 \\ .semver = .{{
                 \\        .min = .{{
                 \\            .major = {},
                 \\            .minor = {},
                 \\            .patch = {},
                 \\        }},
                 \\        .max = .{{
                 \\            .major = {},
                 \\            .minor = {},
                 \\            .patch = {},
                 \\        }},
                 \\    }}}},
                 \\
             , .{
                 target.os.version_range.semver.min.major,
                 target.os.version_range.semver.min.minor,
                 target.os.version_range.semver.min.patch,
 
                 target.os.version_range.semver.max.major,
                 target.os.version_range.semver.max.minor,
                 target.os.version_range.semver.max.patch,
             }),
 
             .linux => try os_builtin_str_buffer.outStream().print(
                 \\ .linux = .{{
                 \\        .range = .{{
                 \\            .min = .{{
                 \\                .major = {},
                 \\                .minor = {},
                 \\                .patch = {},
                 \\            }},
                 \\            .max = .{{
                 \\                .major = {},
                 \\                .minor = {},
                 \\                .patch = {},
                 \\            }},
                 \\        }},
                 \\        .glibc = .{{
                 \\            .major = {},
                 \\            .minor = {},
                 \\            .patch = {},
                 \\        }},
                 \\    }}}},
                 \\
             , .{
                 target.os.version_range.linux.range.min.major,
                 target.os.version_range.linux.range.min.minor,
                 target.os.version_range.linux.range.min.patch,
 
                 target.os.version_range.linux.range.max.major,
                 target.os.version_range.linux.range.max.minor,
                 target.os.version_range.linux.range.max.patch,
 
                 target.os.version_range.linux.glibc.major,
                 target.os.version_range.linux.glibc.minor,
                 target.os.version_range.linux.glibc.patch,
             }),
 
             .windows => try os_builtin_str_buffer.outStream().print(
                 \\ .windows = .{{
                 \\        .min = {},
                 \\        .max = {},
                 \\    }}}},
                 \\
             , .{
                 try enumToString(target.os.version_range.windows.min, "Target.Os.WindowsVersion"),
                 try enumToString(target.os.version_range.windows.max, "Target.Os.WindowsVersion"),
             }),
         }
         try os_builtin_str_buffer.appendSlice("};\n");
 
         try cache_hash.appendSlice(
             os_builtin_str_buffer.span()[os_builtin_str_ver_start_index..os_builtin_str_buffer.len()],
         );
 
         const glibc_or_darwin_version = blk: {
             if (target.isGnuLibC()) {
                 const stage1_glibc = try std.heap.c_allocator.create(Stage2SemVer);
                 const stage2_glibc = target.os.version_range.linux.glibc;
                 stage1_glibc.* = .{
                     .major = stage2_glibc.major,
                     .minor = stage2_glibc.minor,
                     .patch = stage2_glibc.patch,
                 };
                 break :blk stage1_glibc;
             } else if (target.isDarwin()) {
                 const stage1_semver = try std.heap.c_allocator.create(Stage2SemVer);
                 const stage2_semver = target.os.version_range.semver.min;
                 stage1_semver.* = .{
                     .major = stage2_semver.major,
                     .minor = stage2_semver.minor,
                     .patch = stage2_semver.patch,
                 };
                 break :blk stage1_semver;
             } else {
                 break :blk null;
             }
         };
 
         const std_dl = target.standardDynamicLinkerPath();
         const std_dl_z = if (std_dl.get()) |dl|
             (try mem.dupeZ(std.heap.c_allocator, u8, dl)).ptr
         else
             null;
 
         const cache_hash_slice = cache_hash.toOwnedSlice();
         const asm_features = asm_features_list.toOwnedSlice();
         self.* = .{
             .arch = @enumToInt(target.cpu.arch) + 1, // skip over ZigLLVM_UnknownArch
             .vendor = 0,
             .os = @enumToInt(target.os.tag),
             .abi = @enumToInt(target.abi),
             .llvm_cpu_name = if (target.cpu.model.llvm_name) |s| s.ptr else null,
             .llvm_cpu_features = llvm_features_buffer.toOwnedSlice().ptr,
             .llvm_cpu_features_asm_ptr = asm_features.ptr,
             .llvm_cpu_features_asm_len = asm_features.len,
             .cpu_builtin_str = cpu_builtin_str_buffer.toOwnedSlice().ptr,
             .os_builtin_str = os_builtin_str_buffer.toOwnedSlice().ptr,
             .cache_hash = cache_hash_slice.ptr,
             .cache_hash_len = cache_hash_slice.len,
             .is_native_os = cross_target.isNativeOs(),
             .is_native_cpu = cross_target.isNativeCpu(),
             .glibc_or_darwin_version = glibc_or_darwin_version,
             .dynamic_linker = dynamic_linker,
             .standard_dynamic_linker_path = std_dl_z,
         };
     }
 };
 
 fn enumInt(comptime Enum: type, int: c_int) Enum {
     return @intToEnum(Enum, @intCast(@TagType(Enum), int));
 }
 
 fn crossTargetToTarget(cross_target: CrossTarget, dynamic_linker_ptr: *?[*:0]u8) !Target {
     var info = try std.zig.system.NativeTargetInfo.detect(std.heap.c_allocator, cross_target);
     if (info.cpu_detection_unimplemented) {
         // TODO We want to just use detected_info.target but implementing
         // CPU model & feature detection is todo so here we rely on LLVM.
         const llvm = @import("llvm.zig");
         const llvm_cpu_name = llvm.GetHostCPUName();
         const llvm_cpu_features = llvm.GetNativeFeatures();
         const arch = std.Target.current.cpu.arch;
         info.target.cpu = try detectNativeCpuWithLLVM(arch, llvm_cpu_name, llvm_cpu_features);
         cross_target.updateCpuFeatures(&info.target.cpu.features);
         info.target.cpu.arch = cross_target.getCpuArch();
     }
     if (info.dynamic_linker.get()) |dl| {
         dynamic_linker_ptr.* = try mem.dupeZ(std.heap.c_allocator, u8, dl);
     } else {
         dynamic_linker_ptr.* = null;
     }
     return info.target;
 }
 
 // ABI warning
 const Stage2SemVer = extern struct {
     major: u32,
     minor: u32,
     patch: u32,
 };
 
 // ABI warning
 const Stage2NativePaths = extern struct {
     include_dirs_ptr: [*][*:0]u8,
     include_dirs_len: usize,
     lib_dirs_ptr: [*][*:0]u8,
     lib_dirs_len: usize,
     rpaths_ptr: [*][*:0]u8,
     rpaths_len: usize,
     warnings_ptr: [*][*:0]u8,
     warnings_len: usize,
 };
 // ABI warning
 export fn stage2_detect_native_paths(stage1_paths: *Stage2NativePaths) Error {
     stage2DetectNativePaths(stage1_paths) catch |err| switch (err) {
         error.OutOfMemory => return .OutOfMemory,
     };
     return .None;
 }
 
 fn stage2DetectNativePaths(stage1_paths: *Stage2NativePaths) !void {
     var paths = try std.zig.system.NativePaths.detect(std.heap.c_allocator);
     errdefer paths.deinit();
 
     try convertSlice(paths.include_dirs.span(), &stage1_paths.include_dirs_ptr, &stage1_paths.include_dirs_len);
     try convertSlice(paths.lib_dirs.span(), &stage1_paths.lib_dirs_ptr, &stage1_paths.lib_dirs_len);
     try convertSlice(paths.rpaths.span(), &stage1_paths.rpaths_ptr, &stage1_paths.rpaths_len);
     try convertSlice(paths.warnings.span(), &stage1_paths.warnings_ptr, &stage1_paths.warnings_len);
 }
 
 fn convertSlice(slice: [][:0]u8, ptr: *[*][*:0]u8, len: *usize) !void {
     len.* = slice.len;
     const new_slice = try std.heap.c_allocator.alloc([*:0]u8, slice.len);
     for (slice) |item, i| {
         new_slice[i] = item.ptr;
     }
     ptr.* = new_slice.ptr;
 }
 
 const clang_args = @import("clang_options.zig").list;
 
 // ABI warning
 pub const ClangArgIterator = extern struct {
     has_next: bool,
     zig_equivalent: ZigEquivalent,
     only_arg: [*:0]const u8,
     second_arg: [*:0]const u8,
     other_args_ptr: [*]const [*:0]const u8,
     other_args_len: usize,
     argv_ptr: [*]const [*:0]const u8,
     argv_len: usize,
     next_index: usize,
     root_args: ?*Args,
 
     // ABI warning
     pub const ZigEquivalent = extern enum {
         target,
         o,
         c,
         other,
         positional,
         l,
         ignore,
         driver_punt,
         pic,
         no_pic,
         nostdlib,
         nostdlib_cpp,
         shared,
         rdynamic,
         wl,
         pp_or_asm,
         optimize,
         debug,
         sanitize,
         linker_script,
         verbose_cmds,
         for_linker,
         linker_input_z,
         lib_dir,
         mcpu,
         dep_file,
         framework_dir,
         framework,
         nostdlibinc,
     };
 
     const Args = struct {
         next_index: usize,
         argv_ptr: [*]const [*:0]const u8,
         argv_len: usize,
     };
 
     pub fn init(argv: []const [*:0]const u8) ClangArgIterator {
         return .{
             .next_index = 2, // `zig cc foo` this points to `foo`
             .has_next = argv.len > 2,
             .zig_equivalent = undefined,
             .only_arg = undefined,
             .second_arg = undefined,
             .other_args_ptr = undefined,
             .other_args_len = undefined,
             .argv_ptr = argv.ptr,
             .argv_len = argv.len,
             .root_args = null,
         };
     }
 
     pub fn next(self: *ClangArgIterator) !void {
         assert(self.has_next);
         assert(self.next_index < self.argv_len);
         // In this state we know that the parameter we are looking at is a root parameter
         // rather than an argument to a parameter.
         self.other_args_ptr = self.argv_ptr + self.next_index;
         self.other_args_len = 1; // We adjust this value below when necessary.
         var arg = mem.span(self.argv_ptr[self.next_index]);
         self.incrementArgIndex();
 
         if (mem.startsWith(u8, arg, "@")) {
             if (self.root_args != null) return error.NestedResponseFile;
 
             // This is a "compiler response file". We must parse the file and treat its
             // contents as command line parameters.
             const allocator = std.heap.c_allocator;
             const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
             const resp_file_path = arg[1..];
             const resp_contents = fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes) catch |err| {
                 std.debug.warn("unable to read response file '{}': {}\n", .{ resp_file_path, @errorName(err) });
                 process.exit(1);
             };
             defer allocator.free(resp_contents);
             // TODO is there a specification for this file format? Let's find it and make this parsing more robust
             // at the very least I'm guessing this needs to handle quotes and `#` comments.
             var it = mem.tokenize(resp_contents, " \t\r\n");
             var resp_arg_list = std.ArrayList([*:0]const u8).init(allocator);
             defer resp_arg_list.deinit();
             {
                 errdefer {
                     for (resp_arg_list.span()) |item| {
                         allocator.free(mem.span(item));
                     }
                 }
                 while (it.next()) |token| {
                     const dupe_token = try mem.dupeZ(allocator, u8, token);
                     errdefer allocator.free(dupe_token);
                     try resp_arg_list.append(dupe_token);
                 }
                 const args = try allocator.create(Args);
                 errdefer allocator.destroy(args);
                 args.* = .{
                     .next_index = self.next_index,
                     .argv_ptr = self.argv_ptr,
                     .argv_len = self.argv_len,
                 };
                 self.root_args = args;
             }
             const resp_arg_slice = resp_arg_list.toOwnedSlice();
             self.next_index = 0;
             self.argv_ptr = resp_arg_slice.ptr;
             self.argv_len = resp_arg_slice.len;
 
             if (resp_arg_slice.len == 0) {
                 self.resolveRespFileArgs();
                 return;
             }
 
             self.has_next = true;
             self.other_args_ptr = self.argv_ptr + self.next_index;
             self.other_args_len = 1; // We adjust this value below when necessary.
             arg = mem.span(self.argv_ptr[self.next_index]);
             self.incrementArgIndex();
         }
         if (!mem.startsWith(u8, arg, "-")) {
             self.zig_equivalent = .positional;
             self.only_arg = arg.ptr;
             return;
         }
 
         find_clang_arg: for (clang_args) |clang_arg| switch (clang_arg.syntax) {
             .flag => {
                 const prefix_len = clang_arg.matchEql(arg);
                 if (prefix_len > 0) {
                     self.zig_equivalent = clang_arg.zig_equivalent;
                     self.only_arg = arg.ptr + prefix_len;
 
                     break :find_clang_arg;
                 }
             },
             .joined, .comma_joined => {
                 // joined example: --target=foo
                 // comma_joined example: -Wl,-soname,libsoundio.so.2
                 const prefix_len = clang_arg.matchStartsWith(arg);
                 if (prefix_len != 0) {
                     self.zig_equivalent = clang_arg.zig_equivalent;
                     self.only_arg = arg.ptr + prefix_len; // This will skip over the "--target=" part.
 
                     break :find_clang_arg;
                 }
             },
             .joined_or_separate => {
                 // Examples: `-lfoo`, `-l foo`
                 const prefix_len = clang_arg.matchStartsWith(arg);
                 if (prefix_len == arg.len) {
                     if (self.next_index >= self.argv_len) {
                         std.debug.warn("Expected parameter after '{}'\n", .{arg});
                         process.exit(1);
                     }
                     self.only_arg = self.argv_ptr[self.next_index];
                     self.incrementArgIndex();
                     self.other_args_len += 1;
                     self.zig_equivalent = clang_arg.zig_equivalent;
 
                     break :find_clang_arg;
                 } else if (prefix_len != 0) {
                     self.zig_equivalent = clang_arg.zig_equivalent;
                     self.only_arg = arg.ptr + prefix_len;
 
                     break :find_clang_arg;
                 }
             },
             .joined_and_separate => {
                 // Example: `-Xopenmp-target=riscv64-linux-unknown foo`
                 const prefix_len = clang_arg.matchStartsWith(arg);
                 if (prefix_len != 0) {
                     self.only_arg = arg.ptr + prefix_len;
                     if (self.next_index >= self.argv_len) {
                         std.debug.warn("Expected parameter after '{}'\n", .{arg});
                         process.exit(1);
                     }
                     self.second_arg = self.argv_ptr[self.next_index];
                     self.incrementArgIndex();
                     self.other_args_len += 1;
                     self.zig_equivalent = clang_arg.zig_equivalent;
                     break :find_clang_arg;
                 }
             },
             .separate => if (clang_arg.matchEql(arg) > 0) {
                 if (self.next_index >= self.argv_len) {
                     std.debug.warn("Expected parameter after '{}'\n", .{arg});
                     process.exit(1);
                 }
                 self.only_arg = self.argv_ptr[self.next_index];
                 self.incrementArgIndex();
                 self.other_args_len += 1;
                 self.zig_equivalent = clang_arg.zig_equivalent;
                 break :find_clang_arg;
             },
             .remaining_args_joined => {
                 const prefix_len = clang_arg.matchStartsWith(arg);
                 if (prefix_len != 0) {
                     @panic("TODO");
                 }
             },
             .multi_arg => if (clang_arg.matchEql(arg) > 0) {
                 @panic("TODO");
             },
         }
         else {
             std.debug.warn("Unknown Clang option: '{}'\n", .{arg});
             process.exit(1);
         }
     }
 
     fn incrementArgIndex(self: *ClangArgIterator) void {
         self.next_index += 1;
         self.resolveRespFileArgs();
     }
 
     fn resolveRespFileArgs(self: *ClangArgIterator) void {
         const allocator = std.heap.c_allocator;
         if (self.next_index >= self.argv_len) {
             if (self.root_args) |root_args| {
                 self.next_index = root_args.next_index;
                 self.argv_ptr = root_args.argv_ptr;
                 self.argv_len = root_args.argv_len;
 
                 allocator.destroy(root_args);
                 self.root_args = null;
             }
             if (self.next_index >= self.argv_len) {
                 self.has_next = false;
             }
         }
     }
 };
 
 export fn stage2_clang_arg_iterator(
     result: *ClangArgIterator,
     argc: usize,
     argv: [*]const [*:0]const u8,
 ) void {
     result.* = ClangArgIterator.init(argv[0..argc]);
 }
 
 export fn stage2_clang_arg_next(it: *ClangArgIterator) Error {
     it.next() catch |err| switch (err) {
         error.NestedResponseFile => return .NestedResponseFile,
         error.OutOfMemory => return .OutOfMemory,
     };
     return .None;
 }