authorgravatar for lgustaf1@binghamton.eduLayne Gustafson <lgustaf1@binghamton.edu> 2020-01-08 20:27:36-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-01-19 20:53:19-05:00
logc61856ebcf54a55f1c17a5fd6a3b3300115b2c65
tree16c00869a16f4c80f697be2822bbfa80c1b04cef
parent79a2747de490ca2bb1603fd1ce55637fb5278671
signaturelock-open Commit is signed but in an unrecognized format.

Add TargetDetails abstraction

8 files changed, 223 insertions(+), 124 deletions(-)

lib/std/build.zig+17-25
......@@ -1199,8 +1199,7 @@ pub const LibExeObjStep = struct {
11991199
12001200 subsystem: ?builtin.SubSystem = null,
12011201
1202 cpu: ?[]const u8 = null,
1203 features: ?[]const u8 = null,
1202 target_details: ?std.target.TargetDetails = null,
12041203
12051204 const LinkObject = union(enum) {
12061205 StaticPath: []const u8,
......@@ -1387,21 +1386,8 @@ pub const LibExeObjStep = struct {
13871386 self.computeOutFileNames();
13881387 }
13891388
1390 pub fn setCpu(self: *LibExeObjStep, cpu: *const std.target.Cpu) void {
1391 self.cpu = cpu.name;
1392 }
1393
1394 pub fn setFeatures(self: *LibExeObjStep, features: []*const std.target.Feature) void {
1395 var features_str_buffer = std.Buffer.init(self.builder.allocator, "") catch unreachable;
1396 defer features_str_buffer.deinit();
1397
1398 for (features) |feature| {
1399 features_str_buffer.append("+") catch unreachable;
1400 features_str_buffer.append(feature.name) catch unreachable;
1401 features_str_buffer.append(",") catch unreachable;
1402 }
1403
1404 self.features = features_str_buffer.toOwnedSlice();
1389 pub fn setTargetDetails(self: *LibExeObjStep, target_details: std.target.TargetDetails) void {
1390 self.target_details = target_details;
14051391 }
14061392
14071393 pub fn setTargetGLibC(self: *LibExeObjStep, major: u32, minor: u32, patch: u32) void {
......@@ -1994,14 +1980,20 @@ pub const LibExeObjStep = struct {
19941980 },
19951981 }
19961982
1997 if (self.cpu) |cpu| {
1998 try zig_args.append("--cpu");
1999 try zig_args.append(cpu);
2000 }
2001
2002 if (self.features) |features| {
2003 try zig_args.append("--features");
2004 try zig_args.append(features);
1983 if (self.target_details) |td| {
1984 switch (td) {
1985 .cpu => |cpu| {
1986 try zig_args.append("--cpu");
1987 try zig_args.append(cpu.name);
1988 },
1989 .features => |features| {
1990 try zig_args.append("--features");
1991 for (features) |feature| {
1992 try zig_args.append(feature.name);
1993 try zig_args.append(",");
1994 }
1995 },
1996 }
20051997 }
20061998
20071999 if (self.target_glibc) |ver| {
lib/std/target.zig+6
......@@ -860,6 +860,7 @@ pub const x86 = @import("target/x86.zig");
860860
861861pub const Feature = struct {
862862 name: []const u8,
863 llvm_name: []const u8,
863864 description: []const u8,
864865
865866 dependencies: []*const Feature,
......@@ -872,6 +873,11 @@ pub const Cpu = struct {
872873 dependencies: []*const Feature,
873874};
874875
876pub const TargetDetails = union(enum) {
877 cpu: *const Cpu,
878 features: []*const Feature,
879};
880
875881pub fn getFeaturesForArch(arch: @TagType(Target.Arch)) []*const Feature {
876882 return switch (arch) {
877883 .arm, .armeb, .thumb, .thumbeb => arm.features,
src-self-hosted/stage1.zig+137-78
......@@ -530,13 +530,13 @@ export fn stage2_progress_update_node(node: *std.Progress.Node, done_count: usiz
530530}
531531
532532// ABI warning
533export fn stage2_list_features_for_arch(arch_name_ptr: [*]const u8, arch_name_len: usize, show_subfeatures: bool) void {
534 printFeaturesForArch(arch_name_ptr[0..arch_name_len], show_subfeatures) catch |err| {
533export fn stage2_list_features_for_arch(arch_name_ptr: [*]const u8, arch_name_len: usize, show_dependencies: bool) void {
534 printFeaturesForArch(arch_name_ptr[0..arch_name_len], show_dependencies) catch |err| {
535535 std.debug.warn("Failed to list features: {}\n", .{ @errorName(err) });
536536 };
537537}
538538
539fn printFeaturesForArch(arch_name: []const u8, show_subfeatures: bool) !void {
539fn printFeaturesForArch(arch_name: []const u8, show_dependencies: bool) !void {
540540 const stdout_stream = &std.io.getStdOut().outStream().stream;
541541
542542 const arch = Target.parseArchTag(arch_name) catch {
......@@ -565,22 +565,22 @@ fn printFeaturesForArch(arch_name: []const u8, show_subfeatures: bool) !void {
565565
566566 try stdout_stream.print(" - {}\n", .{ feature.description });
567567
568 if (show_subfeatures and feature.subfeatures.len > 0) {
569 for (feature.subfeatures) |subfeature| {
570 try stdout_stream.print(" {}\n", .{ subfeature.name });
568 if (show_dependencies and feature.dependencies.len > 0) {
569 for (feature.dependencies) |dependency| {
570 try stdout_stream.print(" {}\n", .{ dependency.name });
571571 }
572572 }
573573 }
574574}
575575
576576// ABI warning
577export fn stage2_list_cpus_for_arch(arch_name_ptr: [*]const u8, arch_name_len: usize, show_subfeatures: bool) void {
578 printCpusForArch(arch_name_ptr[0..arch_name_len], show_subfeatures) catch |err| {
577export fn stage2_list_cpus_for_arch(arch_name_ptr: [*]const u8, arch_name_len: usize, show_dependencies: bool) void {
578 printCpusForArch(arch_name_ptr[0..arch_name_len], show_dependencies) catch |err| {
579579 std.debug.warn("Failed to list features: {}\n", .{ @errorName(err) });
580580 };
581581}
582582
583fn printCpusForArch(arch_name: []const u8, show_subfeatures: bool) !void {
583fn printCpusForArch(arch_name: []const u8, show_dependencies: bool) !void {
584584 const stdout_stream = &std.io.getStdOut().outStream().stream;
585585
586586 const arch = Target.parseArchTag(arch_name) catch {
......@@ -609,99 +609,158 @@ fn printCpusForArch(arch_name: []const u8, show_subfeatures: bool) !void {
609609
610610 try stdout_stream.write("\n");
611611
612 if (show_subfeatures and cpu.subfeatures.len > 0) {
613 for (cpu.subfeatures) |subfeature| {
614 try stdout_stream.print(" {}\n", .{ subfeature.name });
612 if (show_dependencies and cpu.dependencies.len > 0) {
613 for (cpu.dependencies) |dependency| {
614 try stdout_stream.print(" {}\n", .{ dependency.name });
615615 }
616616 }
617617 }
618618}
619619
620// use target_arch_name(ZigLLVM_ArchType) to get name from main.cpp 'target'.
620const Stage2TargetDetails = struct {
621 allocator: *std.mem.Allocator,
622 target_details: std.target.TargetDetails,
623
624 llvm_cpu_str: [:0]const u8,
625 llvm_features_str: [:0]const u8,
626};
627
621628// ABI warning
622export fn stage2_validate_cpu_and_features(
623 arch_name: [*:0]const u8,
624 cpu: ?[*:0]const u8,
625 features: ?[*:0]const u8,
626) bool {
627 const arch = Target.parseArchTag(std.mem.toSliceConst(u8, arch_name)) catch {
628 std.debug.warn("Failed to parse arch '{}'\nInvoke 'zig targets' for a list of valid architectures\n", .{ arch_name });
629 return false;
629export fn stage2_target_details_parse_cpu(arch_str: ?[*:0]const u8, cpu_str: ?[*:0]const u8) ?*Stage2TargetDetails {
630 if (cpu_str == null) return null;
631 if (arch_str == null) return null;
632
633 const arch = Target.parseArchTag(std.mem.toSliceConst(u8, arch_str.?)) catch {
634 return null;
635 };
636 return parseCpu(arch, std.mem.toSliceConst(u8, cpu_str.?)) catch |err| {
637 switch (err) {
638 error.OutOfMemory => @panic("out of memory"),
639 else => return null,
640 }
641 };
642}
643
644// ABI warning
645export fn stage2_target_details_parse_features(arch_str: ?[*:0]const u8, features_str: ?[*:0]const u8) ?*Stage2TargetDetails {
646 if (features_str == null) return null;
647 if (arch_str == null) return null;
648
649 const arch = Target.parseArchTag(std.mem.toSliceConst(u8, arch_str.?)) catch return null;
650 return parseFeatures(arch, std.mem.toSliceConst(u8, features_str.?)) catch |err| {
651 switch (err) {
652 error.OutOfMemory => @panic("out of memory"),
653 else => return null,
654 }
630655 };
656}
631657
632 const res = validateCpuAndFeatures(
633 arch,
634 if (cpu) |def_cpu| std.mem.toSliceConst(u8, def_cpu) else "",
635 if (features) |def_features| std.mem.toSliceConst(u8, def_features) else "");
658fn parseCpu(arch: @TagType(std.Target.Arch), str: []const u8) !*Stage2TargetDetails {
659 const cpus = std.target.getCpusForArch(arch);
636660
637 switch (res) {
638 .Ok => return true,
639 .InvalidCpu => |invalid_cpu| {
640 std.debug.warn("Invalid CPU '{}'\n", .{ invalid_cpu });
641 return false;
642 },
643 .InvalidFeaturesString => {
644 std.debug.warn("Invalid features string\n", .{});
645 std.debug.warn("Must have format \"+yes_feature,-no_feature\"\n", .{});
646 return false;
647 },
648 .InvalidFeature => |invalid_feature| {
649 std.debug.warn("Invalid feature '{}'\n", .{ invalid_feature });
650 return false;
661 for (cpus) |cpu| {
662 if (std.mem.eql(u8, str, cpu.name)) {
663 const allocator = std.heap.c_allocator;
664
665 const ptr = try allocator.create(Stage2TargetDetails);
666 ptr.* = .{
667 .allocator = allocator,
668 .target_details = .{
669 .cpu = cpu,
670 },
671 .llvm_cpu_str = cpu.name,
672 .llvm_features_str = "",
673 };
674
675 return ptr;
651676 }
652677 }
653}
654678
655const ValidateCpuAndFeaturesResult = union(enum) {
656 Ok,
657 InvalidCpu: []const u8,
658 InvalidFeaturesString,
659 InvalidFeature: []const u8,
660};
679 return error.InvalidCpu;
680}
661681
662fn validateCpuAndFeatures(arch: @TagType(std.Target.Arch), cpu: []const u8, features: []const u8) ValidateCpuAndFeaturesResult {
682fn parseFeatures(arch: @TagType(std.Target.Arch), str: []const u8) !*Stage2TargetDetails {
683 const allocator = std.heap.c_allocator;
663684
664 const known_cpus = std.target.getCpusForArch(arch);
665685 const known_features = std.target.getFeaturesForArch(arch);
666
667 if (cpu.len > 0) {
668 var found_cpu = false;
669 for (known_cpus) |known_cpu| {
670 if (std.mem.eql(u8, cpu, known_cpu.name)) {
671 found_cpu = true;
686
687 var features = std.ArrayList(*const std.target.Feature).init(allocator);
688 defer features.deinit();
689
690 var start: usize = 0;
691 while (start < str.len) {
692 const next_comma_pos = std.mem.indexOfScalar(u8, str[start..], ',') orelse str.len - start;
693 const feature_str = std.mem.trim(u8, str[start..start+next_comma_pos], " ");
694
695 start += next_comma_pos + 1;
696
697 if (feature_str.len == 0) continue;
698
699 var feature: ?*const std.target.Feature = null;
700 for (known_features) |known_feature| {
701 if (std.mem.eql(u8, feature_str, known_feature.name)) {
702 feature = known_feature;
672703 break;
673704 }
674705 }
675706
676 if (!found_cpu) {
677 return .{ .InvalidCpu = cpu };
707 if (feature) |f| {
708 features.append(f) catch @panic("out of memory");
709 } else {
710 return error.InvalidFeature;
678711 }
679712 }
713
714 const features_slice = features.toOwnedSlice();
680715
681 if (features.len > 0) {
682 var start: usize = 0;
683 while (start < features.len) {
684 const next_comma_pos = std.mem.indexOfScalar(u8, features[start..], ',') orelse features.len - start;
685 var feature = features[start..start+next_comma_pos];
686
687 if (feature.len < 2) return .{ .InvalidFeaturesString = {} };
688
689 if (feature[0] != '+' and feature[0] != '-') return .{ .InvalidFeaturesString = {} };
690 feature = feature[1..];
691
692 var found_feature = false;
693 for (known_features) |known_feature| {
694 if (std.mem.eql(u8, feature, known_feature.name)) {
695 found_feature = true;
696 break;
697 }
698 }
716 var llvm_features_buffer = try std.Buffer.initSize(allocator, 0);
717 defer llvm_features_buffer.deinit();
699718
700 if (!found_feature) return .{ .InvalidFeature = feature };
719 for (features_slice) |feature| {
720 try llvm_features_buffer.append("+");
721 try llvm_features_buffer.append(feature.llvm_name);
722 try llvm_features_buffer.append(",");
723 }
701724
702 start += next_comma_pos + 1;
703 }
725 const ptr = try allocator.create(Stage2TargetDetails);
726 ptr.* = Stage2TargetDetails{
727 .allocator = allocator,
728 .target_details = std.target.TargetDetails{
729 .features = features_slice,
730 },
731 .llvm_cpu_str = "",
732 .llvm_features_str = llvm_features_buffer.toOwnedSlice(),
733 };
734
735 return ptr;
736}
737
738// ABI warning
739export fn stage2_target_details_get_cache_str(target_details: ?*const Stage2TargetDetails) [*:0]const u8 {
740 if (target_details) |td| {
741 return @as([*:0]const u8, switch (td.target_details) {
742 .cpu => td.llvm_cpu_str,
743 .features => td.llvm_features_str,
744 });
745 }
746
747 return @as([*:0]const u8, "");
748}
749
750// ABI warning
751export fn stage2_target_details_get_llvm_cpu(target_details: ?*const Stage2TargetDetails) [*:0]const u8 {
752 if (target_details) |td| {
753 return @as([*:0]const u8, td.llvm_cpu_str);
754 }
755
756 return @as([*:0]const u8, "");
757}
758
759// ABI warning
760export fn stage2_target_details_get_llvm_features(target_details: ?*const Stage2TargetDetails) [*:0]const u8 {
761 if (target_details) |td| {
762 return @as([*:0]const u8, td.llvm_features_str);
704763 }
705764
706 return .{ .Ok = {} };
765 return @as([*:0]const u8, "");
707766}
src/all_types.hpp+1-2
......@@ -2216,8 +2216,7 @@ struct CodeGen {
22162216 const char **clang_argv;
22172217 size_t clang_argv_len;
22182218
2219 const char *llvm_cpu;
2220 const char *llvm_features;
2219 Stage2TargetDetails *target_details;
22212220};
22222221
22232222struct ZigVar {
src/codegen.cpp+12-11
......@@ -8655,8 +8655,10 @@ static Error define_builtin_compile_vars(CodeGen *g) {
86558655 cache_bool(&cache_hash, g->valgrind_support);
86568656 cache_bool(&cache_hash, g->link_eh_frame_hdr);
86578657 cache_int(&cache_hash, detect_subsystem(g));
8658 if (g->llvm_cpu) cache_str(&cache_hash, g->llvm_cpu);
8659 if (g->llvm_features) cache_str(&cache_hash, g->llvm_features);
8658
8659 if (g->target_details) {
8660 cache_str(&cache_hash, stage2_target_details_get_cache_str(g->target_details));
8661 }
86608662
86618663 Buf digest = BUF_INIT;
86628664 buf_resize(&digest, 0);
......@@ -8802,15 +8804,12 @@ static void init(CodeGen *g) {
88028804 target_specific_features = "";
88038805 }
88048806
8805 // Override CPU and features if non-null.
8806 if (g->llvm_cpu != nullptr) {
8807 target_specific_cpu_args = g->llvm_cpu;
8807 // Override CPU and features if defined by user.
8808 if (g->target_details) {
8809 target_specific_cpu_args = stage2_target_details_get_llvm_cpu(g->target_details);
8810 target_specific_features = stage2_target_details_get_llvm_features(g->target_details);
88088811 }
88098812
8810 if (g->llvm_features != nullptr) {
8811 target_specific_features = g->llvm_features;
8812 }
8813
88148813 g->target_machine = ZigLLVMCreateTargetMachine(target_ref, buf_ptr(&g->llvm_triple_str),
88158814 target_specific_cpu_args, target_specific_features, opt_level, reloc_mode,
88168815 LLVMCodeModelDefault, g->function_sections);
......@@ -10390,8 +10389,10 @@ static Error check_cache(CodeGen *g, Buf *manifest_dir, Buf *digest) {
1039010389 }
1039110390 cache_buf_opt(ch, g->dynamic_linker_path);
1039210391 cache_buf_opt(ch, g->version_script_path);
10393 if (g->llvm_cpu) cache_str(ch, g->llvm_cpu);
10394 if (g->llvm_features) cache_str(ch, g->llvm_features);
10392
10393 if (g->target_details) {
10394 cache_str(ch, stage2_target_details_get_cache_str(g->target_details));
10395 }
1039510396
1039610397 // gen_c_objects appends objects to g->link_objects which we want to include in the hash
1039710398 gen_c_objects(g);
src/main.cpp+19-6
......@@ -535,8 +535,8 @@ int main(int argc, char **argv) {
535535 WantStackCheck want_stack_check = WantStackCheckAuto;
536536 WantCSanitize want_sanitize_c = WantCSanitizeAuto;
537537 bool function_sections = false;
538 const char *cpu = "";
539 const char *features = "";
538 const char *cpu = nullptr;
539 const char *features = nullptr;
540540
541541 const char *targets_list_features_arch = nullptr;
542542 const char *targets_list_cpus_arch = nullptr;
......@@ -1278,12 +1278,25 @@ int main(int argc, char **argv) {
12781278 codegen_add_rpath(g, rpath_list.at(i));
12791279 }
12801280
1281 if (!stage2_validate_cpu_and_features(target_arch_name(target.arch), cpu, features)) {
1282 return 1;
1281 Stage2TargetDetails *target_details = nullptr;
1282 if (cpu && features) {
1283 fprintf(stderr, "--cpu and --features options not allowed together\n");
1284 return main_exit(root_progress_node, EXIT_FAILURE);
1285 } else if (cpu) {
1286 target_details = stage2_target_details_parse_cpu(target_arch_name(target.arch), cpu);
1287 if (!target_details) {
1288 fprintf(stderr, "invalid --cpu value\n");
1289 return main_exit(root_progress_node, EXIT_FAILURE);
1290 }
1291 } else if (features) {
1292 target_details = stage2_target_details_parse_features(target_arch_name(target.arch), features);
1293 if (!target_details) {
1294 fprintf(stderr, "invalid --features value\n");
1295 return main_exit(root_progress_node, EXIT_FAILURE);
1296 }
12831297 }
12841298
1285 g->llvm_cpu = cpu;
1286 g->llvm_features = features;
1299 g->target_details = target_details;
12871300
12881301 codegen_set_rdynamic(g, rdynamic);
12891302 if (mmacosx_version_min && mios_version_min) {
src/userland.cpp+15-1
......@@ -91,4 +91,18 @@ void stage2_progress_update_node(Stage2ProgressNode *node, size_t completed_coun
9191
9292void stage2_list_features_for_arch(const char *arch_name_ptr, size_t arch_name_len, bool show_subfeatures) {}
9393void stage2_list_cpus_for_arch(const char *arch_name_ptr, size_t arch_name_len, bool show_subfeatures) {}
94bool stage2_validate_cpu_and_features(const char *arch_name, const char *cpu, const char *features) { return true; }
94Stage2TargetDetails *stage2_target_details_parse_cpu(const char *arch, const char *str) {
95 return nullptr;
96}
97Stage2TargetDetails *stage2_target_details_parse_features(const char *arch, const char *str) {
98 return nullptr;
99}
100const char *stage2_target_details_get_cache_str(const Stage2TargetDetails *target_details) {
101 return "";
102}
103const char *stage2_target_details_get_llvm_cpu(const Stage2TargetDetails *target_details) {
104 return "";
105}
106const char *stage2_target_details_get_llvm_features(const Stage2TargetDetails *target_details) {
107 return "";
108}
src/userland.h+16-1
......@@ -181,6 +181,21 @@ ZIG_EXTERN_C void stage2_list_features_for_arch(const char *arch_name_ptr, size_
181181ZIG_EXTERN_C void stage2_list_cpus_for_arch(const char *arch_name_ptr, size_t arch_name_len, bool show_subfeatures);
182182
183183// ABI warning
184ZIG_EXTERN_C bool stage2_validate_cpu_and_features(const char *arch_name, const char *cpu, const char *features);
184struct Stage2TargetDetails;
185
186// ABI warning
187ZIG_EXTERN_C Stage2TargetDetails *stage2_target_details_parse_cpu(const char *arch, const char *str);
188
189// ABI warning
190ZIG_EXTERN_C Stage2TargetDetails *stage2_target_details_parse_features(const char *arch, const char *str);
191
192// ABI warning
193ZIG_EXTERN_C const char *stage2_target_details_get_cache_str(const Stage2TargetDetails *target_details);
194
195// ABI warning
196ZIG_EXTERN_C const char *stage2_target_details_get_llvm_cpu(const Stage2TargetDetails *target_details);
197
198// ABI warning
199ZIG_EXTERN_C const char *stage2_target_details_get_llvm_features(const Stage2TargetDetails *target_details);
185200
186201#endif