Commit 3d5ff91441040d11cca814f298231a501700da9e | zig

author	Martin Wickham <spexguy070@gmail.com> 2021-09-07 14:11:28-05:00
committer	GitHub <noreply@github.com> 2021-09-07 15:11:28-04:00
log	3d5ff91441040d11cca814f298231a501700da9e
tree	706a7c116a1be0dffa72819394e0403a5041efaa
parent	88e0f81eefc84feaba3ea3b146c92a62efeb9c3f
signature	Signed by PGP key 4AEE18F83AFDEB23

Fix libc file to check against compilation target instead of native (#9670)

2 files changed, 75 insertions(+), 42 deletions(-)

src
- libc_installation.zig
- main.zig

src/libc_installation.zig+16-10

...	@@ -41,6 +41,7 @@ pub const LibCInstallation = struct {	...	@@ -41,6 +41,7 @@ pub const LibCInstallation = struct {
41	pub fn parse(	41	pub fn parse(
42	allocator: *Allocator,	42	allocator: *Allocator,
43	libc_file: []const u8,	43	libc_file: []const u8,
		44	target: std.zig.CrossTarget,
44	) !LibCInstallation {	45	) !LibCInstallation {
45	var self: LibCInstallation = .{};	46	var self: LibCInstallation = .{};
46		47
...	@@ -96,26 +97,31 @@ pub const LibCInstallation = struct {	...	@@ -96,26 +97,31 @@ pub const LibCInstallation = struct {
96	log.err("sys_include_dir may not be empty\n", .{});	97	log.err("sys_include_dir may not be empty\n", .{});
97	return error.ParseError;	98	return error.ParseError;
98	}	99	}
99	if (self.crt_dir == null and !is_darwin) {	100
100	log.err("crt_dir may not be empty for {s}\n", .{@tagName(Target.current.os.tag)});	101	const os_tag = target.getOsTag();
		102	if (self.crt_dir == null and !target.isDarwin()) {
		103	log.err("crt_dir may not be empty for {s}\n", .{@tagName(os_tag)});
101	return error.ParseError;	104	return error.ParseError;
102	}	105	}
103	if (self.msvc_lib_dir == null and is_windows) {	106
		107	const abi = target.getAbi();
		108	if (self.msvc_lib_dir == null and target.isWindows() and abi == .msvc) {
104	log.err("msvc_lib_dir may not be empty for {s}-{s}\n", .{	109	log.err("msvc_lib_dir may not be empty for {s}-{s}\n", .{
105	@tagName(Target.current.os.tag),	110	@tagName(os_tag),
106	@tagName(Target.current.abi),	111	@tagName(abi),
107	});	112	});
108	return error.ParseError;	113	return error.ParseError;
109	}	114	}
110	if (self.kernel32_lib_dir == null and is_windows) {	115	if (self.kernel32_lib_dir == null and target.isWindows() and abi == .msvc) {
111	log.err("kernel32_lib_dir may not be empty for {s}-{s}\n", .{	116	log.err("kernel32_lib_dir may not be empty for {s}-{s}\n", .{
112	@tagName(Target.current.os.tag),	117	@tagName(os_tag),
113	@tagName(Target.current.abi),	118	@tagName(abi),
114	});	119	});
115	return error.ParseError;	120	return error.ParseError;
116	}	121	}
117	if (self.gcc_dir == null and is_haiku) {	122
118	log.err("gcc_dir may not be empty for {s}\n", .{@tagName(Target.current.os.tag)});	123	if (self.gcc_dir == null and os_tag == .haiku) {
		124	log.err("gcc_dir may not be empty for {s}\n", .{@tagName(os_tag)});
119	return error.ParseError;	125	return error.ParseError;
120	}	126	}
121		127

src/main.zig+59-32

 @@ -1593,39 +1593,11 @@ fn buildOutputType(
         }
     };
-    var diags: std.zig.CrossTarget.ParseOptions.Diagnostics = .{};
+    const cross_target = try parseCrossTargetOrReportFatalError(arena, .{
-    const cross_target = std.zig.CrossTarget.parse(.{
         .arch_os_abi = target_arch_os_abi,
         .cpu_features = target_mcpu,
         .dynamic_linker = target_dynamic_linker,
-        .diagnostics = &diags,
+    });
-    }) catch |err| switch (err) {
-        error.UnknownCpuModel => {
-            help: {
-                var help_text = std.ArrayList(u8).init(arena);
-                for (diags.arch.?.allCpuModels()) |cpu| {
-                    help_text.writer().print(" {s}\n", .{cpu.name}) catch break :help;
-                }
-                std.log.info("Available CPUs for architecture '{s}':\n{s}", .{
-                    @tagName(diags.arch.?), help_text.items,
-                });
-            }
-            fatal("Unknown CPU: '{s}'", .{diags.cpu_name.?});
-        },
-        error.UnknownCpuFeature => {
-            help: {
-                var help_text = std.ArrayList(u8).init(arena);
-                for (diags.arch.?.allFeaturesList()) |feature| {
-                    help_text.writer().print(" {s}: {s}\n", .{ feature.name, feature.description }) catch break :help;
-                }
-                std.log.info("Available CPU features for architecture '{s}':\n{s}", .{
-                    @tagName(diags.arch.?), help_text.items,
-                });
-            }
-            fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name});
-        },
-        else => |e| return e,
-    };
     const target_info = try detectNativeTargetInfo(gpa, cross_target);
 @@ -1972,7 +1944,7 @@ fn buildOutputType(
     defer if (libc_installation) |*l| l.deinit(gpa);
     if (libc_paths_file) |paths_file| {
-        libc_installation = LibCInstallation.parse(gpa, paths_file) catch |err| {
+        libc_installation = LibCInstallation.parse(gpa, paths_file, cross_target) catch |err| {
             fatal("unable to parse libc paths file at path {s}: {s}", .{ paths_file, @errorName(err) });
         };
     }
 @@ -2289,6 +2261,43 @@ fn buildOutputType(
     return cleanExit();
 }
+fn parseCrossTargetOrReportFatalError(allocator: *Allocator, opts: std.zig.CrossTarget.ParseOptions) !std.zig.CrossTarget {
+    var opts_with_diags = opts;
+    var diags: std.zig.CrossTarget.ParseOptions.Diagnostics = .{};
+    if (opts_with_diags.diagnostics == null) {
+        opts_with_diags.diagnostics = &diags;
+    }
+    return std.zig.CrossTarget.parse(opts_with_diags) catch |err| switch (err) {
+        error.UnknownCpuModel => {
+            help: {
+                var help_text = std.ArrayList(u8).init(allocator);
+                defer help_text.deinit();
+                for (diags.arch.?.allCpuModels()) |cpu| {
+                    help_text.writer().print(" {s}\n", .{cpu.name}) catch break :help;
+                }
+                std.log.info("Available CPUs for architecture '{s}':\n{s}", .{
+                    @tagName(diags.arch.?), help_text.items,
+                });
+            }
+            fatal("Unknown CPU: '{s}'", .{diags.cpu_name.?});
+        },
+        error.UnknownCpuFeature => {
+            help: {
+                var help_text = std.ArrayList(u8).init(allocator);
+                defer help_text.deinit();
+                for (diags.arch.?.allFeaturesList()) |feature| {
+                    help_text.writer().print(" {s}: {s}\n", .{ feature.name, feature.description }) catch break :help;
+                }
+                std.log.info("Available CPU features for architecture '{s}':\n{s}", .{
+                    @tagName(diags.arch.?), help_text.items,
+                });
+            }
+            fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name});
+        },
+        else => |e| return e,
+    };
+}
 fn runOrTest(
     comp: *Compilation,
     gpa: *Allocator,
 @@ -2630,10 +2639,15 @@ pub const usage_libc =
     \\
     \\    Parse a libc installation text file and validate it.
     \\
+    \\Options:
+    \\    -h, --help             Print this help and exit
+    \\    -target [name]         <arch><sub>-<os>-<abi> see the targets command
+    \\
 ;
 pub fn cmdLibC(gpa: *Allocator, args: []const []const u8) !void {
     var input_file: ?[]const u8 = null;
+    var target_arch_os_abi: []const u8 = "native";
     {
         var i: usize = 0;
         while (i < args.len) : (i += 1) {
 @@ -2643,6 +2657,10 @@ pub fn cmdLibC(gpa: *Allocator, args: []const []const u8) !void {
                     const stdout = io.getStdOut().writer();
                     try stdout.writeAll(usage_libc);
                     return cleanExit();
+                } else if (mem.eql(u8, arg, "-target")) {
+                    if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
+                    i += 1;
+                    target_arch_os_abi = args[i];
                 } else {
                     fatal("unrecognized parameter: '{s}'", .{arg});
                 }
 @@ -2653,12 +2671,21 @@ pub fn cmdLibC(gpa: *Allocator, args: []const []const u8) !void {
             }
         }
     }
+    const cross_target = try parseCrossTargetOrReportFatalError(gpa, .{
+        .arch_os_abi = target_arch_os_abi,
+    });
     if (input_file) |libc_file| {
-        var libc = LibCInstallation.parse(gpa, libc_file) catch |err| {
+        var libc = LibCInstallation.parse(gpa, libc_file, cross_target) catch |err| {
             fatal("unable to parse libc file at path {s}: {s}", .{ libc_file, @errorName(err) });
         };
         defer libc.deinit(gpa);
     } else {
+        if (!cross_target.isNative()) {
+            fatal("unable to detect libc for non-native target", .{});
+        }
         var libc = LibCInstallation.findNative(.{
             .allocator = gpa,
             .verbose = true,