authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-01-21 00:34:54-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-01-21 00:34:54-05:00
loge640d015351c3d3bf7c41020ff2a87f38f853140
tree8ff75fc739c83d45573753b9d80b8f39a95cae71
parent6118b11afa1bbceab6ab4681f1f79e68aa131b65
signaturelock-open Commit is signed but in an unrecognized format.

fixups to arch data, support any number of cpu features

22 files changed, 777 insertions(+), 702 deletions(-)

lib/std/build.zig+1-1
......@@ -1983,7 +1983,7 @@ pub const LibExeObjStep = struct {
19831983
19841984 var feature_str_buffer = try std.Buffer.initSize(builder.allocator, 0);
19851985 for (self.target.getArch().allFeaturesList()) |feature, i| {
1986 if (Target.Cpu.Feature.isEnabled(features, @intCast(u7, i))) {
1986 if (features.isEnabled(@intCast(u8, i))) {
19871987 try feature_str_buffer.append(feature.name);
19881988 try feature_str_buffer.append(",");
19891989 }
lib/std/target.zig+60-31
......@@ -219,7 +219,8 @@ pub const Target = union(enum) {
219219 pub fn parseCpuFeatureSet(arch: Arch, features_text: []const u8) !Cpu.Feature.Set {
220220 // Here we compute both and choose the correct result at the end, based
221221 // on whether or not we saw + and - signs.
222 var set: @Vector(2, Cpu.Feature.Set) = [2]Cpu.Feature.Set{ 0, arch.baselineFeatures() };
222 var whitelist_set = Cpu.Feature.Set.empty();
223 var baseline_set = arch.baselineFeatures();
223224 var mode: enum {
224225 unknown,
225226 baseline,
......@@ -257,10 +258,15 @@ pub const Target = union(enum) {
257258 }
258259 for (arch.allFeaturesList()) |feature, index| {
259260 if (mem.eql(u8, feature_name, feature.name)) {
260 const one_bit = @as(Cpu.Feature.Set, 1) << @intCast(u7, index);
261261 switch (op) {
262 .add => set |= @splat(2, one_bit),
263 .sub => set &= @splat(2, ~one_bit),
262 .add => {
263 baseline_set.addFeature(@intCast(u8, index));
264 whitelist_set.addFeature(@intCast(u8, index));
265 },
266 .sub => {
267 baseline_set.removeFeature(@intCast(u8, index));
268 whitelist_set.removeFeature(@intCast(u8, index));
269 },
264270 }
265271 break;
266272 }
......@@ -270,8 +276,8 @@ pub const Target = union(enum) {
270276 }
271277
272278 return switch (mode) {
273 .unknown, .whitelist => set[0],
274 .baseline => set[1],
279 .unknown, .whitelist => whitelist_set,
280 .baseline => baseline_set,
275281 };
276282 }
277283
......@@ -413,21 +419,21 @@ pub const Target = union(enum) {
413419 /// All CPU features Zig is aware of, sorted lexicographically by name.
414420 pub fn allFeaturesList(arch: Arch) []const Cpu.Feature {
415421 return switch (arch) {
416 .arm, .armeb, .thumb, .thumbeb => arm.all_features,
422 .arm, .armeb, .thumb, .thumbeb => &arm.all_features,
417423 .aarch64, .aarch64_be, .aarch64_32 => &aarch64.all_features,
418 .avr => avr.all_features,
419 .bpfel, .bpfeb => bpf.all_features,
420 .hexagon => hexagon.all_features,
421 .mips, .mipsel, .mips64, .mips64el => mips.all_features,
422 .msp430 => msp430.all_features,
423 .powerpc, .powerpc64, .powerpc64le => powerpc.all_features,
424 .amdgcn => amdgpu.all_features,
425 .riscv32, .riscv64 => riscv.all_features,
426 .sparc, .sparcv9, .sparcel => sparc.all_features,
427 .s390x => systemz.all_features,
424 .avr => &avr.all_features,
425 .bpfel, .bpfeb => &bpf.all_features,
426 .hexagon => &hexagon.all_features,
427 .mips, .mipsel, .mips64, .mips64el => &mips.all_features,
428 .msp430 => &msp430.all_features,
429 .powerpc, .powerpc64, .powerpc64le => &powerpc.all_features,
430 .amdgcn => &amdgpu.all_features,
431 .riscv32, .riscv64 => &riscv.all_features,
432 .sparc, .sparcv9, .sparcel => &sparc.all_features,
433 .s390x => &systemz.all_features,
428434 .i386, .x86_64 => &x86.all_features,
429 .nvptx, .nvptx64 => nvptx.all_features,
430 .wasm32, .wasm64 => wasm.all_features,
435 .nvptx, .nvptx64 => &nvptx.all_features,
436 .wasm32, .wasm64 => &wasm.all_features,
431437
432438 else => &[0]Cpu.Feature{},
433439 };
......@@ -439,10 +445,11 @@ pub const Target = union(enum) {
439445 return switch (arch) {
440446 .arm, .armeb, .thumb, .thumbeb => arm.cpu.generic.features,
441447 .aarch64, .aarch64_be, .aarch64_32 => aarch64.cpu.generic.features,
442 .avr => avr.cpu.generic.features,
448 .avr => avr.baseline_features,
443449 .bpfel, .bpfeb => bpf.cpu.generic.features,
444450 .hexagon => hexagon.cpu.generic.features,
445 .mips, .mipsel, .mips64, .mips64el => mips.cpu.generic.features,
451 .mips, .mipsel => mips.cpu.mips32.features,
452 .mips64, .mips64el => mips.cpu.mips64.features,
446453 .msp430 => msp430.cpu.generic.features,
447454 .powerpc, .powerpc64, .powerpc64le => powerpc.cpu.generic.features,
448455 .amdgcn => amdgpu.cpu.generic.features,
......@@ -452,10 +459,10 @@ pub const Target = union(enum) {
452459 .s390x => systemz.cpu.generic.features,
453460 .i386 => x86.cpu.pentium4.features,
454461 .x86_64 => x86.cpu.x86_64.features,
455 .nvptx, .nvptx64 => nvptx.cpu.generic.features,
462 .nvptx, .nvptx64 => nvptx.cpu.sm_20.features,
456463 .wasm32, .wasm64 => wasm.cpu.generic.features,
457464
458 else => 0,
465 else => Cpu.Feature.Set.empty(),
459466 };
460467 }
461468
......@@ -522,24 +529,46 @@ pub const Target = union(enum) {
522529 dependencies: Set,
523530
524531 /// A bit set of all the features.
525 pub const Set = u128;
532 pub const Set = struct {
533 bytes: [bit_count / 8]u8,
526534
527 pub fn isEnabled(set: Set, arch_feature_index: u7) bool {
528 return (set & (@as(Set, 1) << arch_feature_index)) != 0;
529 }
535 pub const bit_count = 22 * 8;
536
537 pub fn empty() Set {
538 return .{ .bytes = [1]u8{0} ** 22 };
539 }
540
541 pub fn isEnabled(set: Set, arch_feature_index: u8) bool {
542 const byte_index = arch_feature_index / 8;
543 const bit_index = @intCast(u3, arch_feature_index % 8);
544 return (set.bytes[byte_index] & (@as(u8, 1) << bit_index)) != 0;
545 }
546
547 pub fn addFeature(set: *Set, arch_feature_index: u8) void {
548 const byte_index = arch_feature_index / 8;
549 const bit_index = @intCast(u3, arch_feature_index % 8);
550 set.bytes[byte_index] |= @as(u8, 1) << bit_index;
551 }
552
553 pub fn removeFeature(set: *Set, arch_feature_index: u8) void {
554 const byte_index = arch_feature_index / 8;
555 const bit_index = @intCast(u3, arch_feature_index % 8);
556 set.bytes[byte_index] &= ~(@as(u8, 1) << bit_index);
557 }
558 };
530559
531560 pub fn feature_set_fns(comptime F: type) type {
532561 return struct {
533562 pub fn featureSet(features: []const F) Set {
534 var x: Set = 0;
563 var x = Set.empty();
535564 for (features) |feature| {
536 x |= @as(Set, 1) << @enumToInt(feature);
565 x.addFeature(@enumToInt(feature));
537566 }
538567 return x;
539568 }
540569
541570 pub fn featureSetHas(set: Set, feature: F) bool {
542 return (set & (@as(Set, 1) << @enumToInt(feature))) != 0;
571 return set.isEnabled(@enumToInt(feature));
543572 }
544573 };
545574 }
......@@ -748,7 +777,7 @@ pub const Target = union(enum) {
748777 pub fn parseArchSub(text: []const u8) ParseArchSubError!Arch {
749778 const info = @typeInfo(Arch);
750779 inline for (info.Union.fields) |field| {
751 if (mem.eql(u8, text, field.name)) {
780 if (mem.startsWith(u8, text, field.name)) {
752781 if (field.field_type == void) {
753782 return @as(Arch, @field(Arch, field.name));
754783 } else {
lib/std/target/aarch64.zig+100-100
......@@ -154,7 +154,7 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
154154
155155pub const all_features = blk: {
156156 const len = @typeInfo(Feature).Enum.fields.len;
157 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
157 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
158158 var result: [len]Cpu.Feature = undefined;
159159 result[@enumToInt(Feature.a35)] = .{
160160 .index = @enumToInt(Feature.a35),
......@@ -298,140 +298,140 @@ pub const all_features = blk: {
298298 .name = @tagName(Feature.aggressive_fma),
299299 .llvm_name = "aggressive-fma",
300300 .description = "Enable Aggressive FMA for floating-point.",
301 .dependencies = 0,
301 .dependencies = featureSet(&[_]Feature{}),
302302 };
303303 result[@enumToInt(Feature.alternate_sextload_cvt_f32_pattern)] = .{
304304 .index = @enumToInt(Feature.alternate_sextload_cvt_f32_pattern),
305305 .name = @tagName(Feature.alternate_sextload_cvt_f32_pattern),
306306 .llvm_name = "alternate-sextload-cvt-f32-pattern",
307307 .description = "Use alternative pattern for sextload convert to f32",
308 .dependencies = 0,
308 .dependencies = featureSet(&[_]Feature{}),
309309 };
310310 result[@enumToInt(Feature.altnzcv)] = .{
311311 .index = @enumToInt(Feature.altnzcv),
312312 .name = @tagName(Feature.altnzcv),
313313 .llvm_name = "altnzcv",
314314 .description = "Enable alternative NZCV format for floating point comparisons",
315 .dependencies = 0,
315 .dependencies = featureSet(&[_]Feature{}),
316316 };
317317 result[@enumToInt(Feature.am)] = .{
318318 .index = @enumToInt(Feature.am),
319319 .name = @tagName(Feature.am),
320320 .llvm_name = "am",
321321 .description = "Enable v8.4-A Activity Monitors extension",
322 .dependencies = 0,
322 .dependencies = featureSet(&[_]Feature{}),
323323 };
324324 result[@enumToInt(Feature.arith_bcc_fusion)] = .{
325325 .index = @enumToInt(Feature.arith_bcc_fusion),
326326 .name = @tagName(Feature.arith_bcc_fusion),
327327 .llvm_name = "arith-bcc-fusion",
328328 .description = "CPU fuses arithmetic+bcc operations",
329 .dependencies = 0,
329 .dependencies = featureSet(&[_]Feature{}),
330330 };
331331 result[@enumToInt(Feature.arith_cbz_fusion)] = .{
332332 .index = @enumToInt(Feature.arith_cbz_fusion),
333333 .name = @tagName(Feature.arith_cbz_fusion),
334334 .llvm_name = "arith-cbz-fusion",
335335 .description = "CPU fuses arithmetic + cbz/cbnz operations",
336 .dependencies = 0,
336 .dependencies = featureSet(&[_]Feature{}),
337337 };
338338 result[@enumToInt(Feature.balance_fp_ops)] = .{
339339 .index = @enumToInt(Feature.balance_fp_ops),
340340 .name = @tagName(Feature.balance_fp_ops),
341341 .llvm_name = "balance-fp-ops",
342342 .description = "balance mix of odd and even D-registers for fp multiply(-accumulate) ops",
343 .dependencies = 0,
343 .dependencies = featureSet(&[_]Feature{}),
344344 };
345345 result[@enumToInt(Feature.bti)] = .{
346346 .index = @enumToInt(Feature.bti),
347347 .name = @tagName(Feature.bti),
348348 .llvm_name = "bti",
349349 .description = "Enable Branch Target Identification",
350 .dependencies = 0,
350 .dependencies = featureSet(&[_]Feature{}),
351351 };
352352 result[@enumToInt(Feature.call_saved_x10)] = .{
353353 .index = @enumToInt(Feature.call_saved_x10),
354354 .name = @tagName(Feature.call_saved_x10),
355355 .llvm_name = "call-saved-x10",
356356 .description = "Make X10 callee saved.",
357 .dependencies = 0,
357 .dependencies = featureSet(&[_]Feature{}),
358358 };
359359 result[@enumToInt(Feature.call_saved_x11)] = .{
360360 .index = @enumToInt(Feature.call_saved_x11),
361361 .name = @tagName(Feature.call_saved_x11),
362362 .llvm_name = "call-saved-x11",
363363 .description = "Make X11 callee saved.",
364 .dependencies = 0,
364 .dependencies = featureSet(&[_]Feature{}),
365365 };
366366 result[@enumToInt(Feature.call_saved_x12)] = .{
367367 .index = @enumToInt(Feature.call_saved_x12),
368368 .name = @tagName(Feature.call_saved_x12),
369369 .llvm_name = "call-saved-x12",
370370 .description = "Make X12 callee saved.",
371 .dependencies = 0,
371 .dependencies = featureSet(&[_]Feature{}),
372372 };
373373 result[@enumToInt(Feature.call_saved_x13)] = .{
374374 .index = @enumToInt(Feature.call_saved_x13),
375375 .name = @tagName(Feature.call_saved_x13),
376376 .llvm_name = "call-saved-x13",
377377 .description = "Make X13 callee saved.",
378 .dependencies = 0,
378 .dependencies = featureSet(&[_]Feature{}),
379379 };
380380 result[@enumToInt(Feature.call_saved_x14)] = .{
381381 .index = @enumToInt(Feature.call_saved_x14),
382382 .name = @tagName(Feature.call_saved_x14),
383383 .llvm_name = "call-saved-x14",
384384 .description = "Make X14 callee saved.",
385 .dependencies = 0,
385 .dependencies = featureSet(&[_]Feature{}),
386386 };
387387 result[@enumToInt(Feature.call_saved_x15)] = .{
388388 .index = @enumToInt(Feature.call_saved_x15),
389389 .name = @tagName(Feature.call_saved_x15),
390390 .llvm_name = "call-saved-x15",
391391 .description = "Make X15 callee saved.",
392 .dependencies = 0,
392 .dependencies = featureSet(&[_]Feature{}),
393393 };
394394 result[@enumToInt(Feature.call_saved_x18)] = .{
395395 .index = @enumToInt(Feature.call_saved_x18),
396396 .name = @tagName(Feature.call_saved_x18),
397397 .llvm_name = "call-saved-x18",
398398 .description = "Make X18 callee saved.",
399 .dependencies = 0,
399 .dependencies = featureSet(&[_]Feature{}),
400400 };
401401 result[@enumToInt(Feature.call_saved_x8)] = .{
402402 .index = @enumToInt(Feature.call_saved_x8),
403403 .name = @tagName(Feature.call_saved_x8),
404404 .llvm_name = "call-saved-x8",
405405 .description = "Make X8 callee saved.",
406 .dependencies = 0,
406 .dependencies = featureSet(&[_]Feature{}),
407407 };
408408 result[@enumToInt(Feature.call_saved_x9)] = .{
409409 .index = @enumToInt(Feature.call_saved_x9),
410410 .name = @tagName(Feature.call_saved_x9),
411411 .llvm_name = "call-saved-x9",
412412 .description = "Make X9 callee saved.",
413 .dependencies = 0,
413 .dependencies = featureSet(&[_]Feature{}),
414414 };
415415 result[@enumToInt(Feature.ccdp)] = .{
416416 .index = @enumToInt(Feature.ccdp),
417417 .name = @tagName(Feature.ccdp),
418418 .llvm_name = "ccdp",
419419 .description = "Enable v8.5 Cache Clean to Point of Deep Persistence",
420 .dependencies = 0,
420 .dependencies = featureSet(&[_]Feature{}),
421421 };
422422 result[@enumToInt(Feature.ccidx)] = .{
423423 .index = @enumToInt(Feature.ccidx),
424424 .name = @tagName(Feature.ccidx),
425425 .llvm_name = "ccidx",
426426 .description = "Enable v8.3-A Extend of the CCSIDR number of sets",
427 .dependencies = 0,
427 .dependencies = featureSet(&[_]Feature{}),
428428 };
429429 result[@enumToInt(Feature.ccpp)] = .{
430430 .index = @enumToInt(Feature.ccpp),
431431 .name = @tagName(Feature.ccpp),
432432 .llvm_name = "ccpp",
433433 .description = "Enable v8.2 data Cache Clean to Point of Persistence",
434 .dependencies = 0,
434 .dependencies = featureSet(&[_]Feature{}),
435435 };
436436 result[@enumToInt(Feature.complxnum)] = .{
437437 .index = @enumToInt(Feature.complxnum),
......@@ -447,7 +447,7 @@ pub const all_features = blk: {
447447 .name = @tagName(Feature.crc),
448448 .llvm_name = "crc",
449449 .description = "Enable ARMv8 CRC-32 checksum instructions",
450 .dependencies = 0,
450 .dependencies = featureSet(&[_]Feature{}),
451451 };
452452 result[@enumToInt(Feature.crypto)] = .{
453453 .index = @enumToInt(Feature.crypto),
......@@ -465,7 +465,7 @@ pub const all_features = blk: {
465465 .name = @tagName(Feature.custom_cheap_as_move),
466466 .llvm_name = "custom-cheap-as-move",
467467 .description = "Use custom handling of cheap instructions",
468 .dependencies = 0,
468 .dependencies = featureSet(&[_]Feature{}),
469469 };
470470 result[@enumToInt(Feature.cyclone)] = .{
471471 .index = @enumToInt(Feature.cyclone),
......@@ -493,21 +493,21 @@ pub const all_features = blk: {
493493 .name = @tagName(Feature.disable_latency_sched_heuristic),
494494 .llvm_name = "disable-latency-sched-heuristic",
495495 .description = "Disable latency scheduling heuristic",
496 .dependencies = 0,
496 .dependencies = featureSet(&[_]Feature{}),
497497 };
498498 result[@enumToInt(Feature.dit)] = .{
499499 .index = @enumToInt(Feature.dit),
500500 .name = @tagName(Feature.dit),
501501 .llvm_name = "dit",
502502 .description = "Enable v8.4-A Data Independent Timing instructions",
503 .dependencies = 0,
503 .dependencies = featureSet(&[_]Feature{}),
504504 };
505505 result[@enumToInt(Feature.dotprod)] = .{
506506 .index = @enumToInt(Feature.dotprod),
507507 .name = @tagName(Feature.dotprod),
508508 .llvm_name = "dotprod",
509509 .description = "Enable dot product support",
510 .dependencies = 0,
510 .dependencies = featureSet(&[_]Feature{}),
511511 };
512512 result[@enumToInt(Feature.exynos_cheap_as_move)] = .{
513513 .index = @enumToInt(Feature.exynos_cheap_as_move),
......@@ -626,21 +626,21 @@ pub const all_features = blk: {
626626 .name = @tagName(Feature.fmi),
627627 .llvm_name = "fmi",
628628 .description = "Enable v8.4-A Flag Manipulation Instructions",
629 .dependencies = 0,
629 .dependencies = featureSet(&[_]Feature{}),
630630 };
631631 result[@enumToInt(Feature.force_32bit_jump_tables)] = .{
632632 .index = @enumToInt(Feature.force_32bit_jump_tables),
633633 .name = @tagName(Feature.force_32bit_jump_tables),
634634 .llvm_name = "force-32bit-jump-tables",
635635 .description = "Force jump table entries to be 32-bits wide except at MinSize",
636 .dependencies = 0,
636 .dependencies = featureSet(&[_]Feature{}),
637637 };
638638 result[@enumToInt(Feature.fp_armv8)] = .{
639639 .index = @enumToInt(Feature.fp_armv8),
640640 .name = @tagName(Feature.fp_armv8),
641641 .llvm_name = "fp-armv8",
642642 .description = "Enable ARMv8 FP",
643 .dependencies = 0,
643 .dependencies = featureSet(&[_]Feature{}),
644644 };
645645 result[@enumToInt(Feature.fp16fml)] = .{
646646 .index = @enumToInt(Feature.fp16fml),
......@@ -656,7 +656,7 @@ pub const all_features = blk: {
656656 .name = @tagName(Feature.fptoint),
657657 .llvm_name = "fptoint",
658658 .description = "Enable FRInt[32|64][Z|X] instructions that round a floating-point number to an integer (in FP format) forcing it to fit into a 32- or 64-bit int",
659 .dependencies = 0,
659 .dependencies = featureSet(&[_]Feature{}),
660660 };
661661 result[@enumToInt(Feature.fullfp16)] = .{
662662 .index = @enumToInt(Feature.fullfp16),
......@@ -672,42 +672,42 @@ pub const all_features = blk: {
672672 .name = @tagName(Feature.fuse_address),
673673 .llvm_name = "fuse-address",
674674 .description = "CPU fuses address generation and memory operations",
675 .dependencies = 0,
675 .dependencies = featureSet(&[_]Feature{}),
676676 };
677677 result[@enumToInt(Feature.fuse_aes)] = .{
678678 .index = @enumToInt(Feature.fuse_aes),
679679 .name = @tagName(Feature.fuse_aes),
680680 .llvm_name = "fuse-aes",
681681 .description = "CPU fuses AES crypto operations",
682 .dependencies = 0,
682 .dependencies = featureSet(&[_]Feature{}),
683683 };
684684 result[@enumToInt(Feature.fuse_arith_logic)] = .{
685685 .index = @enumToInt(Feature.fuse_arith_logic),
686686 .name = @tagName(Feature.fuse_arith_logic),
687687 .llvm_name = "fuse-arith-logic",
688688 .description = "CPU fuses arithmetic and logic operations",
689 .dependencies = 0,
689 .dependencies = featureSet(&[_]Feature{}),
690690 };
691691 result[@enumToInt(Feature.fuse_crypto_eor)] = .{
692692 .index = @enumToInt(Feature.fuse_crypto_eor),
693693 .name = @tagName(Feature.fuse_crypto_eor),
694694 .llvm_name = "fuse-crypto-eor",
695695 .description = "CPU fuses AES/PMULL and EOR operations",
696 .dependencies = 0,
696 .dependencies = featureSet(&[_]Feature{}),
697697 };
698698 result[@enumToInt(Feature.fuse_csel)] = .{
699699 .index = @enumToInt(Feature.fuse_csel),
700700 .name = @tagName(Feature.fuse_csel),
701701 .llvm_name = "fuse-csel",
702702 .description = "CPU fuses conditional select operations",
703 .dependencies = 0,
703 .dependencies = featureSet(&[_]Feature{}),
704704 };
705705 result[@enumToInt(Feature.fuse_literals)] = .{
706706 .index = @enumToInt(Feature.fuse_literals),
707707 .name = @tagName(Feature.fuse_literals),
708708 .llvm_name = "fuse-literals",
709709 .description = "CPU fuses literal generation operations",
710 .dependencies = 0,
710 .dependencies = featureSet(&[_]Feature{}),
711711 };
712712 result[@enumToInt(Feature.jsconv)] = .{
713713 .index = @enumToInt(Feature.jsconv),
......@@ -741,35 +741,35 @@ pub const all_features = blk: {
741741 .name = @tagName(Feature.lor),
742742 .llvm_name = "lor",
743743 .description = "Enables ARM v8.1 Limited Ordering Regions extension",
744 .dependencies = 0,
744 .dependencies = featureSet(&[_]Feature{}),
745745 };
746746 result[@enumToInt(Feature.lse)] = .{
747747 .index = @enumToInt(Feature.lse),
748748 .name = @tagName(Feature.lse),
749749 .llvm_name = "lse",
750750 .description = "Enable ARMv8.1 Large System Extension (LSE) atomic instructions",
751 .dependencies = 0,
751 .dependencies = featureSet(&[_]Feature{}),
752752 };
753753 result[@enumToInt(Feature.lsl_fast)] = .{
754754 .index = @enumToInt(Feature.lsl_fast),
755755 .name = @tagName(Feature.lsl_fast),
756756 .llvm_name = "lsl-fast",
757757 .description = "CPU has a fastpath logical shift of up to 3 places",
758 .dependencies = 0,
758 .dependencies = featureSet(&[_]Feature{}),
759759 };
760760 result[@enumToInt(Feature.mpam)] = .{
761761 .index = @enumToInt(Feature.mpam),
762762 .name = @tagName(Feature.mpam),
763763 .llvm_name = "mpam",
764764 .description = "Enable v8.4-A Memory system Partitioning and Monitoring extension",
765 .dependencies = 0,
765 .dependencies = featureSet(&[_]Feature{}),
766766 };
767767 result[@enumToInt(Feature.mte)] = .{
768768 .index = @enumToInt(Feature.mte),
769769 .name = @tagName(Feature.mte),
770770 .llvm_name = "mte",
771771 .description = "Enable Memory Tagging Extension",
772 .dependencies = 0,
772 .dependencies = featureSet(&[_]Feature{}),
773773 };
774774 result[@enumToInt(Feature.neon)] = .{
775775 .index = @enumToInt(Feature.neon),
......@@ -785,28 +785,28 @@ pub const all_features = blk: {
785785 .name = @tagName(Feature.no_neg_immediates),
786786 .llvm_name = "no-neg-immediates",
787787 .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.",
788 .dependencies = 0,
788 .dependencies = featureSet(&[_]Feature{}),
789789 };
790790 result[@enumToInt(Feature.nv)] = .{
791791 .index = @enumToInt(Feature.nv),
792792 .name = @tagName(Feature.nv),
793793 .llvm_name = "nv",
794794 .description = "Enable v8.4-A Nested Virtualization Enchancement",
795 .dependencies = 0,
795 .dependencies = featureSet(&[_]Feature{}),
796796 };
797797 result[@enumToInt(Feature.pa)] = .{
798798 .index = @enumToInt(Feature.pa),
799799 .name = @tagName(Feature.pa),
800800 .llvm_name = "pa",
801801 .description = "Enable v8.3-A Pointer Authentication enchancement",
802 .dependencies = 0,
802 .dependencies = featureSet(&[_]Feature{}),
803803 };
804804 result[@enumToInt(Feature.pan)] = .{
805805 .index = @enumToInt(Feature.pan),
806806 .name = @tagName(Feature.pan),
807807 .llvm_name = "pan",
808808 .description = "Enables ARM v8.1 Privileged Access-Never extension",
809 .dependencies = 0,
809 .dependencies = featureSet(&[_]Feature{}),
810810 };
811811 result[@enumToInt(Feature.pan_rwv)] = .{
812812 .index = @enumToInt(Feature.pan_rwv),
......@@ -822,35 +822,35 @@ pub const all_features = blk: {
822822 .name = @tagName(Feature.perfmon),
823823 .llvm_name = "perfmon",
824824 .description = "Enable ARMv8 PMUv3 Performance Monitors extension",
825 .dependencies = 0,
825 .dependencies = featureSet(&[_]Feature{}),
826826 };
827827 result[@enumToInt(Feature.predictable_select_expensive)] = .{
828828 .index = @enumToInt(Feature.predictable_select_expensive),
829829 .name = @tagName(Feature.predictable_select_expensive),
830830 .llvm_name = "predictable-select-expensive",
831831 .description = "Prefer likely predicted branches over selects",
832 .dependencies = 0,
832 .dependencies = featureSet(&[_]Feature{}),
833833 };
834834 result[@enumToInt(Feature.predres)] = .{
835835 .index = @enumToInt(Feature.predres),
836836 .name = @tagName(Feature.predres),
837837 .llvm_name = "predres",
838838 .description = "Enable v8.5a execution and data prediction invalidation instructions",
839 .dependencies = 0,
839 .dependencies = featureSet(&[_]Feature{}),
840840 };
841841 result[@enumToInt(Feature.rand)] = .{
842842 .index = @enumToInt(Feature.rand),
843843 .name = @tagName(Feature.rand),
844844 .llvm_name = "rand",
845845 .description = "Enable Random Number generation instructions",
846 .dependencies = 0,
846 .dependencies = featureSet(&[_]Feature{}),
847847 };
848848 result[@enumToInt(Feature.ras)] = .{
849849 .index = @enumToInt(Feature.ras),
850850 .name = @tagName(Feature.ras),
851851 .llvm_name = "ras",
852852 .description = "Enable ARMv8 Reliability, Availability and Serviceability Extensions",
853 .dependencies = 0,
853 .dependencies = featureSet(&[_]Feature{}),
854854 };
855855 result[@enumToInt(Feature.rasv8_4)] = .{
856856 .index = @enumToInt(Feature.rasv8_4),
......@@ -866,7 +866,7 @@ pub const all_features = blk: {
866866 .name = @tagName(Feature.rcpc),
867867 .llvm_name = "rcpc",
868868 .description = "Enable support for RCPC extension",
869 .dependencies = 0,
869 .dependencies = featureSet(&[_]Feature{}),
870870 };
871871 result[@enumToInt(Feature.rcpc_immo)] = .{
872872 .index = @enumToInt(Feature.rcpc_immo),
......@@ -882,175 +882,175 @@ pub const all_features = blk: {
882882 .name = @tagName(Feature.rdm),
883883 .llvm_name = "rdm",
884884 .description = "Enable ARMv8.1 Rounding Double Multiply Add/Subtract instructions",
885 .dependencies = 0,
885 .dependencies = featureSet(&[_]Feature{}),
886886 };
887887 result[@enumToInt(Feature.reserve_x1)] = .{
888888 .index = @enumToInt(Feature.reserve_x1),
889889 .name = @tagName(Feature.reserve_x1),
890890 .llvm_name = "reserve-x1",
891891 .description = "Reserve X1, making it unavailable as a GPR",
892 .dependencies = 0,
892 .dependencies = featureSet(&[_]Feature{}),
893893 };
894894 result[@enumToInt(Feature.reserve_x10)] = .{
895895 .index = @enumToInt(Feature.reserve_x10),
896896 .name = @tagName(Feature.reserve_x10),
897897 .llvm_name = "reserve-x10",
898898 .description = "Reserve X10, making it unavailable as a GPR",
899 .dependencies = 0,
899 .dependencies = featureSet(&[_]Feature{}),
900900 };
901901 result[@enumToInt(Feature.reserve_x11)] = .{
902902 .index = @enumToInt(Feature.reserve_x11),
903903 .name = @tagName(Feature.reserve_x11),
904904 .llvm_name = "reserve-x11",
905905 .description = "Reserve X11, making it unavailable as a GPR",
906 .dependencies = 0,
906 .dependencies = featureSet(&[_]Feature{}),
907907 };
908908 result[@enumToInt(Feature.reserve_x12)] = .{
909909 .index = @enumToInt(Feature.reserve_x12),
910910 .name = @tagName(Feature.reserve_x12),
911911 .llvm_name = "reserve-x12",
912912 .description = "Reserve X12, making it unavailable as a GPR",
913 .dependencies = 0,
913 .dependencies = featureSet(&[_]Feature{}),
914914 };
915915 result[@enumToInt(Feature.reserve_x13)] = .{
916916 .index = @enumToInt(Feature.reserve_x13),
917917 .name = @tagName(Feature.reserve_x13),
918918 .llvm_name = "reserve-x13",
919919 .description = "Reserve X13, making it unavailable as a GPR",
920 .dependencies = 0,
920 .dependencies = featureSet(&[_]Feature{}),
921921 };
922922 result[@enumToInt(Feature.reserve_x14)] = .{
923923 .index = @enumToInt(Feature.reserve_x14),
924924 .name = @tagName(Feature.reserve_x14),
925925 .llvm_name = "reserve-x14",
926926 .description = "Reserve X14, making it unavailable as a GPR",
927 .dependencies = 0,
927 .dependencies = featureSet(&[_]Feature{}),
928928 };
929929 result[@enumToInt(Feature.reserve_x15)] = .{
930930 .index = @enumToInt(Feature.reserve_x15),
931931 .name = @tagName(Feature.reserve_x15),
932932 .llvm_name = "reserve-x15",
933933 .description = "Reserve X15, making it unavailable as a GPR",
934 .dependencies = 0,
934 .dependencies = featureSet(&[_]Feature{}),
935935 };
936936 result[@enumToInt(Feature.reserve_x18)] = .{
937937 .index = @enumToInt(Feature.reserve_x18),
938938 .name = @tagName(Feature.reserve_x18),
939939 .llvm_name = "reserve-x18",
940940 .description = "Reserve X18, making it unavailable as a GPR",
941 .dependencies = 0,
941 .dependencies = featureSet(&[_]Feature{}),
942942 };
943943 result[@enumToInt(Feature.reserve_x2)] = .{
944944 .index = @enumToInt(Feature.reserve_x2),
945945 .name = @tagName(Feature.reserve_x2),
946946 .llvm_name = "reserve-x2",
947947 .description = "Reserve X2, making it unavailable as a GPR",
948 .dependencies = 0,
948 .dependencies = featureSet(&[_]Feature{}),
949949 };
950950 result[@enumToInt(Feature.reserve_x20)] = .{
951951 .index = @enumToInt(Feature.reserve_x20),
952952 .name = @tagName(Feature.reserve_x20),
953953 .llvm_name = "reserve-x20",
954954 .description = "Reserve X20, making it unavailable as a GPR",
955 .dependencies = 0,
955 .dependencies = featureSet(&[_]Feature{}),
956956 };
957957 result[@enumToInt(Feature.reserve_x21)] = .{
958958 .index = @enumToInt(Feature.reserve_x21),
959959 .name = @tagName(Feature.reserve_x21),
960960 .llvm_name = "reserve-x21",
961961 .description = "Reserve X21, making it unavailable as a GPR",
962 .dependencies = 0,
962 .dependencies = featureSet(&[_]Feature{}),
963963 };
964964 result[@enumToInt(Feature.reserve_x22)] = .{
965965 .index = @enumToInt(Feature.reserve_x22),
966966 .name = @tagName(Feature.reserve_x22),
967967 .llvm_name = "reserve-x22",
968968 .description = "Reserve X22, making it unavailable as a GPR",
969 .dependencies = 0,
969 .dependencies = featureSet(&[_]Feature{}),
970970 };
971971 result[@enumToInt(Feature.reserve_x23)] = .{
972972 .index = @enumToInt(Feature.reserve_x23),
973973 .name = @tagName(Feature.reserve_x23),
974974 .llvm_name = "reserve-x23",
975975 .description = "Reserve X23, making it unavailable as a GPR",
976 .dependencies = 0,
976 .dependencies = featureSet(&[_]Feature{}),
977977 };
978978 result[@enumToInt(Feature.reserve_x24)] = .{
979979 .index = @enumToInt(Feature.reserve_x24),
980980 .name = @tagName(Feature.reserve_x24),
981981 .llvm_name = "reserve-x24",
982982 .description = "Reserve X24, making it unavailable as a GPR",
983 .dependencies = 0,
983 .dependencies = featureSet(&[_]Feature{}),
984984 };
985985 result[@enumToInt(Feature.reserve_x25)] = .{
986986 .index = @enumToInt(Feature.reserve_x25),
987987 .name = @tagName(Feature.reserve_x25),
988988 .llvm_name = "reserve-x25",
989989 .description = "Reserve X25, making it unavailable as a GPR",
990 .dependencies = 0,
990 .dependencies = featureSet(&[_]Feature{}),
991991 };
992992 result[@enumToInt(Feature.reserve_x26)] = .{
993993 .index = @enumToInt(Feature.reserve_x26),
994994 .name = @tagName(Feature.reserve_x26),
995995 .llvm_name = "reserve-x26",
996996 .description = "Reserve X26, making it unavailable as a GPR",
997 .dependencies = 0,
997 .dependencies = featureSet(&[_]Feature{}),
998998 };
999999 result[@enumToInt(Feature.reserve_x27)] = .{
10001000 .index = @enumToInt(Feature.reserve_x27),
10011001 .name = @tagName(Feature.reserve_x27),
10021002 .llvm_name = "reserve-x27",
10031003 .description = "Reserve X27, making it unavailable as a GPR",
1004 .dependencies = 0,
1004 .dependencies = featureSet(&[_]Feature{}),
10051005 };
10061006 result[@enumToInt(Feature.reserve_x28)] = .{
10071007 .index = @enumToInt(Feature.reserve_x28),
10081008 .name = @tagName(Feature.reserve_x28),
10091009 .llvm_name = "reserve-x28",
10101010 .description = "Reserve X28, making it unavailable as a GPR",
1011 .dependencies = 0,
1011 .dependencies = featureSet(&[_]Feature{}),
10121012 };
10131013 result[@enumToInt(Feature.reserve_x3)] = .{
10141014 .index = @enumToInt(Feature.reserve_x3),
10151015 .name = @tagName(Feature.reserve_x3),
10161016 .llvm_name = "reserve-x3",
10171017 .description = "Reserve X3, making it unavailable as a GPR",
1018 .dependencies = 0,
1018 .dependencies = featureSet(&[_]Feature{}),
10191019 };
10201020 result[@enumToInt(Feature.reserve_x4)] = .{
10211021 .index = @enumToInt(Feature.reserve_x4),
10221022 .name = @tagName(Feature.reserve_x4),
10231023 .llvm_name = "reserve-x4",
10241024 .description = "Reserve X4, making it unavailable as a GPR",
1025 .dependencies = 0,
1025 .dependencies = featureSet(&[_]Feature{}),
10261026 };
10271027 result[@enumToInt(Feature.reserve_x5)] = .{
10281028 .index = @enumToInt(Feature.reserve_x5),
10291029 .name = @tagName(Feature.reserve_x5),
10301030 .llvm_name = "reserve-x5",
10311031 .description = "Reserve X5, making it unavailable as a GPR",
1032 .dependencies = 0,
1032 .dependencies = featureSet(&[_]Feature{}),
10331033 };
10341034 result[@enumToInt(Feature.reserve_x6)] = .{
10351035 .index = @enumToInt(Feature.reserve_x6),
10361036 .name = @tagName(Feature.reserve_x6),
10371037 .llvm_name = "reserve-x6",
10381038 .description = "Reserve X6, making it unavailable as a GPR",
1039 .dependencies = 0,
1039 .dependencies = featureSet(&[_]Feature{}),
10401040 };
10411041 result[@enumToInt(Feature.reserve_x7)] = .{
10421042 .index = @enumToInt(Feature.reserve_x7),
10431043 .name = @tagName(Feature.reserve_x7),
10441044 .llvm_name = "reserve-x7",
10451045 .description = "Reserve X7, making it unavailable as a GPR",
1046 .dependencies = 0,
1046 .dependencies = featureSet(&[_]Feature{}),
10471047 };
10481048 result[@enumToInt(Feature.reserve_x9)] = .{
10491049 .index = @enumToInt(Feature.reserve_x9),
10501050 .name = @tagName(Feature.reserve_x9),
10511051 .llvm_name = "reserve-x9",
10521052 .description = "Reserve X9, making it unavailable as a GPR",
1053 .dependencies = 0,
1053 .dependencies = featureSet(&[_]Feature{}),
10541054 };
10551055 result[@enumToInt(Feature.saphira)] = .{
10561056 .index = @enumToInt(Feature.saphira),
......@@ -1076,14 +1076,14 @@ pub const all_features = blk: {
10761076 .name = @tagName(Feature.sb),
10771077 .llvm_name = "sb",
10781078 .description = "Enable v8.5 Speculation Barrier",
1079 .dependencies = 0,
1079 .dependencies = featureSet(&[_]Feature{}),
10801080 };
10811081 result[@enumToInt(Feature.sel2)] = .{
10821082 .index = @enumToInt(Feature.sel2),
10831083 .name = @tagName(Feature.sel2),
10841084 .llvm_name = "sel2",
10851085 .description = "Enable v8.4-A Secure Exception Level 2 extension",
1086 .dependencies = 0,
1086 .dependencies = featureSet(&[_]Feature{}),
10871087 };
10881088 result[@enumToInt(Feature.sha2)] = .{
10891089 .index = @enumToInt(Feature.sha2),
......@@ -1109,21 +1109,21 @@ pub const all_features = blk: {
11091109 .name = @tagName(Feature.slow_misaligned_128store),
11101110 .llvm_name = "slow-misaligned-128store",
11111111 .description = "Misaligned 128 bit stores are slow",
1112 .dependencies = 0,
1112 .dependencies = featureSet(&[_]Feature{}),
11131113 };
11141114 result[@enumToInt(Feature.slow_paired_128)] = .{
11151115 .index = @enumToInt(Feature.slow_paired_128),
11161116 .name = @tagName(Feature.slow_paired_128),
11171117 .llvm_name = "slow-paired-128",
11181118 .description = "Paired 128 bit loads and stores are slow",
1119 .dependencies = 0,
1119 .dependencies = featureSet(&[_]Feature{}),
11201120 };
11211121 result[@enumToInt(Feature.slow_strqro_store)] = .{
11221122 .index = @enumToInt(Feature.slow_strqro_store),
11231123 .name = @tagName(Feature.slow_strqro_store),
11241124 .llvm_name = "slow-strqro-store",
11251125 .description = "STR of Q register with register offset is slow",
1126 .dependencies = 0,
1126 .dependencies = featureSet(&[_]Feature{}),
11271127 };
11281128 result[@enumToInt(Feature.sm4)] = .{
11291129 .index = @enumToInt(Feature.sm4),
......@@ -1139,35 +1139,35 @@ pub const all_features = blk: {
11391139 .name = @tagName(Feature.spe),
11401140 .llvm_name = "spe",
11411141 .description = "Enable Statistical Profiling extension",
1142 .dependencies = 0,
1142 .dependencies = featureSet(&[_]Feature{}),
11431143 };
11441144 result[@enumToInt(Feature.specrestrict)] = .{
11451145 .index = @enumToInt(Feature.specrestrict),
11461146 .name = @tagName(Feature.specrestrict),
11471147 .llvm_name = "specrestrict",
11481148 .description = "Enable architectural speculation restriction",
1149 .dependencies = 0,
1149 .dependencies = featureSet(&[_]Feature{}),
11501150 };
11511151 result[@enumToInt(Feature.ssbs)] = .{
11521152 .index = @enumToInt(Feature.ssbs),
11531153 .name = @tagName(Feature.ssbs),
11541154 .llvm_name = "ssbs",
11551155 .description = "Enable Speculative Store Bypass Safe bit",
1156 .dependencies = 0,
1156 .dependencies = featureSet(&[_]Feature{}),
11571157 };
11581158 result[@enumToInt(Feature.strict_align)] = .{
11591159 .index = @enumToInt(Feature.strict_align),
11601160 .name = @tagName(Feature.strict_align),
11611161 .llvm_name = "strict-align",
11621162 .description = "Disallow all unaligned memory access",
1163 .dependencies = 0,
1163 .dependencies = featureSet(&[_]Feature{}),
11641164 };
11651165 result[@enumToInt(Feature.sve)] = .{
11661166 .index = @enumToInt(Feature.sve),
11671167 .name = @tagName(Feature.sve),
11681168 .llvm_name = "sve",
11691169 .description = "Enable Scalable Vector Extension (SVE) instructions",
1170 .dependencies = 0,
1170 .dependencies = featureSet(&[_]Feature{}),
11711171 };
11721172 result[@enumToInt(Feature.sve2)] = .{
11731173 .index = @enumToInt(Feature.sve2),
......@@ -1300,35 +1300,35 @@ pub const all_features = blk: {
13001300 .name = @tagName(Feature.tlb_rmi),
13011301 .llvm_name = "tlb-rmi",
13021302 .description = "Enable v8.4-A TLB Range and Maintenance Instructions",
1303 .dependencies = 0,
1303 .dependencies = featureSet(&[_]Feature{}),
13041304 };
13051305 result[@enumToInt(Feature.tpidr_el1)] = .{
13061306 .index = @enumToInt(Feature.tpidr_el1),
13071307 .name = @tagName(Feature.tpidr_el1),
13081308 .llvm_name = "tpidr-el1",
13091309 .description = "Permit use of TPIDR_EL1 for the TLS base",
1310 .dependencies = 0,
1310 .dependencies = featureSet(&[_]Feature{}),
13111311 };
13121312 result[@enumToInt(Feature.tpidr_el2)] = .{
13131313 .index = @enumToInt(Feature.tpidr_el2),
13141314 .name = @tagName(Feature.tpidr_el2),
13151315 .llvm_name = "tpidr-el2",
13161316 .description = "Permit use of TPIDR_EL2 for the TLS base",
1317 .dependencies = 0,
1317 .dependencies = featureSet(&[_]Feature{}),
13181318 };
13191319 result[@enumToInt(Feature.tpidr_el3)] = .{
13201320 .index = @enumToInt(Feature.tpidr_el3),
13211321 .name = @tagName(Feature.tpidr_el3),
13221322 .llvm_name = "tpidr-el3",
13231323 .description = "Permit use of TPIDR_EL3 for the TLS base",
1324 .dependencies = 0,
1324 .dependencies = featureSet(&[_]Feature{}),
13251325 };
13261326 result[@enumToInt(Feature.tracev8_4)] = .{
13271327 .index = @enumToInt(Feature.tracev8_4),
13281328 .name = @tagName(Feature.tracev8_4),
13291329 .llvm_name = "tracev8.4",
13301330 .description = "Enable v8.4-A Trace extension",
1331 .dependencies = 0,
1331 .dependencies = featureSet(&[_]Feature{}),
13321332 };
13331333 result[@enumToInt(Feature.tsv110)] = .{
13341334 .index = @enumToInt(Feature.tsv110),
......@@ -1355,28 +1355,28 @@ pub const all_features = blk: {
13551355 .name = @tagName(Feature.uaops),
13561356 .llvm_name = "uaops",
13571357 .description = "Enable v8.2 UAO PState",
1358 .dependencies = 0,
1358 .dependencies = featureSet(&[_]Feature{}),
13591359 };
13601360 result[@enumToInt(Feature.use_aa)] = .{
13611361 .index = @enumToInt(Feature.use_aa),
13621362 .name = @tagName(Feature.use_aa),
13631363 .llvm_name = "use-aa",
13641364 .description = "Use alias analysis during codegen",
1365 .dependencies = 0,
1365 .dependencies = featureSet(&[_]Feature{}),
13661366 };
13671367 result[@enumToInt(Feature.use_postra_scheduler)] = .{
13681368 .index = @enumToInt(Feature.use_postra_scheduler),
13691369 .name = @tagName(Feature.use_postra_scheduler),
13701370 .llvm_name = "use-postra-scheduler",
13711371 .description = "Schedule again after register allocation",
1372 .dependencies = 0,
1372 .dependencies = featureSet(&[_]Feature{}),
13731373 };
13741374 result[@enumToInt(Feature.use_reciprocal_square_root)] = .{
13751375 .index = @enumToInt(Feature.use_reciprocal_square_root),
13761376 .name = @tagName(Feature.use_reciprocal_square_root),
13771377 .llvm_name = "use-reciprocal-square-root",
13781378 .description = "Use the reciprocal square root approximation",
1379 .dependencies = 0,
1379 .dependencies = featureSet(&[_]Feature{}),
13801380 };
13811381 result[@enumToInt(Feature.v8_1a)] = .{
13821382 .index = @enumToInt(Feature.v8_1a),
......@@ -1461,14 +1461,14 @@ pub const all_features = blk: {
14611461 .name = @tagName(Feature.vh),
14621462 .llvm_name = "vh",
14631463 .description = "Enables ARM v8.1 Virtual Host extension",
1464 .dependencies = 0,
1464 .dependencies = featureSet(&[_]Feature{}),
14651465 };
14661466 result[@enumToInt(Feature.zcm)] = .{
14671467 .index = @enumToInt(Feature.zcm),
14681468 .name = @tagName(Feature.zcm),
14691469 .llvm_name = "zcm",
14701470 .description = "Has zero-cycle register moves",
1471 .dependencies = 0,
1471 .dependencies = featureSet(&[_]Feature{}),
14721472 };
14731473 result[@enumToInt(Feature.zcz)] = .{
14741474 .index = @enumToInt(Feature.zcz),
......@@ -1485,21 +1485,21 @@ pub const all_features = blk: {
14851485 .name = @tagName(Feature.zcz_fp),
14861486 .llvm_name = "zcz-fp",
14871487 .description = "Has zero-cycle zeroing instructions for FP registers",
1488 .dependencies = 0,
1488 .dependencies = featureSet(&[_]Feature{}),
14891489 };
14901490 result[@enumToInt(Feature.zcz_fp_workaround)] = .{
14911491 .index = @enumToInt(Feature.zcz_fp_workaround),
14921492 .name = @tagName(Feature.zcz_fp_workaround),
14931493 .llvm_name = "zcz-fp-workaround",
14941494 .description = "The zero-cycle floating-point zeroing instruction has a bug",
1495 .dependencies = 0,
1495 .dependencies = featureSet(&[_]Feature{}),
14961496 };
14971497 result[@enumToInt(Feature.zcz_gp)] = .{
14981498 .index = @enumToInt(Feature.zcz_gp),
14991499 .name = @tagName(Feature.zcz_gp),
15001500 .llvm_name = "zcz-gp",
15011501 .description = "Has zero-cycle zeroing instructions for generic registers",
1502 .dependencies = 0,
1502 .dependencies = featureSet(&[_]Feature{}),
15031503 };
15041504 break :blk result;
15051505};
lib/std/target/amdgpu.zig+100-100
......@@ -115,224 +115,224 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
115115
116116pub const all_features = blk: {
117117 const len = @typeInfo(Feature).Enum.fields.len;
118 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
118 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
119119 var result: [len]Cpu.Feature = undefined;
120120 result[@enumToInt(Feature.@"16_bit_insts")] = .{
121121 .index = @enumToInt(Feature.@"16_bit_insts"),
122122 .name = @tagName(Feature.@"16_bit_insts"),
123123 .llvm_name = "16-bit-insts",
124124 .description = "Has i16/f16 instructions",
125 .dependencies = 0,
125 .dependencies = featureSet(&[_]Feature{}),
126126 };
127127 result[@enumToInt(Feature.DumpCode)] = .{
128128 .index = @enumToInt(Feature.DumpCode),
129129 .name = @tagName(Feature.DumpCode),
130130 .llvm_name = "DumpCode",
131131 .description = "Dump MachineInstrs in the CodeEmitter",
132 .dependencies = 0,
132 .dependencies = featureSet(&[_]Feature{}),
133133 };
134134 result[@enumToInt(Feature.add_no_carry_insts)] = .{
135135 .index = @enumToInt(Feature.add_no_carry_insts),
136136 .name = @tagName(Feature.add_no_carry_insts),
137137 .llvm_name = "add-no-carry-insts",
138138 .description = "Have VALU add/sub instructions without carry out",
139 .dependencies = 0,
139 .dependencies = featureSet(&[_]Feature{}),
140140 };
141141 result[@enumToInt(Feature.aperture_regs)] = .{
142142 .index = @enumToInt(Feature.aperture_regs),
143143 .name = @tagName(Feature.aperture_regs),
144144 .llvm_name = "aperture-regs",
145145 .description = "Has Memory Aperture Base and Size Registers",
146 .dependencies = 0,
146 .dependencies = featureSet(&[_]Feature{}),
147147 };
148148 result[@enumToInt(Feature.atomic_fadd_insts)] = .{
149149 .index = @enumToInt(Feature.atomic_fadd_insts),
150150 .name = @tagName(Feature.atomic_fadd_insts),
151151 .llvm_name = "atomic-fadd-insts",
152152 .description = "Has buffer_atomic_add_f32, buffer_atomic_pk_add_f16, global_atomic_add_f32, global_atomic_pk_add_f16 instructions",
153 .dependencies = 0,
153 .dependencies = featureSet(&[_]Feature{}),
154154 };
155155 result[@enumToInt(Feature.auto_waitcnt_before_barrier)] = .{
156156 .index = @enumToInt(Feature.auto_waitcnt_before_barrier),
157157 .name = @tagName(Feature.auto_waitcnt_before_barrier),
158158 .llvm_name = "auto-waitcnt-before-barrier",
159159 .description = "Hardware automatically inserts waitcnt before barrier",
160 .dependencies = 0,
160 .dependencies = featureSet(&[_]Feature{}),
161161 };
162162 result[@enumToInt(Feature.ci_insts)] = .{
163163 .index = @enumToInt(Feature.ci_insts),
164164 .name = @tagName(Feature.ci_insts),
165165 .llvm_name = "ci-insts",
166166 .description = "Additional instructions for CI+",
167 .dependencies = 0,
167 .dependencies = featureSet(&[_]Feature{}),
168168 };
169169 result[@enumToInt(Feature.code_object_v3)] = .{
170170 .index = @enumToInt(Feature.code_object_v3),
171171 .name = @tagName(Feature.code_object_v3),
172172 .llvm_name = "code-object-v3",
173173 .description = "Generate code object version 3",
174 .dependencies = 0,
174 .dependencies = featureSet(&[_]Feature{}),
175175 };
176176 result[@enumToInt(Feature.cumode)] = .{
177177 .index = @enumToInt(Feature.cumode),
178178 .name = @tagName(Feature.cumode),
179179 .llvm_name = "cumode",
180180 .description = "Enable CU wavefront execution mode",
181 .dependencies = 0,
181 .dependencies = featureSet(&[_]Feature{}),
182182 };
183183 result[@enumToInt(Feature.dl_insts)] = .{
184184 .index = @enumToInt(Feature.dl_insts),
185185 .name = @tagName(Feature.dl_insts),
186186 .llvm_name = "dl-insts",
187187 .description = "Has v_fmac_f32 and v_xnor_b32 instructions",
188 .dependencies = 0,
188 .dependencies = featureSet(&[_]Feature{}),
189189 };
190190 result[@enumToInt(Feature.dot1_insts)] = .{
191191 .index = @enumToInt(Feature.dot1_insts),
192192 .name = @tagName(Feature.dot1_insts),
193193 .llvm_name = "dot1-insts",
194194 .description = "Has v_dot4_i32_i8 and v_dot8_i32_i4 instructions",
195 .dependencies = 0,
195 .dependencies = featureSet(&[_]Feature{}),
196196 };
197197 result[@enumToInt(Feature.dot2_insts)] = .{
198198 .index = @enumToInt(Feature.dot2_insts),
199199 .name = @tagName(Feature.dot2_insts),
200200 .llvm_name = "dot2-insts",
201201 .description = "Has v_dot2_f32_f16, v_dot2_i32_i16, v_dot2_u32_u16, v_dot4_u32_u8, v_dot8_u32_u4 instructions",
202 .dependencies = 0,
202 .dependencies = featureSet(&[_]Feature{}),
203203 };
204204 result[@enumToInt(Feature.dot3_insts)] = .{
205205 .index = @enumToInt(Feature.dot3_insts),
206206 .name = @tagName(Feature.dot3_insts),
207207 .llvm_name = "dot3-insts",
208208 .description = "Has v_dot8c_i32_i4 instruction",
209 .dependencies = 0,
209 .dependencies = featureSet(&[_]Feature{}),
210210 };
211211 result[@enumToInt(Feature.dot4_insts)] = .{
212212 .index = @enumToInt(Feature.dot4_insts),
213213 .name = @tagName(Feature.dot4_insts),
214214 .llvm_name = "dot4-insts",
215215 .description = "Has v_dot2c_i32_i16 instruction",
216 .dependencies = 0,
216 .dependencies = featureSet(&[_]Feature{}),
217217 };
218218 result[@enumToInt(Feature.dot5_insts)] = .{
219219 .index = @enumToInt(Feature.dot5_insts),
220220 .name = @tagName(Feature.dot5_insts),
221221 .llvm_name = "dot5-insts",
222222 .description = "Has v_dot2c_f32_f16 instruction",
223 .dependencies = 0,
223 .dependencies = featureSet(&[_]Feature{}),
224224 };
225225 result[@enumToInt(Feature.dot6_insts)] = .{
226226 .index = @enumToInt(Feature.dot6_insts),
227227 .name = @tagName(Feature.dot6_insts),
228228 .llvm_name = "dot6-insts",
229229 .description = "Has v_dot4c_i32_i8 instruction",
230 .dependencies = 0,
230 .dependencies = featureSet(&[_]Feature{}),
231231 };
232232 result[@enumToInt(Feature.dpp)] = .{
233233 .index = @enumToInt(Feature.dpp),
234234 .name = @tagName(Feature.dpp),
235235 .llvm_name = "dpp",
236236 .description = "Support DPP (Data Parallel Primitives) extension",
237 .dependencies = 0,
237 .dependencies = featureSet(&[_]Feature{}),
238238 };
239239 result[@enumToInt(Feature.dpp8)] = .{
240240 .index = @enumToInt(Feature.dpp8),
241241 .name = @tagName(Feature.dpp8),
242242 .llvm_name = "dpp8",
243243 .description = "Support DPP8 (Data Parallel Primitives) extension",
244 .dependencies = 0,
244 .dependencies = featureSet(&[_]Feature{}),
245245 };
246246 result[@enumToInt(Feature.dumpcode)] = .{
247247 .index = @enumToInt(Feature.dumpcode),
248248 .name = @tagName(Feature.dumpcode),
249249 .llvm_name = "dumpcode",
250250 .description = "Dump MachineInstrs in the CodeEmitter",
251 .dependencies = 0,
251 .dependencies = featureSet(&[_]Feature{}),
252252 };
253253 result[@enumToInt(Feature.enable_ds128)] = .{
254254 .index = @enumToInt(Feature.enable_ds128),
255255 .name = @tagName(Feature.enable_ds128),
256256 .llvm_name = "enable-ds128",
257257 .description = "Use ds_read|write_b128",
258 .dependencies = 0,
258 .dependencies = featureSet(&[_]Feature{}),
259259 };
260260 result[@enumToInt(Feature.enable_prt_strict_null)] = .{
261261 .index = @enumToInt(Feature.enable_prt_strict_null),
262262 .name = @tagName(Feature.enable_prt_strict_null),
263263 .llvm_name = "enable-prt-strict-null",
264264 .description = "Enable zeroing of result registers for sparse texture fetches",
265 .dependencies = 0,
265 .dependencies = featureSet(&[_]Feature{}),
266266 };
267267 result[@enumToInt(Feature.fast_fmaf)] = .{
268268 .index = @enumToInt(Feature.fast_fmaf),
269269 .name = @tagName(Feature.fast_fmaf),
270270 .llvm_name = "fast-fmaf",
271271 .description = "Assuming f32 fma is at least as fast as mul + add",
272 .dependencies = 0,
272 .dependencies = featureSet(&[_]Feature{}),
273273 };
274274 result[@enumToInt(Feature.flat_address_space)] = .{
275275 .index = @enumToInt(Feature.flat_address_space),
276276 .name = @tagName(Feature.flat_address_space),
277277 .llvm_name = "flat-address-space",
278278 .description = "Support flat address space",
279 .dependencies = 0,
279 .dependencies = featureSet(&[_]Feature{}),
280280 };
281281 result[@enumToInt(Feature.flat_for_global)] = .{
282282 .index = @enumToInt(Feature.flat_for_global),
283283 .name = @tagName(Feature.flat_for_global),
284284 .llvm_name = "flat-for-global",
285285 .description = "Force to generate flat instruction for global",
286 .dependencies = 0,
286 .dependencies = featureSet(&[_]Feature{}),
287287 };
288288 result[@enumToInt(Feature.flat_global_insts)] = .{
289289 .index = @enumToInt(Feature.flat_global_insts),
290290 .name = @tagName(Feature.flat_global_insts),
291291 .llvm_name = "flat-global-insts",
292292 .description = "Have global_* flat memory instructions",
293 .dependencies = 0,
293 .dependencies = featureSet(&[_]Feature{}),
294294 };
295295 result[@enumToInt(Feature.flat_inst_offsets)] = .{
296296 .index = @enumToInt(Feature.flat_inst_offsets),
297297 .name = @tagName(Feature.flat_inst_offsets),
298298 .llvm_name = "flat-inst-offsets",
299299 .description = "Flat instructions have immediate offset addressing mode",
300 .dependencies = 0,
300 .dependencies = featureSet(&[_]Feature{}),
301301 };
302302 result[@enumToInt(Feature.flat_scratch_insts)] = .{
303303 .index = @enumToInt(Feature.flat_scratch_insts),
304304 .name = @tagName(Feature.flat_scratch_insts),
305305 .llvm_name = "flat-scratch-insts",
306306 .description = "Have scratch_* flat memory instructions",
307 .dependencies = 0,
307 .dependencies = featureSet(&[_]Feature{}),
308308 };
309309 result[@enumToInt(Feature.flat_segment_offset_bug)] = .{
310310 .index = @enumToInt(Feature.flat_segment_offset_bug),
311311 .name = @tagName(Feature.flat_segment_offset_bug),
312312 .llvm_name = "flat-segment-offset-bug",
313313 .description = "GFX10 bug, inst_offset ignored in flat segment",
314 .dependencies = 0,
314 .dependencies = featureSet(&[_]Feature{}),
315315 };
316316 result[@enumToInt(Feature.fma_mix_insts)] = .{
317317 .index = @enumToInt(Feature.fma_mix_insts),
318318 .name = @tagName(Feature.fma_mix_insts),
319319 .llvm_name = "fma-mix-insts",
320320 .description = "Has v_fma_mix_f32, v_fma_mixlo_f16, v_fma_mixhi_f16 instructions",
321 .dependencies = 0,
321 .dependencies = featureSet(&[_]Feature{}),
322322 };
323323 result[@enumToInt(Feature.fmaf)] = .{
324324 .index = @enumToInt(Feature.fmaf),
325325 .name = @tagName(Feature.fmaf),
326326 .llvm_name = "fmaf",
327327 .description = "Enable single precision FMA (not as fast as mul+add, but fused)",
328 .dependencies = 0,
328 .dependencies = featureSet(&[_]Feature{}),
329329 };
330330 result[@enumToInt(Feature.fp_exceptions)] = .{
331331 .index = @enumToInt(Feature.fp_exceptions),
332332 .name = @tagName(Feature.fp_exceptions),
333333 .llvm_name = "fp-exceptions",
334334 .description = "Enable floating point exceptions",
335 .dependencies = 0,
335 .dependencies = featureSet(&[_]Feature{}),
336336 };
337337 result[@enumToInt(Feature.fp16_denormals)] = .{
338338 .index = @enumToInt(Feature.fp16_denormals),
......@@ -348,14 +348,14 @@ pub const all_features = blk: {
348348 .name = @tagName(Feature.fp32_denormals),
349349 .llvm_name = "fp32-denormals",
350350 .description = "Enable single precision denormal handling",
351 .dependencies = 0,
351 .dependencies = featureSet(&[_]Feature{}),
352352 };
353353 result[@enumToInt(Feature.fp64)] = .{
354354 .index = @enumToInt(Feature.fp64),
355355 .name = @tagName(Feature.fp64),
356356 .llvm_name = "fp64",
357357 .description = "Enable double precision operations",
358 .dependencies = 0,
358 .dependencies = featureSet(&[_]Feature{}),
359359 };
360360 result[@enumToInt(Feature.fp64_denormals)] = .{
361361 .index = @enumToInt(Feature.fp64_denormals),
......@@ -381,7 +381,7 @@ pub const all_features = blk: {
381381 .name = @tagName(Feature.gcn3_encoding),
382382 .llvm_name = "gcn3-encoding",
383383 .description = "Encoding format for VI",
384 .dependencies = 0,
384 .dependencies = featureSet(&[_]Feature{}),
385385 };
386386 result[@enumToInt(Feature.gfx10)] = .{
387387 .index = @enumToInt(Feature.gfx10),
......@@ -430,21 +430,21 @@ pub const all_features = blk: {
430430 .name = @tagName(Feature.gfx10_insts),
431431 .llvm_name = "gfx10-insts",
432432 .description = "Additional instructions for GFX10+",
433 .dependencies = 0,
433 .dependencies = featureSet(&[_]Feature{}),
434434 };
435435 result[@enumToInt(Feature.gfx7_gfx8_gfx9_insts)] = .{
436436 .index = @enumToInt(Feature.gfx7_gfx8_gfx9_insts),
437437 .name = @tagName(Feature.gfx7_gfx8_gfx9_insts),
438438 .llvm_name = "gfx7-gfx8-gfx9-insts",
439439 .description = "Instructions shared in GFX7, GFX8, GFX9",
440 .dependencies = 0,
440 .dependencies = featureSet(&[_]Feature{}),
441441 };
442442 result[@enumToInt(Feature.gfx8_insts)] = .{
443443 .index = @enumToInt(Feature.gfx8_insts),
444444 .name = @tagName(Feature.gfx8_insts),
445445 .llvm_name = "gfx8-insts",
446446 .description = "Additional instructions for GFX8+",
447 .dependencies = 0,
447 .dependencies = featureSet(&[_]Feature{}),
448448 };
449449 result[@enumToInt(Feature.gfx9)] = .{
450450 .index = @enumToInt(Feature.gfx9),
......@@ -489,287 +489,287 @@ pub const all_features = blk: {
489489 .name = @tagName(Feature.gfx9_insts),
490490 .llvm_name = "gfx9-insts",
491491 .description = "Additional instructions for GFX9+",
492 .dependencies = 0,
492 .dependencies = featureSet(&[_]Feature{}),
493493 };
494494 result[@enumToInt(Feature.half_rate_64_ops)] = .{
495495 .index = @enumToInt(Feature.half_rate_64_ops),
496496 .name = @tagName(Feature.half_rate_64_ops),
497497 .llvm_name = "half-rate-64-ops",
498498 .description = "Most fp64 instructions are half rate instead of quarter",
499 .dependencies = 0,
499 .dependencies = featureSet(&[_]Feature{}),
500500 };
501501 result[@enumToInt(Feature.inst_fwd_prefetch_bug)] = .{
502502 .index = @enumToInt(Feature.inst_fwd_prefetch_bug),
503503 .name = @tagName(Feature.inst_fwd_prefetch_bug),
504504 .llvm_name = "inst-fwd-prefetch-bug",
505505 .description = "S_INST_PREFETCH instruction causes shader to hang",
506 .dependencies = 0,
506 .dependencies = featureSet(&[_]Feature{}),
507507 };
508508 result[@enumToInt(Feature.int_clamp_insts)] = .{
509509 .index = @enumToInt(Feature.int_clamp_insts),
510510 .name = @tagName(Feature.int_clamp_insts),
511511 .llvm_name = "int-clamp-insts",
512512 .description = "Support clamp for integer destination",
513 .dependencies = 0,
513 .dependencies = featureSet(&[_]Feature{}),
514514 };
515515 result[@enumToInt(Feature.inv_2pi_inline_imm)] = .{
516516 .index = @enumToInt(Feature.inv_2pi_inline_imm),
517517 .name = @tagName(Feature.inv_2pi_inline_imm),
518518 .llvm_name = "inv-2pi-inline-imm",
519519 .description = "Has 1 / (2 * pi) as inline immediate",
520 .dependencies = 0,
520 .dependencies = featureSet(&[_]Feature{}),
521521 };
522522 result[@enumToInt(Feature.lds_branch_vmem_war_hazard)] = .{
523523 .index = @enumToInt(Feature.lds_branch_vmem_war_hazard),
524524 .name = @tagName(Feature.lds_branch_vmem_war_hazard),
525525 .llvm_name = "lds-branch-vmem-war-hazard",
526526 .description = "Switching between LDS and VMEM-tex not waiting VM_VSRC=0",
527 .dependencies = 0,
527 .dependencies = featureSet(&[_]Feature{}),
528528 };
529529 result[@enumToInt(Feature.lds_misaligned_bug)] = .{
530530 .index = @enumToInt(Feature.lds_misaligned_bug),
531531 .name = @tagName(Feature.lds_misaligned_bug),
532532 .llvm_name = "lds-misaligned-bug",
533533 .description = "Some GFX10 bug with misaligned multi-dword LDS access in WGP mode",
534 .dependencies = 0,
534 .dependencies = featureSet(&[_]Feature{}),
535535 };
536536 result[@enumToInt(Feature.ldsbankcount16)] = .{
537537 .index = @enumToInt(Feature.ldsbankcount16),
538538 .name = @tagName(Feature.ldsbankcount16),
539539 .llvm_name = "ldsbankcount16",
540540 .description = "The number of LDS banks per compute unit.",
541 .dependencies = 0,
541 .dependencies = featureSet(&[_]Feature{}),
542542 };
543543 result[@enumToInt(Feature.ldsbankcount32)] = .{
544544 .index = @enumToInt(Feature.ldsbankcount32),
545545 .name = @tagName(Feature.ldsbankcount32),
546546 .llvm_name = "ldsbankcount32",
547547 .description = "The number of LDS banks per compute unit.",
548 .dependencies = 0,
548 .dependencies = featureSet(&[_]Feature{}),
549549 };
550550 result[@enumToInt(Feature.load_store_opt)] = .{
551551 .index = @enumToInt(Feature.load_store_opt),
552552 .name = @tagName(Feature.load_store_opt),
553553 .llvm_name = "load-store-opt",
554554 .description = "Enable SI load/store optimizer pass",
555 .dependencies = 0,
555 .dependencies = featureSet(&[_]Feature{}),
556556 };
557557 result[@enumToInt(Feature.localmemorysize0)] = .{
558558 .index = @enumToInt(Feature.localmemorysize0),
559559 .name = @tagName(Feature.localmemorysize0),
560560 .llvm_name = "localmemorysize0",
561561 .description = "The size of local memory in bytes",
562 .dependencies = 0,
562 .dependencies = featureSet(&[_]Feature{}),
563563 };
564564 result[@enumToInt(Feature.localmemorysize32768)] = .{
565565 .index = @enumToInt(Feature.localmemorysize32768),
566566 .name = @tagName(Feature.localmemorysize32768),
567567 .llvm_name = "localmemorysize32768",
568568 .description = "The size of local memory in bytes",
569 .dependencies = 0,
569 .dependencies = featureSet(&[_]Feature{}),
570570 };
571571 result[@enumToInt(Feature.localmemorysize65536)] = .{
572572 .index = @enumToInt(Feature.localmemorysize65536),
573573 .name = @tagName(Feature.localmemorysize65536),
574574 .llvm_name = "localmemorysize65536",
575575 .description = "The size of local memory in bytes",
576 .dependencies = 0,
576 .dependencies = featureSet(&[_]Feature{}),
577577 };
578578 result[@enumToInt(Feature.mad_mix_insts)] = .{
579579 .index = @enumToInt(Feature.mad_mix_insts),
580580 .name = @tagName(Feature.mad_mix_insts),
581581 .llvm_name = "mad-mix-insts",
582582 .description = "Has v_mad_mix_f32, v_mad_mixlo_f16, v_mad_mixhi_f16 instructions",
583 .dependencies = 0,
583 .dependencies = featureSet(&[_]Feature{}),
584584 };
585585 result[@enumToInt(Feature.mai_insts)] = .{
586586 .index = @enumToInt(Feature.mai_insts),
587587 .name = @tagName(Feature.mai_insts),
588588 .llvm_name = "mai-insts",
589589 .description = "Has mAI instructions",
590 .dependencies = 0,
590 .dependencies = featureSet(&[_]Feature{}),
591591 };
592592 result[@enumToInt(Feature.max_private_element_size_16)] = .{
593593 .index = @enumToInt(Feature.max_private_element_size_16),
594594 .name = @tagName(Feature.max_private_element_size_16),
595595 .llvm_name = "max-private-element-size-16",
596596 .description = "Maximum private access size may be 16",
597 .dependencies = 0,
597 .dependencies = featureSet(&[_]Feature{}),
598598 };
599599 result[@enumToInt(Feature.max_private_element_size_4)] = .{
600600 .index = @enumToInt(Feature.max_private_element_size_4),
601601 .name = @tagName(Feature.max_private_element_size_4),
602602 .llvm_name = "max-private-element-size-4",
603603 .description = "Maximum private access size may be 4",
604 .dependencies = 0,
604 .dependencies = featureSet(&[_]Feature{}),
605605 };
606606 result[@enumToInt(Feature.max_private_element_size_8)] = .{
607607 .index = @enumToInt(Feature.max_private_element_size_8),
608608 .name = @tagName(Feature.max_private_element_size_8),
609609 .llvm_name = "max-private-element-size-8",
610610 .description = "Maximum private access size may be 8",
611 .dependencies = 0,
611 .dependencies = featureSet(&[_]Feature{}),
612612 };
613613 result[@enumToInt(Feature.mimg_r128)] = .{
614614 .index = @enumToInt(Feature.mimg_r128),
615615 .name = @tagName(Feature.mimg_r128),
616616 .llvm_name = "mimg-r128",
617617 .description = "Support 128-bit texture resources",
618 .dependencies = 0,
618 .dependencies = featureSet(&[_]Feature{}),
619619 };
620620 result[@enumToInt(Feature.movrel)] = .{
621621 .index = @enumToInt(Feature.movrel),
622622 .name = @tagName(Feature.movrel),
623623 .llvm_name = "movrel",
624624 .description = "Has v_movrel*_b32 instructions",
625 .dependencies = 0,
625 .dependencies = featureSet(&[_]Feature{}),
626626 };
627627 result[@enumToInt(Feature.no_data_dep_hazard)] = .{
628628 .index = @enumToInt(Feature.no_data_dep_hazard),
629629 .name = @tagName(Feature.no_data_dep_hazard),
630630 .llvm_name = "no-data-dep-hazard",
631631 .description = "Does not need SW waitstates",
632 .dependencies = 0,
632 .dependencies = featureSet(&[_]Feature{}),
633633 };
634634 result[@enumToInt(Feature.no_sdst_cmpx)] = .{
635635 .index = @enumToInt(Feature.no_sdst_cmpx),
636636 .name = @tagName(Feature.no_sdst_cmpx),
637637 .llvm_name = "no-sdst-cmpx",
638638 .description = "V_CMPX does not write VCC/SGPR in addition to EXEC",
639 .dependencies = 0,
639 .dependencies = featureSet(&[_]Feature{}),
640640 };
641641 result[@enumToInt(Feature.no_sram_ecc_support)] = .{
642642 .index = @enumToInt(Feature.no_sram_ecc_support),
643643 .name = @tagName(Feature.no_sram_ecc_support),
644644 .llvm_name = "no-sram-ecc-support",
645645 .description = "Hardware does not support SRAM ECC",
646 .dependencies = 0,
646 .dependencies = featureSet(&[_]Feature{}),
647647 };
648648 result[@enumToInt(Feature.no_xnack_support)] = .{
649649 .index = @enumToInt(Feature.no_xnack_support),
650650 .name = @tagName(Feature.no_xnack_support),
651651 .llvm_name = "no-xnack-support",
652652 .description = "Hardware does not support XNACK",
653 .dependencies = 0,
653 .dependencies = featureSet(&[_]Feature{}),
654654 };
655655 result[@enumToInt(Feature.nsa_encoding)] = .{
656656 .index = @enumToInt(Feature.nsa_encoding),
657657 .name = @tagName(Feature.nsa_encoding),
658658 .llvm_name = "nsa-encoding",
659659 .description = "Support NSA encoding for image instructions",
660 .dependencies = 0,
660 .dependencies = featureSet(&[_]Feature{}),
661661 };
662662 result[@enumToInt(Feature.nsa_to_vmem_bug)] = .{
663663 .index = @enumToInt(Feature.nsa_to_vmem_bug),
664664 .name = @tagName(Feature.nsa_to_vmem_bug),
665665 .llvm_name = "nsa-to-vmem-bug",
666666 .description = "MIMG-NSA followed by VMEM fail if EXEC_LO or EXEC_HI equals zero",
667 .dependencies = 0,
667 .dependencies = featureSet(&[_]Feature{}),
668668 };
669669 result[@enumToInt(Feature.offset_3f_bug)] = .{
670670 .index = @enumToInt(Feature.offset_3f_bug),
671671 .name = @tagName(Feature.offset_3f_bug),
672672 .llvm_name = "offset-3f-bug",
673673 .description = "Branch offset of 3f hardware bug",
674 .dependencies = 0,
674 .dependencies = featureSet(&[_]Feature{}),
675675 };
676676 result[@enumToInt(Feature.pk_fmac_f16_inst)] = .{
677677 .index = @enumToInt(Feature.pk_fmac_f16_inst),
678678 .name = @tagName(Feature.pk_fmac_f16_inst),
679679 .llvm_name = "pk-fmac-f16-inst",
680680 .description = "Has v_pk_fmac_f16 instruction",
681 .dependencies = 0,
681 .dependencies = featureSet(&[_]Feature{}),
682682 };
683683 result[@enumToInt(Feature.promote_alloca)] = .{
684684 .index = @enumToInt(Feature.promote_alloca),
685685 .name = @tagName(Feature.promote_alloca),
686686 .llvm_name = "promote-alloca",
687687 .description = "Enable promote alloca pass",
688 .dependencies = 0,
688 .dependencies = featureSet(&[_]Feature{}),
689689 };
690690 result[@enumToInt(Feature.r128_a16)] = .{
691691 .index = @enumToInt(Feature.r128_a16),
692692 .name = @tagName(Feature.r128_a16),
693693 .llvm_name = "r128-a16",
694694 .description = "Support 16 bit coordindates/gradients/lod/clamp/mip types on gfx9",
695 .dependencies = 0,
695 .dependencies = featureSet(&[_]Feature{}),
696696 };
697697 result[@enumToInt(Feature.register_banking)] = .{
698698 .index = @enumToInt(Feature.register_banking),
699699 .name = @tagName(Feature.register_banking),
700700 .llvm_name = "register-banking",
701701 .description = "Has register banking",
702 .dependencies = 0,
702 .dependencies = featureSet(&[_]Feature{}),
703703 };
704704 result[@enumToInt(Feature.s_memrealtime)] = .{
705705 .index = @enumToInt(Feature.s_memrealtime),
706706 .name = @tagName(Feature.s_memrealtime),
707707 .llvm_name = "s-memrealtime",
708708 .description = "Has s_memrealtime instruction",
709 .dependencies = 0,
709 .dependencies = featureSet(&[_]Feature{}),
710710 };
711711 result[@enumToInt(Feature.scalar_atomics)] = .{
712712 .index = @enumToInt(Feature.scalar_atomics),
713713 .name = @tagName(Feature.scalar_atomics),
714714 .llvm_name = "scalar-atomics",
715715 .description = "Has atomic scalar memory instructions",
716 .dependencies = 0,
716 .dependencies = featureSet(&[_]Feature{}),
717717 };
718718 result[@enumToInt(Feature.scalar_flat_scratch_insts)] = .{
719719 .index = @enumToInt(Feature.scalar_flat_scratch_insts),
720720 .name = @tagName(Feature.scalar_flat_scratch_insts),
721721 .llvm_name = "scalar-flat-scratch-insts",
722722 .description = "Have s_scratch_* flat memory instructions",
723 .dependencies = 0,
723 .dependencies = featureSet(&[_]Feature{}),
724724 };
725725 result[@enumToInt(Feature.scalar_stores)] = .{
726726 .index = @enumToInt(Feature.scalar_stores),
727727 .name = @tagName(Feature.scalar_stores),
728728 .llvm_name = "scalar-stores",
729729 .description = "Has store scalar memory instructions",
730 .dependencies = 0,
730 .dependencies = featureSet(&[_]Feature{}),
731731 };
732732 result[@enumToInt(Feature.sdwa)] = .{
733733 .index = @enumToInt(Feature.sdwa),
734734 .name = @tagName(Feature.sdwa),
735735 .llvm_name = "sdwa",
736736 .description = "Support SDWA (Sub-DWORD Addressing) extension",
737 .dependencies = 0,
737 .dependencies = featureSet(&[_]Feature{}),
738738 };
739739 result[@enumToInt(Feature.sdwa_mav)] = .{
740740 .index = @enumToInt(Feature.sdwa_mav),
741741 .name = @tagName(Feature.sdwa_mav),
742742 .llvm_name = "sdwa-mav",
743743 .description = "Support v_mac_f32/f16 with SDWA (Sub-DWORD Addressing) extension",
744 .dependencies = 0,
744 .dependencies = featureSet(&[_]Feature{}),
745745 };
746746 result[@enumToInt(Feature.sdwa_omod)] = .{
747747 .index = @enumToInt(Feature.sdwa_omod),
748748 .name = @tagName(Feature.sdwa_omod),
749749 .llvm_name = "sdwa-omod",
750750 .description = "Support OMod with SDWA (Sub-DWORD Addressing) extension",
751 .dependencies = 0,
751 .dependencies = featureSet(&[_]Feature{}),
752752 };
753753 result[@enumToInt(Feature.sdwa_out_mods_vopc)] = .{
754754 .index = @enumToInt(Feature.sdwa_out_mods_vopc),
755755 .name = @tagName(Feature.sdwa_out_mods_vopc),
756756 .llvm_name = "sdwa-out-mods-vopc",
757757 .description = "Support clamp for VOPC with SDWA (Sub-DWORD Addressing) extension",
758 .dependencies = 0,
758 .dependencies = featureSet(&[_]Feature{}),
759759 };
760760 result[@enumToInt(Feature.sdwa_scalar)] = .{
761761 .index = @enumToInt(Feature.sdwa_scalar),
762762 .name = @tagName(Feature.sdwa_scalar),
763763 .llvm_name = "sdwa-scalar",
764764 .description = "Support scalar register with SDWA (Sub-DWORD Addressing) extension",
765 .dependencies = 0,
765 .dependencies = featureSet(&[_]Feature{}),
766766 };
767767 result[@enumToInt(Feature.sdwa_sdst)] = .{
768768 .index = @enumToInt(Feature.sdwa_sdst),
769769 .name = @tagName(Feature.sdwa_sdst),
770770 .llvm_name = "sdwa-sdst",
771771 .description = "Support scalar dst for VOPC with SDWA (Sub-DWORD Addressing) extension",
772 .dependencies = 0,
772 .dependencies = featureSet(&[_]Feature{}),
773773 };
774774 result[@enumToInt(Feature.sea_islands)] = .{
775775 .index = @enumToInt(Feature.sea_islands),
......@@ -794,21 +794,21 @@ pub const all_features = blk: {
794794 .name = @tagName(Feature.sgpr_init_bug),
795795 .llvm_name = "sgpr-init-bug",
796796 .description = "VI SGPR initialization bug requiring a fixed SGPR allocation size",
797 .dependencies = 0,
797 .dependencies = featureSet(&[_]Feature{}),
798798 };
799799 result[@enumToInt(Feature.si_scheduler)] = .{
800800 .index = @enumToInt(Feature.si_scheduler),
801801 .name = @tagName(Feature.si_scheduler),
802802 .llvm_name = "si-scheduler",
803803 .description = "Enable SI Machine Scheduler",
804 .dependencies = 0,
804 .dependencies = featureSet(&[_]Feature{}),
805805 };
806806 result[@enumToInt(Feature.smem_to_vector_write_hazard)] = .{
807807 .index = @enumToInt(Feature.smem_to_vector_write_hazard),
808808 .name = @tagName(Feature.smem_to_vector_write_hazard),
809809 .llvm_name = "smem-to-vector-write-hazard",
810810 .description = "s_load_dword followed by v_cmp page faults",
811 .dependencies = 0,
811 .dependencies = featureSet(&[_]Feature{}),
812812 };
813813 result[@enumToInt(Feature.southern_islands)] = .{
814814 .index = @enumToInt(Feature.southern_islands),
......@@ -832,77 +832,77 @@ pub const all_features = blk: {
832832 .name = @tagName(Feature.sram_ecc),
833833 .llvm_name = "sram-ecc",
834834 .description = "Enable SRAM ECC",
835 .dependencies = 0,
835 .dependencies = featureSet(&[_]Feature{}),
836836 };
837837 result[@enumToInt(Feature.trap_handler)] = .{
838838 .index = @enumToInt(Feature.trap_handler),
839839 .name = @tagName(Feature.trap_handler),
840840 .llvm_name = "trap-handler",
841841 .description = "Trap handler support",
842 .dependencies = 0,
842 .dependencies = featureSet(&[_]Feature{}),
843843 };
844844 result[@enumToInt(Feature.trig_reduced_range)] = .{
845845 .index = @enumToInt(Feature.trig_reduced_range),
846846 .name = @tagName(Feature.trig_reduced_range),
847847 .llvm_name = "trig-reduced-range",
848848 .description = "Requires use of fract on arguments to trig instructions",
849 .dependencies = 0,
849 .dependencies = featureSet(&[_]Feature{}),
850850 };
851851 result[@enumToInt(Feature.unaligned_buffer_access)] = .{
852852 .index = @enumToInt(Feature.unaligned_buffer_access),
853853 .name = @tagName(Feature.unaligned_buffer_access),
854854 .llvm_name = "unaligned-buffer-access",
855855 .description = "Support unaligned global loads and stores",
856 .dependencies = 0,
856 .dependencies = featureSet(&[_]Feature{}),
857857 };
858858 result[@enumToInt(Feature.unaligned_scratch_access)] = .{
859859 .index = @enumToInt(Feature.unaligned_scratch_access),
860860 .name = @tagName(Feature.unaligned_scratch_access),
861861 .llvm_name = "unaligned-scratch-access",
862862 .description = "Support unaligned scratch loads and stores",
863 .dependencies = 0,
863 .dependencies = featureSet(&[_]Feature{}),
864864 };
865865 result[@enumToInt(Feature.unpacked_d16_vmem)] = .{
866866 .index = @enumToInt(Feature.unpacked_d16_vmem),
867867 .name = @tagName(Feature.unpacked_d16_vmem),
868868 .llvm_name = "unpacked-d16-vmem",
869869 .description = "Has unpacked d16 vmem instructions",
870 .dependencies = 0,
870 .dependencies = featureSet(&[_]Feature{}),
871871 };
872872 result[@enumToInt(Feature.unsafe_ds_offset_folding)] = .{
873873 .index = @enumToInt(Feature.unsafe_ds_offset_folding),
874874 .name = @tagName(Feature.unsafe_ds_offset_folding),
875875 .llvm_name = "unsafe-ds-offset-folding",
876876 .description = "Force using DS instruction immediate offsets on SI",
877 .dependencies = 0,
877 .dependencies = featureSet(&[_]Feature{}),
878878 };
879879 result[@enumToInt(Feature.vcmpx_exec_war_hazard)] = .{
880880 .index = @enumToInt(Feature.vcmpx_exec_war_hazard),
881881 .name = @tagName(Feature.vcmpx_exec_war_hazard),
882882 .llvm_name = "vcmpx-exec-war-hazard",
883883 .description = "V_CMPX WAR hazard on EXEC (V_CMPX issue ONLY)",
884 .dependencies = 0,
884 .dependencies = featureSet(&[_]Feature{}),
885885 };
886886 result[@enumToInt(Feature.vcmpx_permlane_hazard)] = .{
887887 .index = @enumToInt(Feature.vcmpx_permlane_hazard),
888888 .name = @tagName(Feature.vcmpx_permlane_hazard),
889889 .llvm_name = "vcmpx-permlane-hazard",
890890 .description = "TODO: describe me",
891 .dependencies = 0,
891 .dependencies = featureSet(&[_]Feature{}),
892892 };
893893 result[@enumToInt(Feature.vgpr_index_mode)] = .{
894894 .index = @enumToInt(Feature.vgpr_index_mode),
895895 .name = @tagName(Feature.vgpr_index_mode),
896896 .llvm_name = "vgpr-index-mode",
897897 .description = "Has VGPR mode register indexing",
898 .dependencies = 0,
898 .dependencies = featureSet(&[_]Feature{}),
899899 };
900900 result[@enumToInt(Feature.vmem_to_scalar_write_hazard)] = .{
901901 .index = @enumToInt(Feature.vmem_to_scalar_write_hazard),
902902 .name = @tagName(Feature.vmem_to_scalar_write_hazard),
903903 .llvm_name = "vmem-to-scalar-write-hazard",
904904 .description = "VMEM instruction followed by scalar writing to EXEC mask, M0 or SGPR leads to incorrect execution.",
905 .dependencies = 0,
905 .dependencies = featureSet(&[_]Feature{}),
906906 };
907907 result[@enumToInt(Feature.volcanic_islands)] = .{
908908 .index = @enumToInt(Feature.volcanic_islands),
......@@ -939,49 +939,49 @@ pub const all_features = blk: {
939939 .name = @tagName(Feature.vop3_literal),
940940 .llvm_name = "vop3-literal",
941941 .description = "Can use one literal in VOP3",
942 .dependencies = 0,
942 .dependencies = featureSet(&[_]Feature{}),
943943 };
944944 result[@enumToInt(Feature.vop3p)] = .{
945945 .index = @enumToInt(Feature.vop3p),
946946 .name = @tagName(Feature.vop3p),
947947 .llvm_name = "vop3p",
948948 .description = "Has VOP3P packed instructions",
949 .dependencies = 0,
949 .dependencies = featureSet(&[_]Feature{}),
950950 };
951951 result[@enumToInt(Feature.vscnt)] = .{
952952 .index = @enumToInt(Feature.vscnt),
953953 .name = @tagName(Feature.vscnt),
954954 .llvm_name = "vscnt",
955955 .description = "Has separate store vscnt counter",
956 .dependencies = 0,
956 .dependencies = featureSet(&[_]Feature{}),
957957 };
958958 result[@enumToInt(Feature.wavefrontsize16)] = .{
959959 .index = @enumToInt(Feature.wavefrontsize16),
960960 .name = @tagName(Feature.wavefrontsize16),
961961 .llvm_name = "wavefrontsize16",
962962 .description = "The number of threads per wavefront",
963 .dependencies = 0,
963 .dependencies = featureSet(&[_]Feature{}),
964964 };
965965 result[@enumToInt(Feature.wavefrontsize32)] = .{
966966 .index = @enumToInt(Feature.wavefrontsize32),
967967 .name = @tagName(Feature.wavefrontsize32),
968968 .llvm_name = "wavefrontsize32",
969969 .description = "The number of threads per wavefront",
970 .dependencies = 0,
970 .dependencies = featureSet(&[_]Feature{}),
971971 };
972972 result[@enumToInt(Feature.wavefrontsize64)] = .{
973973 .index = @enumToInt(Feature.wavefrontsize64),
974974 .name = @tagName(Feature.wavefrontsize64),
975975 .llvm_name = "wavefrontsize64",
976976 .description = "The number of threads per wavefront",
977 .dependencies = 0,
977 .dependencies = featureSet(&[_]Feature{}),
978978 };
979979 result[@enumToInt(Feature.xnack)] = .{
980980 .index = @enumToInt(Feature.xnack),
981981 .name = @tagName(Feature.xnack),
982982 .llvm_name = "xnack",
983983 .description = "Enable XNACK support",
984 .dependencies = 0,
984 .dependencies = featureSet(&[_]Feature{}),
985985 };
986986 break :blk result;
987987};
lib/std/target/arm.zig+98-98
......@@ -182,147 +182,147 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
182182
183183pub const all_features = blk: {
184184 const len = @typeInfo(Feature).Enum.fields.len;
185 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
185 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
186186 var result: [len]Cpu.Feature = undefined;
187187 result[@enumToInt(Feature.@"32bit")] = .{
188188 .index = @enumToInt(Feature.@"32bit"),
189189 .name = @tagName(Feature.@"32bit"),
190190 .llvm_name = "32bit",
191191 .description = "Prefer 32-bit Thumb instrs",
192 .dependencies = 0,
192 .dependencies = featureSet(&[_]Feature{}),
193193 };
194194 result[@enumToInt(Feature.@"8msecext")] = .{
195195 .index = @enumToInt(Feature.@"8msecext"),
196196 .name = @tagName(Feature.@"8msecext"),
197197 .llvm_name = "8msecext",
198198 .description = "Enable support for ARMv8-M Security Extensions",
199 .dependencies = 0,
199 .dependencies = featureSet(&[_]Feature{}),
200200 };
201201 result[@enumToInt(Feature.a12)] = .{
202202 .index = @enumToInt(Feature.a12),
203203 .name = @tagName(Feature.a12),
204204 .llvm_name = "a12",
205205 .description = "Cortex-A12 ARM processors",
206 .dependencies = 0,
206 .dependencies = featureSet(&[_]Feature{}),
207207 };
208208 result[@enumToInt(Feature.a15)] = .{
209209 .index = @enumToInt(Feature.a15),
210210 .name = @tagName(Feature.a15),
211211 .llvm_name = "a15",
212212 .description = "Cortex-A15 ARM processors",
213 .dependencies = 0,
213 .dependencies = featureSet(&[_]Feature{}),
214214 };
215215 result[@enumToInt(Feature.a17)] = .{
216216 .index = @enumToInt(Feature.a17),
217217 .name = @tagName(Feature.a17),
218218 .llvm_name = "a17",
219219 .description = "Cortex-A17 ARM processors",
220 .dependencies = 0,
220 .dependencies = featureSet(&[_]Feature{}),
221221 };
222222 result[@enumToInt(Feature.a32)] = .{
223223 .index = @enumToInt(Feature.a32),
224224 .name = @tagName(Feature.a32),
225225 .llvm_name = "a32",
226226 .description = "Cortex-A32 ARM processors",
227 .dependencies = 0,
227 .dependencies = featureSet(&[_]Feature{}),
228228 };
229229 result[@enumToInt(Feature.a35)] = .{
230230 .index = @enumToInt(Feature.a35),
231231 .name = @tagName(Feature.a35),
232232 .llvm_name = "a35",
233233 .description = "Cortex-A35 ARM processors",
234 .dependencies = 0,
234 .dependencies = featureSet(&[_]Feature{}),
235235 };
236236 result[@enumToInt(Feature.a5)] = .{
237237 .index = @enumToInt(Feature.a5),
238238 .name = @tagName(Feature.a5),
239239 .llvm_name = "a5",
240240 .description = "Cortex-A5 ARM processors",
241 .dependencies = 0,
241 .dependencies = featureSet(&[_]Feature{}),
242242 };
243243 result[@enumToInt(Feature.a53)] = .{
244244 .index = @enumToInt(Feature.a53),
245245 .name = @tagName(Feature.a53),
246246 .llvm_name = "a53",
247247 .description = "Cortex-A53 ARM processors",
248 .dependencies = 0,
248 .dependencies = featureSet(&[_]Feature{}),
249249 };
250250 result[@enumToInt(Feature.a55)] = .{
251251 .index = @enumToInt(Feature.a55),
252252 .name = @tagName(Feature.a55),
253253 .llvm_name = "a55",
254254 .description = "Cortex-A55 ARM processors",
255 .dependencies = 0,
255 .dependencies = featureSet(&[_]Feature{}),
256256 };
257257 result[@enumToInt(Feature.a57)] = .{
258258 .index = @enumToInt(Feature.a57),
259259 .name = @tagName(Feature.a57),
260260 .llvm_name = "a57",
261261 .description = "Cortex-A57 ARM processors",
262 .dependencies = 0,
262 .dependencies = featureSet(&[_]Feature{}),
263263 };
264264 result[@enumToInt(Feature.a7)] = .{
265265 .index = @enumToInt(Feature.a7),
266266 .name = @tagName(Feature.a7),
267267 .llvm_name = "a7",
268268 .description = "Cortex-A7 ARM processors",
269 .dependencies = 0,
269 .dependencies = featureSet(&[_]Feature{}),
270270 };
271271 result[@enumToInt(Feature.a72)] = .{
272272 .index = @enumToInt(Feature.a72),
273273 .name = @tagName(Feature.a72),
274274 .llvm_name = "a72",
275275 .description = "Cortex-A72 ARM processors",
276 .dependencies = 0,
276 .dependencies = featureSet(&[_]Feature{}),
277277 };
278278 result[@enumToInt(Feature.a73)] = .{
279279 .index = @enumToInt(Feature.a73),
280280 .name = @tagName(Feature.a73),
281281 .llvm_name = "a73",
282282 .description = "Cortex-A73 ARM processors",
283 .dependencies = 0,
283 .dependencies = featureSet(&[_]Feature{}),
284284 };
285285 result[@enumToInt(Feature.a75)] = .{
286286 .index = @enumToInt(Feature.a75),
287287 .name = @tagName(Feature.a75),
288288 .llvm_name = "a75",
289289 .description = "Cortex-A75 ARM processors",
290 .dependencies = 0,
290 .dependencies = featureSet(&[_]Feature{}),
291291 };
292292 result[@enumToInt(Feature.a76)] = .{
293293 .index = @enumToInt(Feature.a76),
294294 .name = @tagName(Feature.a76),
295295 .llvm_name = "a76",
296296 .description = "Cortex-A76 ARM processors",
297 .dependencies = 0,
297 .dependencies = featureSet(&[_]Feature{}),
298298 };
299299 result[@enumToInt(Feature.a8)] = .{
300300 .index = @enumToInt(Feature.a8),
301301 .name = @tagName(Feature.a8),
302302 .llvm_name = "a8",
303303 .description = "Cortex-A8 ARM processors",
304 .dependencies = 0,
304 .dependencies = featureSet(&[_]Feature{}),
305305 };
306306 result[@enumToInt(Feature.a9)] = .{
307307 .index = @enumToInt(Feature.a9),
308308 .name = @tagName(Feature.a9),
309309 .llvm_name = "a9",
310310 .description = "Cortex-A9 ARM processors",
311 .dependencies = 0,
311 .dependencies = featureSet(&[_]Feature{}),
312312 };
313313 result[@enumToInt(Feature.aclass)] = .{
314314 .index = @enumToInt(Feature.aclass),
315315 .name = @tagName(Feature.aclass),
316316 .llvm_name = "aclass",
317317 .description = "Is application profile ('A' series)",
318 .dependencies = 0,
318 .dependencies = featureSet(&[_]Feature{}),
319319 };
320320 result[@enumToInt(Feature.acquire_release)] = .{
321321 .index = @enumToInt(Feature.acquire_release),
322322 .name = @tagName(Feature.acquire_release),
323323 .llvm_name = "acquire-release",
324324 .description = "Has v8 acquire/release (lda/ldaex etc) instructions",
325 .dependencies = 0,
325 .dependencies = featureSet(&[_]Feature{}),
326326 };
327327 result[@enumToInt(Feature.aes)] = .{
328328 .index = @enumToInt(Feature.aes),
......@@ -338,35 +338,35 @@ pub const all_features = blk: {
338338 .name = @tagName(Feature.armv2),
339339 .llvm_name = "armv2",
340340 .description = "ARMv2 architecture",
341 .dependencies = 0,
341 .dependencies = featureSet(&[_]Feature{}),
342342 };
343343 result[@enumToInt(Feature.armv2a)] = .{
344344 .index = @enumToInt(Feature.armv2a),
345345 .name = @tagName(Feature.armv2a),
346346 .llvm_name = "armv2a",
347347 .description = "ARMv2a architecture",
348 .dependencies = 0,
348 .dependencies = featureSet(&[_]Feature{}),
349349 };
350350 result[@enumToInt(Feature.armv3)] = .{
351351 .index = @enumToInt(Feature.armv3),
352352 .name = @tagName(Feature.armv3),
353353 .llvm_name = "armv3",
354354 .description = "ARMv3 architecture",
355 .dependencies = 0,
355 .dependencies = featureSet(&[_]Feature{}),
356356 };
357357 result[@enumToInt(Feature.armv3m)] = .{
358358 .index = @enumToInt(Feature.armv3m),
359359 .name = @tagName(Feature.armv3m),
360360 .llvm_name = "armv3m",
361361 .description = "ARMv3m architecture",
362 .dependencies = 0,
362 .dependencies = featureSet(&[_]Feature{}),
363363 };
364364 result[@enumToInt(Feature.armv4)] = .{
365365 .index = @enumToInt(Feature.armv4),
366366 .name = @tagName(Feature.armv4),
367367 .llvm_name = "armv4",
368368 .description = "ARMv4 architecture",
369 .dependencies = 0,
369 .dependencies = featureSet(&[_]Feature{}),
370370 };
371371 result[@enumToInt(Feature.armv4t)] = .{
372372 .index = @enumToInt(Feature.armv4t),
......@@ -766,28 +766,28 @@ pub const all_features = blk: {
766766 .name = @tagName(Feature.avoid_movs_shop),
767767 .llvm_name = "avoid-movs-shop",
768768 .description = "Avoid movs instructions with shifter operand",
769 .dependencies = 0,
769 .dependencies = featureSet(&[_]Feature{}),
770770 };
771771 result[@enumToInt(Feature.avoid_partial_cpsr)] = .{
772772 .index = @enumToInt(Feature.avoid_partial_cpsr),
773773 .name = @tagName(Feature.avoid_partial_cpsr),
774774 .llvm_name = "avoid-partial-cpsr",
775775 .description = "Avoid CPSR partial update for OOO execution",
776 .dependencies = 0,
776 .dependencies = featureSet(&[_]Feature{}),
777777 };
778778 result[@enumToInt(Feature.cheap_predicable_cpsr)] = .{
779779 .index = @enumToInt(Feature.cheap_predicable_cpsr),
780780 .name = @tagName(Feature.cheap_predicable_cpsr),
781781 .llvm_name = "cheap-predicable-cpsr",
782782 .description = "Disable +1 predication cost for instructions updating CPSR",
783 .dependencies = 0,
783 .dependencies = featureSet(&[_]Feature{}),
784784 };
785785 result[@enumToInt(Feature.crc)] = .{
786786 .index = @enumToInt(Feature.crc),
787787 .name = @tagName(Feature.crc),
788788 .llvm_name = "crc",
789789 .description = "Enable support for CRC instructions",
790 .dependencies = 0,
790 .dependencies = featureSet(&[_]Feature{}),
791791 };
792792 result[@enumToInt(Feature.crypto)] = .{
793793 .index = @enumToInt(Feature.crypto),
......@@ -805,35 +805,35 @@ pub const all_features = blk: {
805805 .name = @tagName(Feature.d32),
806806 .llvm_name = "d32",
807807 .description = "Extend FP to 32 double registers",
808 .dependencies = 0,
808 .dependencies = featureSet(&[_]Feature{}),
809809 };
810810 result[@enumToInt(Feature.db)] = .{
811811 .index = @enumToInt(Feature.db),
812812 .name = @tagName(Feature.db),
813813 .llvm_name = "db",
814814 .description = "Has data barrier (dmb/dsb) instructions",
815 .dependencies = 0,
815 .dependencies = featureSet(&[_]Feature{}),
816816 };
817817 result[@enumToInt(Feature.dfb)] = .{
818818 .index = @enumToInt(Feature.dfb),
819819 .name = @tagName(Feature.dfb),
820820 .llvm_name = "dfb",
821821 .description = "Has full data barrier (dfb) instruction",
822 .dependencies = 0,
822 .dependencies = featureSet(&[_]Feature{}),
823823 };
824824 result[@enumToInt(Feature.disable_postra_scheduler)] = .{
825825 .index = @enumToInt(Feature.disable_postra_scheduler),
826826 .name = @tagName(Feature.disable_postra_scheduler),
827827 .llvm_name = "disable-postra-scheduler",
828828 .description = "Don't schedule again after register allocation",
829 .dependencies = 0,
829 .dependencies = featureSet(&[_]Feature{}),
830830 };
831831 result[@enumToInt(Feature.dont_widen_vmovs)] = .{
832832 .index = @enumToInt(Feature.dont_widen_vmovs),
833833 .name = @tagName(Feature.dont_widen_vmovs),
834834 .llvm_name = "dont-widen-vmovs",
835835 .description = "Don't widen VMOVS to VMOVD",
836 .dependencies = 0,
836 .dependencies = featureSet(&[_]Feature{}),
837837 };
838838 result[@enumToInt(Feature.dotprod)] = .{
839839 .index = @enumToInt(Feature.dotprod),
......@@ -849,21 +849,21 @@ pub const all_features = blk: {
849849 .name = @tagName(Feature.dsp),
850850 .llvm_name = "dsp",
851851 .description = "Supports DSP instructions in ARM and/or Thumb2",
852 .dependencies = 0,
852 .dependencies = featureSet(&[_]Feature{}),
853853 };
854854 result[@enumToInt(Feature.execute_only)] = .{
855855 .index = @enumToInt(Feature.execute_only),
856856 .name = @tagName(Feature.execute_only),
857857 .llvm_name = "execute-only",
858858 .description = "Enable the generation of execute only code.",
859 .dependencies = 0,
859 .dependencies = featureSet(&[_]Feature{}),
860860 };
861861 result[@enumToInt(Feature.expand_fp_mlx)] = .{
862862 .index = @enumToInt(Feature.expand_fp_mlx),
863863 .name = @tagName(Feature.expand_fp_mlx),
864864 .llvm_name = "expand-fp-mlx",
865865 .description = "Expand VFP/NEON MLA/MLS instructions",
866 .dependencies = 0,
866 .dependencies = featureSet(&[_]Feature{}),
867867 };
868868 result[@enumToInt(Feature.exynos)] = .{
869869 .index = @enumToInt(Feature.exynos),
......@@ -937,7 +937,7 @@ pub const all_features = blk: {
937937 .name = @tagName(Feature.fp16),
938938 .llvm_name = "fp16",
939939 .description = "Enable half-precision floating point",
940 .dependencies = 0,
940 .dependencies = featureSet(&[_]Feature{}),
941941 };
942942 result[@enumToInt(Feature.fp16fml)] = .{
943943 .index = @enumToInt(Feature.fp16fml),
......@@ -962,14 +962,14 @@ pub const all_features = blk: {
962962 .name = @tagName(Feature.fpao),
963963 .llvm_name = "fpao",
964964 .description = "Enable fast computation of positive address offsets",
965 .dependencies = 0,
965 .dependencies = featureSet(&[_]Feature{}),
966966 };
967967 result[@enumToInt(Feature.fpregs)] = .{
968968 .index = @enumToInt(Feature.fpregs),
969969 .name = @tagName(Feature.fpregs),
970970 .llvm_name = "fpregs",
971971 .description = "Enable FP registers",
972 .dependencies = 0,
972 .dependencies = featureSet(&[_]Feature{}),
973973 };
974974 result[@enumToInt(Feature.fpregs16)] = .{
975975 .index = @enumToInt(Feature.fpregs16),
......@@ -1004,28 +1004,28 @@ pub const all_features = blk: {
10041004 .name = @tagName(Feature.fuse_aes),
10051005 .llvm_name = "fuse-aes",
10061006 .description = "CPU fuses AES crypto operations",
1007 .dependencies = 0,
1007 .dependencies = featureSet(&[_]Feature{}),
10081008 };
10091009 result[@enumToInt(Feature.fuse_literals)] = .{
10101010 .index = @enumToInt(Feature.fuse_literals),
10111011 .name = @tagName(Feature.fuse_literals),
10121012 .llvm_name = "fuse-literals",
10131013 .description = "CPU fuses literal generation operations",
1014 .dependencies = 0,
1014 .dependencies = featureSet(&[_]Feature{}),
10151015 };
10161016 result[@enumToInt(Feature.hwdiv)] = .{
10171017 .index = @enumToInt(Feature.hwdiv),
10181018 .name = @tagName(Feature.hwdiv),
10191019 .llvm_name = "hwdiv",
10201020 .description = "Enable divide instructions in Thumb",
1021 .dependencies = 0,
1021 .dependencies = featureSet(&[_]Feature{}),
10221022 };
10231023 result[@enumToInt(Feature.hwdiv_arm)] = .{
10241024 .index = @enumToInt(Feature.hwdiv_arm),
10251025 .name = @tagName(Feature.hwdiv_arm),
10261026 .llvm_name = "hwdiv-arm",
10271027 .description = "Enable divide instructions in ARM mode",
1028 .dependencies = 0,
1028 .dependencies = featureSet(&[_]Feature{}),
10291029 };
10301030 result[@enumToInt(Feature.iwmmxt)] = .{
10311031 .index = @enumToInt(Feature.iwmmxt),
......@@ -1050,63 +1050,63 @@ pub const all_features = blk: {
10501050 .name = @tagName(Feature.krait),
10511051 .llvm_name = "krait",
10521052 .description = "Qualcomm Krait processors",
1053 .dependencies = 0,
1053 .dependencies = featureSet(&[_]Feature{}),
10541054 };
10551055 result[@enumToInt(Feature.kryo)] = .{
10561056 .index = @enumToInt(Feature.kryo),
10571057 .name = @tagName(Feature.kryo),
10581058 .llvm_name = "kryo",
10591059 .description = "Qualcomm Kryo processors",
1060 .dependencies = 0,
1060 .dependencies = featureSet(&[_]Feature{}),
10611061 };
10621062 result[@enumToInt(Feature.lob)] = .{
10631063 .index = @enumToInt(Feature.lob),
10641064 .name = @tagName(Feature.lob),
10651065 .llvm_name = "lob",
10661066 .description = "Enable Low Overhead Branch extensions",
1067 .dependencies = 0,
1067 .dependencies = featureSet(&[_]Feature{}),
10681068 };
10691069 result[@enumToInt(Feature.long_calls)] = .{
10701070 .index = @enumToInt(Feature.long_calls),
10711071 .name = @tagName(Feature.long_calls),
10721072 .llvm_name = "long-calls",
10731073 .description = "Generate calls via indirect call instructions",
1074 .dependencies = 0,
1074 .dependencies = featureSet(&[_]Feature{}),
10751075 };
10761076 result[@enumToInt(Feature.loop_align)] = .{
10771077 .index = @enumToInt(Feature.loop_align),
10781078 .name = @tagName(Feature.loop_align),
10791079 .llvm_name = "loop-align",
10801080 .description = "Prefer 32-bit alignment for loops",
1081 .dependencies = 0,
1081 .dependencies = featureSet(&[_]Feature{}),
10821082 };
10831083 result[@enumToInt(Feature.m3)] = .{
10841084 .index = @enumToInt(Feature.m3),
10851085 .name = @tagName(Feature.m3),
10861086 .llvm_name = "m3",
10871087 .description = "Cortex-M3 ARM processors",
1088 .dependencies = 0,
1088 .dependencies = featureSet(&[_]Feature{}),
10891089 };
10901090 result[@enumToInt(Feature.mclass)] = .{
10911091 .index = @enumToInt(Feature.mclass),
10921092 .name = @tagName(Feature.mclass),
10931093 .llvm_name = "mclass",
10941094 .description = "Is microcontroller profile ('M' series)",
1095 .dependencies = 0,
1095 .dependencies = featureSet(&[_]Feature{}),
10961096 };
10971097 result[@enumToInt(Feature.mp)] = .{
10981098 .index = @enumToInt(Feature.mp),
10991099 .name = @tagName(Feature.mp),
11001100 .llvm_name = "mp",
11011101 .description = "Supports Multiprocessing extension",
1102 .dependencies = 0,
1102 .dependencies = featureSet(&[_]Feature{}),
11031103 };
11041104 result[@enumToInt(Feature.muxed_units)] = .{
11051105 .index = @enumToInt(Feature.muxed_units),
11061106 .name = @tagName(Feature.muxed_units),
11071107 .llvm_name = "muxed-units",
11081108 .description = "Has muxed AGU and NEON/FPU",
1109 .dependencies = 0,
1109 .dependencies = featureSet(&[_]Feature{}),
11101110 };
11111111 result[@enumToInt(Feature.mve)] = .{
11121112 .index = @enumToInt(Feature.mve),
......@@ -1136,7 +1136,7 @@ pub const all_features = blk: {
11361136 .name = @tagName(Feature.nacl_trap),
11371137 .llvm_name = "nacl-trap",
11381138 .description = "NaCl trap",
1139 .dependencies = 0,
1139 .dependencies = featureSet(&[_]Feature{}),
11401140 };
11411141 result[@enumToInt(Feature.neon)] = .{
11421142 .index = @enumToInt(Feature.neon),
......@@ -1152,147 +1152,147 @@ pub const all_features = blk: {
11521152 .name = @tagName(Feature.neon_fpmovs),
11531153 .llvm_name = "neon-fpmovs",
11541154 .description = "Convert VMOVSR, VMOVRS, VMOVS to NEON",
1155 .dependencies = 0,
1155 .dependencies = featureSet(&[_]Feature{}),
11561156 };
11571157 result[@enumToInt(Feature.neonfp)] = .{
11581158 .index = @enumToInt(Feature.neonfp),
11591159 .name = @tagName(Feature.neonfp),
11601160 .llvm_name = "neonfp",
11611161 .description = "Use NEON for single precision FP",
1162 .dependencies = 0,
1162 .dependencies = featureSet(&[_]Feature{}),
11631163 };
11641164 result[@enumToInt(Feature.no_branch_predictor)] = .{
11651165 .index = @enumToInt(Feature.no_branch_predictor),
11661166 .name = @tagName(Feature.no_branch_predictor),
11671167 .llvm_name = "no-branch-predictor",
11681168 .description = "Has no branch predictor",
1169 .dependencies = 0,
1169 .dependencies = featureSet(&[_]Feature{}),
11701170 };
11711171 result[@enumToInt(Feature.no_movt)] = .{
11721172 .index = @enumToInt(Feature.no_movt),
11731173 .name = @tagName(Feature.no_movt),
11741174 .llvm_name = "no-movt",
11751175 .description = "Don't use movt/movw pairs for 32-bit imms",
1176 .dependencies = 0,
1176 .dependencies = featureSet(&[_]Feature{}),
11771177 };
11781178 result[@enumToInt(Feature.no_neg_immediates)] = .{
11791179 .index = @enumToInt(Feature.no_neg_immediates),
11801180 .name = @tagName(Feature.no_neg_immediates),
11811181 .llvm_name = "no-neg-immediates",
11821182 .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.",
1183 .dependencies = 0,
1183 .dependencies = featureSet(&[_]Feature{}),
11841184 };
11851185 result[@enumToInt(Feature.noarm)] = .{
11861186 .index = @enumToInt(Feature.noarm),
11871187 .name = @tagName(Feature.noarm),
11881188 .llvm_name = "noarm",
11891189 .description = "Does not support ARM mode execution",
1190 .dependencies = 0,
1190 .dependencies = featureSet(&[_]Feature{}),
11911191 };
11921192 result[@enumToInt(Feature.nonpipelined_vfp)] = .{
11931193 .index = @enumToInt(Feature.nonpipelined_vfp),
11941194 .name = @tagName(Feature.nonpipelined_vfp),
11951195 .llvm_name = "nonpipelined-vfp",
11961196 .description = "VFP instructions are not pipelined",
1197 .dependencies = 0,
1197 .dependencies = featureSet(&[_]Feature{}),
11981198 };
11991199 result[@enumToInt(Feature.perfmon)] = .{
12001200 .index = @enumToInt(Feature.perfmon),
12011201 .name = @tagName(Feature.perfmon),
12021202 .llvm_name = "perfmon",
12031203 .description = "Enable support for Performance Monitor extensions",
1204 .dependencies = 0,
1204 .dependencies = featureSet(&[_]Feature{}),
12051205 };
12061206 result[@enumToInt(Feature.prefer_ishst)] = .{
12071207 .index = @enumToInt(Feature.prefer_ishst),
12081208 .name = @tagName(Feature.prefer_ishst),
12091209 .llvm_name = "prefer-ishst",
12101210 .description = "Prefer ISHST barriers",
1211 .dependencies = 0,
1211 .dependencies = featureSet(&[_]Feature{}),
12121212 };
12131213 result[@enumToInt(Feature.prefer_vmovsr)] = .{
12141214 .index = @enumToInt(Feature.prefer_vmovsr),
12151215 .name = @tagName(Feature.prefer_vmovsr),
12161216 .llvm_name = "prefer-vmovsr",
12171217 .description = "Prefer VMOVSR",
1218 .dependencies = 0,
1218 .dependencies = featureSet(&[_]Feature{}),
12191219 };
12201220 result[@enumToInt(Feature.prof_unpr)] = .{
12211221 .index = @enumToInt(Feature.prof_unpr),
12221222 .name = @tagName(Feature.prof_unpr),
12231223 .llvm_name = "prof-unpr",
12241224 .description = "Is profitable to unpredicate",
1225 .dependencies = 0,
1225 .dependencies = featureSet(&[_]Feature{}),
12261226 };
12271227 result[@enumToInt(Feature.r4)] = .{
12281228 .index = @enumToInt(Feature.r4),
12291229 .name = @tagName(Feature.r4),
12301230 .llvm_name = "r4",
12311231 .description = "Cortex-R4 ARM processors",
1232 .dependencies = 0,
1232 .dependencies = featureSet(&[_]Feature{}),
12331233 };
12341234 result[@enumToInt(Feature.r5)] = .{
12351235 .index = @enumToInt(Feature.r5),
12361236 .name = @tagName(Feature.r5),
12371237 .llvm_name = "r5",
12381238 .description = "Cortex-R5 ARM processors",
1239 .dependencies = 0,
1239 .dependencies = featureSet(&[_]Feature{}),
12401240 };
12411241 result[@enumToInt(Feature.r52)] = .{
12421242 .index = @enumToInt(Feature.r52),
12431243 .name = @tagName(Feature.r52),
12441244 .llvm_name = "r52",
12451245 .description = "Cortex-R52 ARM processors",
1246 .dependencies = 0,
1246 .dependencies = featureSet(&[_]Feature{}),
12471247 };
12481248 result[@enumToInt(Feature.r7)] = .{
12491249 .index = @enumToInt(Feature.r7),
12501250 .name = @tagName(Feature.r7),
12511251 .llvm_name = "r7",
12521252 .description = "Cortex-R7 ARM processors",
1253 .dependencies = 0,
1253 .dependencies = featureSet(&[_]Feature{}),
12541254 };
12551255 result[@enumToInt(Feature.ras)] = .{
12561256 .index = @enumToInt(Feature.ras),
12571257 .name = @tagName(Feature.ras),
12581258 .llvm_name = "ras",
12591259 .description = "Enable Reliability, Availability and Serviceability extensions",
1260 .dependencies = 0,
1260 .dependencies = featureSet(&[_]Feature{}),
12611261 };
12621262 result[@enumToInt(Feature.rclass)] = .{
12631263 .index = @enumToInt(Feature.rclass),
12641264 .name = @tagName(Feature.rclass),
12651265 .llvm_name = "rclass",
12661266 .description = "Is realtime profile ('R' series)",
1267 .dependencies = 0,
1267 .dependencies = featureSet(&[_]Feature{}),
12681268 };
12691269 result[@enumToInt(Feature.read_tp_hard)] = .{
12701270 .index = @enumToInt(Feature.read_tp_hard),
12711271 .name = @tagName(Feature.read_tp_hard),
12721272 .llvm_name = "read-tp-hard",
12731273 .description = "Reading thread pointer from register",
1274 .dependencies = 0,
1274 .dependencies = featureSet(&[_]Feature{}),
12751275 };
12761276 result[@enumToInt(Feature.reserve_r9)] = .{
12771277 .index = @enumToInt(Feature.reserve_r9),
12781278 .name = @tagName(Feature.reserve_r9),
12791279 .llvm_name = "reserve-r9",
12801280 .description = "Reserve R9, making it unavailable as GPR",
1281 .dependencies = 0,
1281 .dependencies = featureSet(&[_]Feature{}),
12821282 };
12831283 result[@enumToInt(Feature.ret_addr_stack)] = .{
12841284 .index = @enumToInt(Feature.ret_addr_stack),
12851285 .name = @tagName(Feature.ret_addr_stack),
12861286 .llvm_name = "ret-addr-stack",
12871287 .description = "Has return address stack",
1288 .dependencies = 0,
1288 .dependencies = featureSet(&[_]Feature{}),
12891289 };
12901290 result[@enumToInt(Feature.sb)] = .{
12911291 .index = @enumToInt(Feature.sb),
12921292 .name = @tagName(Feature.sb),
12931293 .llvm_name = "sb",
12941294 .description = "Enable v8.5a Speculation Barrier",
1295 .dependencies = 0,
1295 .dependencies = featureSet(&[_]Feature{}),
12961296 };
12971297 result[@enumToInt(Feature.sha2)] = .{
12981298 .index = @enumToInt(Feature.sha2),
......@@ -1308,49 +1308,49 @@ pub const all_features = blk: {
13081308 .name = @tagName(Feature.slow_fp_brcc),
13091309 .llvm_name = "slow-fp-brcc",
13101310 .description = "FP compare + branch is slow",
1311 .dependencies = 0,
1311 .dependencies = featureSet(&[_]Feature{}),
13121312 };
13131313 result[@enumToInt(Feature.slow_load_D_subreg)] = .{
13141314 .index = @enumToInt(Feature.slow_load_D_subreg),
13151315 .name = @tagName(Feature.slow_load_D_subreg),
13161316 .llvm_name = "slow-load-D-subreg",
13171317 .description = "Loading into D subregs is slow",
1318 .dependencies = 0,
1318 .dependencies = featureSet(&[_]Feature{}),
13191319 };
13201320 result[@enumToInt(Feature.slow_odd_reg)] = .{
13211321 .index = @enumToInt(Feature.slow_odd_reg),
13221322 .name = @tagName(Feature.slow_odd_reg),
13231323 .llvm_name = "slow-odd-reg",
13241324 .description = "VLDM/VSTM starting with an odd register is slow",
1325 .dependencies = 0,
1325 .dependencies = featureSet(&[_]Feature{}),
13261326 };
13271327 result[@enumToInt(Feature.slow_vdup32)] = .{
13281328 .index = @enumToInt(Feature.slow_vdup32),
13291329 .name = @tagName(Feature.slow_vdup32),
13301330 .llvm_name = "slow-vdup32",
13311331 .description = "Has slow VDUP32 - prefer VMOV",
1332 .dependencies = 0,
1332 .dependencies = featureSet(&[_]Feature{}),
13331333 };
13341334 result[@enumToInt(Feature.slow_vgetlni32)] = .{
13351335 .index = @enumToInt(Feature.slow_vgetlni32),
13361336 .name = @tagName(Feature.slow_vgetlni32),
13371337 .llvm_name = "slow-vgetlni32",
13381338 .description = "Has slow VGETLNi32 - prefer VMOV",
1339 .dependencies = 0,
1339 .dependencies = featureSet(&[_]Feature{}),
13401340 };
13411341 result[@enumToInt(Feature.slowfpvmlx)] = .{
13421342 .index = @enumToInt(Feature.slowfpvmlx),
13431343 .name = @tagName(Feature.slowfpvmlx),
13441344 .llvm_name = "slowfpvmlx",
13451345 .description = "Disable VFP / NEON MAC instructions",
1346 .dependencies = 0,
1346 .dependencies = featureSet(&[_]Feature{}),
13471347 };
13481348 result[@enumToInt(Feature.soft_float)] = .{
13491349 .index = @enumToInt(Feature.soft_float),
13501350 .name = @tagName(Feature.soft_float),
13511351 .llvm_name = "soft-float",
13521352 .description = "Use software floating point features.",
1353 .dependencies = 0,
1353 .dependencies = featureSet(&[_]Feature{}),
13541354 };
13551355 result[@enumToInt(Feature.splat_vfp_neon)] = .{
13561356 .index = @enumToInt(Feature.splat_vfp_neon),
......@@ -1366,56 +1366,56 @@ pub const all_features = blk: {
13661366 .name = @tagName(Feature.strict_align),
13671367 .llvm_name = "strict-align",
13681368 .description = "Disallow all unaligned memory access",
1369 .dependencies = 0,
1369 .dependencies = featureSet(&[_]Feature{}),
13701370 };
13711371 result[@enumToInt(Feature.swift)] = .{
13721372 .index = @enumToInt(Feature.swift),
13731373 .name = @tagName(Feature.swift),
13741374 .llvm_name = "swift",
13751375 .description = "Swift ARM processors",
1376 .dependencies = 0,
1376 .dependencies = featureSet(&[_]Feature{}),
13771377 };
13781378 result[@enumToInt(Feature.thumb_mode)] = .{
13791379 .index = @enumToInt(Feature.thumb_mode),
13801380 .name = @tagName(Feature.thumb_mode),
13811381 .llvm_name = "thumb-mode",
13821382 .description = "Thumb mode",
1383 .dependencies = 0,
1383 .dependencies = featureSet(&[_]Feature{}),
13841384 };
13851385 result[@enumToInt(Feature.thumb2)] = .{
13861386 .index = @enumToInt(Feature.thumb2),
13871387 .name = @tagName(Feature.thumb2),
13881388 .llvm_name = "thumb2",
13891389 .description = "Enable Thumb2 instructions",
1390 .dependencies = 0,
1390 .dependencies = featureSet(&[_]Feature{}),
13911391 };
13921392 result[@enumToInt(Feature.trustzone)] = .{
13931393 .index = @enumToInt(Feature.trustzone),
13941394 .name = @tagName(Feature.trustzone),
13951395 .llvm_name = "trustzone",
13961396 .description = "Enable support for TrustZone security extensions",
1397 .dependencies = 0,
1397 .dependencies = featureSet(&[_]Feature{}),
13981398 };
13991399 result[@enumToInt(Feature.use_aa)] = .{
14001400 .index = @enumToInt(Feature.use_aa),
14011401 .name = @tagName(Feature.use_aa),
14021402 .llvm_name = "use-aa",
14031403 .description = "Use alias analysis during codegen",
1404 .dependencies = 0,
1404 .dependencies = featureSet(&[_]Feature{}),
14051405 };
14061406 result[@enumToInt(Feature.use_misched)] = .{
14071407 .index = @enumToInt(Feature.use_misched),
14081408 .name = @tagName(Feature.use_misched),
14091409 .llvm_name = "use-misched",
14101410 .description = "Use the MachineScheduler",
1411 .dependencies = 0,
1411 .dependencies = featureSet(&[_]Feature{}),
14121412 };
14131413 result[@enumToInt(Feature.v4t)] = .{
14141414 .index = @enumToInt(Feature.v4t),
14151415 .name = @tagName(Feature.v4t),
14161416 .llvm_name = "v4t",
14171417 .description = "Support ARM v4T instructions",
1418 .dependencies = 0,
1418 .dependencies = featureSet(&[_]Feature{}),
14191419 };
14201420 result[@enumToInt(Feature.v5t)] = .{
14211421 .index = @enumToInt(Feature.v5t),
......@@ -1489,7 +1489,7 @@ pub const all_features = blk: {
14891489 .name = @tagName(Feature.v7clrex),
14901490 .llvm_name = "v7clrex",
14911491 .description = "Has v7 clrex instruction",
1492 .dependencies = 0,
1492 .dependencies = featureSet(&[_]Feature{}),
14931493 };
14941494 result[@enumToInt(Feature.v8)] = .{
14951495 .index = @enumToInt(Feature.v8),
......@@ -1714,28 +1714,28 @@ pub const all_features = blk: {
17141714 .name = @tagName(Feature.vldn_align),
17151715 .llvm_name = "vldn-align",
17161716 .description = "Check for VLDn unaligned access",
1717 .dependencies = 0,
1717 .dependencies = featureSet(&[_]Feature{}),
17181718 };
17191719 result[@enumToInt(Feature.vmlx_forwarding)] = .{
17201720 .index = @enumToInt(Feature.vmlx_forwarding),
17211721 .name = @tagName(Feature.vmlx_forwarding),
17221722 .llvm_name = "vmlx-forwarding",
17231723 .description = "Has multiplier accumulator forwarding",
1724 .dependencies = 0,
1724 .dependencies = featureSet(&[_]Feature{}),
17251725 };
17261726 result[@enumToInt(Feature.vmlx_hazards)] = .{
17271727 .index = @enumToInt(Feature.vmlx_hazards),
17281728 .name = @tagName(Feature.vmlx_hazards),
17291729 .llvm_name = "vmlx-hazards",
17301730 .description = "Has VMLx hazards",
1731 .dependencies = 0,
1731 .dependencies = featureSet(&[_]Feature{}),
17321732 };
17331733 result[@enumToInt(Feature.wide_stride_vfp)] = .{
17341734 .index = @enumToInt(Feature.wide_stride_vfp),
17351735 .name = @tagName(Feature.wide_stride_vfp),
17361736 .llvm_name = "wide-stride-vfp",
17371737 .description = "Use a wide stride when allocating VFP registers",
1738 .dependencies = 0,
1738 .dependencies = featureSet(&[_]Feature{}),
17391739 };
17401740 result[@enumToInt(Feature.xscale)] = .{
17411741 .index = @enumToInt(Feature.xscale),
......@@ -1751,7 +1751,7 @@ pub const all_features = blk: {
17511751 .name = @tagName(Feature.zcz),
17521752 .llvm_name = "zcz",
17531753 .description = "Has zero-cycle zeroing instructions",
1754 .dependencies = 0,
1754 .dependencies = featureSet(&[_]Feature{}),
17551755 };
17561756 break :blk result;
17571757};
......@@ -2450,7 +2450,7 @@ pub const cpu = struct {
24502450 pub const generic = Cpu{
24512451 .name = "generic",
24522452 .llvm_name = "generic",
2453 .features = 0,
2453 .features = featureSet(&[_]Feature{}),
24542454 };
24552455 pub const iwmmxt = Cpu{
24562456 .name = "iwmmxt",
lib/std/target/avr.zig+34-30
......@@ -15,7 +15,7 @@ pub const Feature = enum {
1515 avr51,
1616 avr6,
1717 avrtiny,
18 break,
18 @"break",
1919 des,
2020 eijmpcall,
2121 elpm,
......@@ -41,21 +41,21 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
4141
4242pub const all_features = blk: {
4343 const len = @typeInfo(Feature).Enum.fields.len;
44 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
44 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
4545 var result: [len]Cpu.Feature = undefined;
4646 result[@enumToInt(Feature.addsubiw)] = .{
4747 .index = @enumToInt(Feature.addsubiw),
4848 .name = @tagName(Feature.addsubiw),
4949 .llvm_name = "addsubiw",
5050 .description = "Enable 16-bit register-immediate addition and subtraction instructions",
51 .dependencies = 0,
51 .dependencies = featureSet(&[_]Feature{}),
5252 };
5353 result[@enumToInt(Feature.avr0)] = .{
5454 .index = @enumToInt(Feature.avr0),
5555 .name = @tagName(Feature.avr0),
5656 .llvm_name = "avr0",
5757 .description = "The device is a part of the avr0 family",
58 .dependencies = 0,
58 .dependencies = featureSet(&[_]Feature{}),
5959 };
6060 result[@enumToInt(Feature.avr1)] = .{
6161 .index = @enumToInt(Feature.avr1),
......@@ -86,7 +86,7 @@ pub const all_features = blk: {
8686 .description = "The device is a part of the avr25 family",
8787 .dependencies = featureSet(&[_]Feature{
8888 .avr2,
89 .break,
89 .@"break",
9090 .lpmx,
9191 .movw,
9292 .spm,
......@@ -119,7 +119,7 @@ pub const all_features = blk: {
119119 .description = "The device is a part of the avr35 family",
120120 .dependencies = featureSet(&[_]Feature{
121121 .avr3,
122 .break,
122 .@"break",
123123 .lpmx,
124124 .movw,
125125 .spm,
......@@ -132,7 +132,7 @@ pub const all_features = blk: {
132132 .description = "The device is a part of the avr4 family",
133133 .dependencies = featureSet(&[_]Feature{
134134 .avr2,
135 .break,
135 .@"break",
136136 .lpmx,
137137 .movw,
138138 .mul,
......@@ -146,7 +146,7 @@ pub const all_features = blk: {
146146 .description = "The device is a part of the avr5 family",
147147 .dependencies = featureSet(&[_]Feature{
148148 .avr3,
149 .break,
149 .@"break",
150150 .lpmx,
151151 .movw,
152152 .mul,
......@@ -180,101 +180,101 @@ pub const all_features = blk: {
180180 .description = "The device is a part of the avrtiny family",
181181 .dependencies = featureSet(&[_]Feature{
182182 .avr0,
183 .break,
183 .@"break",
184184 .sram,
185185 .tinyencoding,
186186 }),
187187 };
188 result[@enumToInt(Feature.break)] = .{
189 .index = @enumToInt(Feature.break),
190 .name = @tagName(Feature.break),
188 result[@enumToInt(Feature.@"break")] = .{
189 .index = @enumToInt(Feature.@"break"),
190 .name = @tagName(Feature.@"break"),
191191 .llvm_name = "break",
192192 .description = "The device supports the `BREAK` debugging instruction",
193 .dependencies = 0,
193 .dependencies = featureSet(&[_]Feature{}),
194194 };
195195 result[@enumToInt(Feature.des)] = .{
196196 .index = @enumToInt(Feature.des),
197197 .name = @tagName(Feature.des),
198198 .llvm_name = "des",
199199 .description = "The device supports the `DES k` encryption instruction",
200 .dependencies = 0,
200 .dependencies = featureSet(&[_]Feature{}),
201201 };
202202 result[@enumToInt(Feature.eijmpcall)] = .{
203203 .index = @enumToInt(Feature.eijmpcall),
204204 .name = @tagName(Feature.eijmpcall),
205205 .llvm_name = "eijmpcall",
206206 .description = "The device supports the `EIJMP`/`EICALL` instructions",
207 .dependencies = 0,
207 .dependencies = featureSet(&[_]Feature{}),
208208 };
209209 result[@enumToInt(Feature.elpm)] = .{
210210 .index = @enumToInt(Feature.elpm),
211211 .name = @tagName(Feature.elpm),
212212 .llvm_name = "elpm",
213213 .description = "The device supports the ELPM instruction",
214 .dependencies = 0,
214 .dependencies = featureSet(&[_]Feature{}),
215215 };
216216 result[@enumToInt(Feature.elpmx)] = .{
217217 .index = @enumToInt(Feature.elpmx),
218218 .name = @tagName(Feature.elpmx),
219219 .llvm_name = "elpmx",
220220 .description = "The device supports the `ELPM Rd, Z[+]` instructions",
221 .dependencies = 0,
221 .dependencies = featureSet(&[_]Feature{}),
222222 };
223223 result[@enumToInt(Feature.ijmpcall)] = .{
224224 .index = @enumToInt(Feature.ijmpcall),
225225 .name = @tagName(Feature.ijmpcall),
226226 .llvm_name = "ijmpcall",
227227 .description = "The device supports `IJMP`/`ICALL`instructions",
228 .dependencies = 0,
228 .dependencies = featureSet(&[_]Feature{}),
229229 };
230230 result[@enumToInt(Feature.jmpcall)] = .{
231231 .index = @enumToInt(Feature.jmpcall),
232232 .name = @tagName(Feature.jmpcall),
233233 .llvm_name = "jmpcall",
234234 .description = "The device supports the `JMP` and `CALL` instructions",
235 .dependencies = 0,
235 .dependencies = featureSet(&[_]Feature{}),
236236 };
237237 result[@enumToInt(Feature.lpm)] = .{
238238 .index = @enumToInt(Feature.lpm),
239239 .name = @tagName(Feature.lpm),
240240 .llvm_name = "lpm",
241241 .description = "The device supports the `LPM` instruction",
242 .dependencies = 0,
242 .dependencies = featureSet(&[_]Feature{}),
243243 };
244244 result[@enumToInt(Feature.lpmx)] = .{
245245 .index = @enumToInt(Feature.lpmx),
246246 .name = @tagName(Feature.lpmx),
247247 .llvm_name = "lpmx",
248248 .description = "The device supports the `LPM Rd, Z[+]` instruction",
249 .dependencies = 0,
249 .dependencies = featureSet(&[_]Feature{}),
250250 };
251251 result[@enumToInt(Feature.movw)] = .{
252252 .index = @enumToInt(Feature.movw),
253253 .name = @tagName(Feature.movw),
254254 .llvm_name = "movw",
255255 .description = "The device supports the 16-bit MOVW instruction",
256 .dependencies = 0,
256 .dependencies = featureSet(&[_]Feature{}),
257257 };
258258 result[@enumToInt(Feature.mul)] = .{
259259 .index = @enumToInt(Feature.mul),
260260 .name = @tagName(Feature.mul),
261261 .llvm_name = "mul",
262262 .description = "The device supports the multiplication instructions",
263 .dependencies = 0,
263 .dependencies = featureSet(&[_]Feature{}),
264264 };
265265 result[@enumToInt(Feature.rmw)] = .{
266266 .index = @enumToInt(Feature.rmw),
267267 .name = @tagName(Feature.rmw),
268268 .llvm_name = "rmw",
269269 .description = "The device supports the read-write-modify instructions: XCH, LAS, LAC, LAT",
270 .dependencies = 0,
270 .dependencies = featureSet(&[_]Feature{}),
271271 };
272272 result[@enumToInt(Feature.smallstack)] = .{
273273 .index = @enumToInt(Feature.smallstack),
274274 .name = @tagName(Feature.smallstack),
275275 .llvm_name = "smallstack",
276276 .description = "The device has an 8-bit stack pointer",
277 .dependencies = 0,
277 .dependencies = featureSet(&[_]Feature{}),
278278 };
279279 result[@enumToInt(Feature.special)] = .{
280280 .index = @enumToInt(Feature.special),
......@@ -283,7 +283,7 @@ pub const all_features = blk: {
283283 .description = "Enable use of the entire instruction set - used for debugging",
284284 .dependencies = featureSet(&[_]Feature{
285285 .addsubiw,
286 .break,
286 .@"break",
287287 .des,
288288 .eijmpcall,
289289 .elpm,
......@@ -305,28 +305,28 @@ pub const all_features = blk: {
305305 .name = @tagName(Feature.spm),
306306 .llvm_name = "spm",
307307 .description = "The device supports the `SPM` instruction",
308 .dependencies = 0,
308 .dependencies = featureSet(&[_]Feature{}),
309309 };
310310 result[@enumToInt(Feature.spmx)] = .{
311311 .index = @enumToInt(Feature.spmx),
312312 .name = @tagName(Feature.spmx),
313313 .llvm_name = "spmx",
314314 .description = "The device supports the `SPM Z+` instruction",
315 .dependencies = 0,
315 .dependencies = featureSet(&[_]Feature{}),
316316 };
317317 result[@enumToInt(Feature.sram)] = .{
318318 .index = @enumToInt(Feature.sram),
319319 .name = @tagName(Feature.sram),
320320 .llvm_name = "sram",
321321 .description = "The device has random access memory",
322 .dependencies = 0,
322 .dependencies = featureSet(&[_]Feature{}),
323323 };
324324 result[@enumToInt(Feature.tinyencoding)] = .{
325325 .index = @enumToInt(Feature.tinyencoding),
326326 .name = @tagName(Feature.tinyencoding),
327327 .llvm_name = "tinyencoding",
328328 .description = "The device has Tiny core specific instruction encodings",
329 .dependencies = 0,
329 .dependencies = featureSet(&[_]Feature{}),
330330 };
331331 result[@enumToInt(Feature.xmega)] = .{
332332 .index = @enumToInt(Feature.xmega),
......@@ -2439,3 +2439,7 @@ pub const all_cpus = &[_]*const Cpu{
24392439 &cpu.avrxmega7,
24402440 &cpu.m3000,
24412441};
2442
2443pub const baseline_features = featureSet(&[_]Feature{
2444 .avr0,
2445});
lib/std/target/bpf.zig+9-9
......@@ -11,28 +11,28 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
1111
1212pub const all_features = blk: {
1313 const len = @typeInfo(Feature).Enum.fields.len;
14 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
14 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
1515 var result: [len]Cpu.Feature = undefined;
1616 result[@enumToInt(Feature.alu32)] = .{
1717 .index = @enumToInt(Feature.alu32),
1818 .name = @tagName(Feature.alu32),
1919 .llvm_name = "alu32",
2020 .description = "Enable ALU32 instructions",
21 .dependencies = 0,
21 .dependencies = featureSet(&[_]Feature{}),
2222 };
2323 result[@enumToInt(Feature.dummy)] = .{
2424 .index = @enumToInt(Feature.dummy),
2525 .name = @tagName(Feature.dummy),
2626 .llvm_name = "dummy",
2727 .description = "unused feature",
28 .dependencies = 0,
28 .dependencies = featureSet(&[_]Feature{}),
2929 };
3030 result[@enumToInt(Feature.dwarfris)] = .{
3131 .index = @enumToInt(Feature.dwarfris),
3232 .name = @tagName(Feature.dwarfris),
3333 .llvm_name = "dwarfris",
3434 .description = "Disable MCAsmInfo DwarfUsesRelocationsAcrossSections",
35 .dependencies = 0,
35 .dependencies = featureSet(&[_]Feature{}),
3636 };
3737 break :blk result;
3838};
......@@ -41,27 +41,27 @@ pub const cpu = struct {
4141 pub const generic = Cpu{
4242 .name = "generic",
4343 .llvm_name = "generic",
44 .features = 0,
44 .features = featureSet(&[_]Feature{}),
4545 };
4646 pub const probe = Cpu{
4747 .name = "probe",
4848 .llvm_name = "probe",
49 .features = 0,
49 .features = featureSet(&[_]Feature{}),
5050 };
5151 pub const v1 = Cpu{
5252 .name = "v1",
5353 .llvm_name = "v1",
54 .features = 0,
54 .features = featureSet(&[_]Feature{}),
5555 };
5656 pub const v2 = Cpu{
5757 .name = "v2",
5858 .llvm_name = "v2",
59 .features = 0,
59 .features = featureSet(&[_]Feature{}),
6060 };
6161 pub const v3 = Cpu{
6262 .name = "v3",
6363 .llvm_name = "v3",
64 .features = 0,
64 .features = featureSet(&[_]Feature{}),
6565 };
6666};
6767
lib/std/target/hexagon.zig+17-17
......@@ -32,21 +32,21 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
3232
3333pub const all_features = blk: {
3434 const len = @typeInfo(Feature).Enum.fields.len;
35 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
35 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
3636 var result: [len]Cpu.Feature = undefined;
3737 result[@enumToInt(Feature.duplex)] = .{
3838 .index = @enumToInt(Feature.duplex),
3939 .name = @tagName(Feature.duplex),
4040 .llvm_name = "duplex",
4141 .description = "Enable generation of duplex instruction",
42 .dependencies = 0,
42 .dependencies = featureSet(&[_]Feature{}),
4343 };
4444 result[@enumToInt(Feature.hvx)] = .{
4545 .index = @enumToInt(Feature.hvx),
4646 .name = @tagName(Feature.hvx),
4747 .llvm_name = "hvx",
4848 .description = "Hexagon HVX instructions",
49 .dependencies = 0,
49 .dependencies = featureSet(&[_]Feature{}),
5050 };
5151 result[@enumToInt(Feature.hvx_length128b)] = .{
5252 .index = @enumToInt(Feature.hvx_length128b),
......@@ -114,28 +114,28 @@ pub const all_features = blk: {
114114 .name = @tagName(Feature.long_calls),
115115 .llvm_name = "long-calls",
116116 .description = "Use constant-extended calls",
117 .dependencies = 0,
117 .dependencies = featureSet(&[_]Feature{}),
118118 };
119119 result[@enumToInt(Feature.mem_noshuf)] = .{
120120 .index = @enumToInt(Feature.mem_noshuf),
121121 .name = @tagName(Feature.mem_noshuf),
122122 .llvm_name = "mem_noshuf",
123123 .description = "Supports mem_noshuf feature",
124 .dependencies = 0,
124 .dependencies = featureSet(&[_]Feature{}),
125125 };
126126 result[@enumToInt(Feature.memops)] = .{
127127 .index = @enumToInt(Feature.memops),
128128 .name = @tagName(Feature.memops),
129129 .llvm_name = "memops",
130130 .description = "Use memop instructions",
131 .dependencies = 0,
131 .dependencies = featureSet(&[_]Feature{}),
132132 };
133133 result[@enumToInt(Feature.noreturn_stack_elim)] = .{
134134 .index = @enumToInt(Feature.noreturn_stack_elim),
135135 .name = @tagName(Feature.noreturn_stack_elim),
136136 .llvm_name = "noreturn-stack-elim",
137137 .description = "Eliminate stack allocation in a noreturn function when possible",
138 .dependencies = 0,
138 .dependencies = featureSet(&[_]Feature{}),
139139 };
140140 result[@enumToInt(Feature.nvj)] = .{
141141 .index = @enumToInt(Feature.nvj),
......@@ -160,70 +160,70 @@ pub const all_features = blk: {
160160 .name = @tagName(Feature.packets),
161161 .llvm_name = "packets",
162162 .description = "Support for instruction packets",
163 .dependencies = 0,
163 .dependencies = featureSet(&[_]Feature{}),
164164 };
165165 result[@enumToInt(Feature.reserved_r19)] = .{
166166 .index = @enumToInt(Feature.reserved_r19),
167167 .name = @tagName(Feature.reserved_r19),
168168 .llvm_name = "reserved-r19",
169169 .description = "Reserve register R19",
170 .dependencies = 0,
170 .dependencies = featureSet(&[_]Feature{}),
171171 };
172172 result[@enumToInt(Feature.small_data)] = .{
173173 .index = @enumToInt(Feature.small_data),
174174 .name = @tagName(Feature.small_data),
175175 .llvm_name = "small-data",
176176 .description = "Allow GP-relative addressing of global variables",
177 .dependencies = 0,
177 .dependencies = featureSet(&[_]Feature{}),
178178 };
179179 result[@enumToInt(Feature.v5)] = .{
180180 .index = @enumToInt(Feature.v5),
181181 .name = @tagName(Feature.v5),
182182 .llvm_name = "v5",
183183 .description = "Enable Hexagon V5 architecture",
184 .dependencies = 0,
184 .dependencies = featureSet(&[_]Feature{}),
185185 };
186186 result[@enumToInt(Feature.v55)] = .{
187187 .index = @enumToInt(Feature.v55),
188188 .name = @tagName(Feature.v55),
189189 .llvm_name = "v55",
190190 .description = "Enable Hexagon V55 architecture",
191 .dependencies = 0,
191 .dependencies = featureSet(&[_]Feature{}),
192192 };
193193 result[@enumToInt(Feature.v60)] = .{
194194 .index = @enumToInt(Feature.v60),
195195 .name = @tagName(Feature.v60),
196196 .llvm_name = "v60",
197197 .description = "Enable Hexagon V60 architecture",
198 .dependencies = 0,
198 .dependencies = featureSet(&[_]Feature{}),
199199 };
200200 result[@enumToInt(Feature.v62)] = .{
201201 .index = @enumToInt(Feature.v62),
202202 .name = @tagName(Feature.v62),
203203 .llvm_name = "v62",
204204 .description = "Enable Hexagon V62 architecture",
205 .dependencies = 0,
205 .dependencies = featureSet(&[_]Feature{}),
206206 };
207207 result[@enumToInt(Feature.v65)] = .{
208208 .index = @enumToInt(Feature.v65),
209209 .name = @tagName(Feature.v65),
210210 .llvm_name = "v65",
211211 .description = "Enable Hexagon V65 architecture",
212 .dependencies = 0,
212 .dependencies = featureSet(&[_]Feature{}),
213213 };
214214 result[@enumToInt(Feature.v66)] = .{
215215 .index = @enumToInt(Feature.v66),
216216 .name = @tagName(Feature.v66),
217217 .llvm_name = "v66",
218218 .description = "Enable Hexagon V66 architecture",
219 .dependencies = 0,
219 .dependencies = featureSet(&[_]Feature{}),
220220 };
221221 result[@enumToInt(Feature.zreg)] = .{
222222 .index = @enumToInt(Feature.zreg),
223223 .name = @tagName(Feature.zreg),
224224 .llvm_name = "zreg",
225225 .description = "Hexagon ZReg extension instructions",
226 .dependencies = 0,
226 .dependencies = featureSet(&[_]Feature{}),
227227 };
228228 break :blk result;
229229};
lib/std/target/mips.zig+32-32
......@@ -57,14 +57,14 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
5757
5858pub const all_features = blk: {
5959 const len = @typeInfo(Feature).Enum.fields.len;
60 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
60 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
6161 var result: [len]Cpu.Feature = undefined;
6262 result[@enumToInt(Feature.abs2008)] = .{
6363 .index = @enumToInt(Feature.abs2008),
6464 .name = @tagName(Feature.abs2008),
6565 .llvm_name = "abs2008",
6666 .description = "Disable IEEE 754-2008 abs.fmt mode",
67 .dependencies = 0,
67 .dependencies = featureSet(&[_]Feature{}),
6868 };
6969 result[@enumToInt(Feature.cnmips)] = .{
7070 .index = @enumToInt(Feature.cnmips),
......@@ -80,14 +80,14 @@ pub const all_features = blk: {
8080 .name = @tagName(Feature.crc),
8181 .llvm_name = "crc",
8282 .description = "Mips R6 CRC ASE",
83 .dependencies = 0,
83 .dependencies = featureSet(&[_]Feature{}),
8484 };
8585 result[@enumToInt(Feature.dsp)] = .{
8686 .index = @enumToInt(Feature.dsp),
8787 .name = @tagName(Feature.dsp),
8888 .llvm_name = "dsp",
8989 .description = "Mips DSP ASE",
90 .dependencies = 0,
90 .dependencies = featureSet(&[_]Feature{}),
9191 };
9292 result[@enumToInt(Feature.dspr2)] = .{
9393 .index = @enumToInt(Feature.dspr2),
......@@ -113,63 +113,63 @@ pub const all_features = blk: {
113113 .name = @tagName(Feature.eva),
114114 .llvm_name = "eva",
115115 .description = "Mips EVA ASE",
116 .dependencies = 0,
116 .dependencies = featureSet(&[_]Feature{}),
117117 };
118118 result[@enumToInt(Feature.fp64)] = .{
119119 .index = @enumToInt(Feature.fp64),
120120 .name = @tagName(Feature.fp64),
121121 .llvm_name = "fp64",
122122 .description = "Support 64-bit FP registers",
123 .dependencies = 0,
123 .dependencies = featureSet(&[_]Feature{}),
124124 };
125125 result[@enumToInt(Feature.fpxx)] = .{
126126 .index = @enumToInt(Feature.fpxx),
127127 .name = @tagName(Feature.fpxx),
128128 .llvm_name = "fpxx",
129129 .description = "Support for FPXX",
130 .dependencies = 0,
130 .dependencies = featureSet(&[_]Feature{}),
131131 };
132132 result[@enumToInt(Feature.ginv)] = .{
133133 .index = @enumToInt(Feature.ginv),
134134 .name = @tagName(Feature.ginv),
135135 .llvm_name = "ginv",
136136 .description = "Mips Global Invalidate ASE",
137 .dependencies = 0,
137 .dependencies = featureSet(&[_]Feature{}),
138138 };
139139 result[@enumToInt(Feature.gp64)] = .{
140140 .index = @enumToInt(Feature.gp64),
141141 .name = @tagName(Feature.gp64),
142142 .llvm_name = "gp64",
143143 .description = "General Purpose Registers are 64-bit wide",
144 .dependencies = 0,
144 .dependencies = featureSet(&[_]Feature{}),
145145 };
146146 result[@enumToInt(Feature.long_calls)] = .{
147147 .index = @enumToInt(Feature.long_calls),
148148 .name = @tagName(Feature.long_calls),
149149 .llvm_name = "long-calls",
150150 .description = "Disable use of the jal instruction",
151 .dependencies = 0,
151 .dependencies = featureSet(&[_]Feature{}),
152152 };
153153 result[@enumToInt(Feature.micromips)] = .{
154154 .index = @enumToInt(Feature.micromips),
155155 .name = @tagName(Feature.micromips),
156156 .llvm_name = "micromips",
157157 .description = "microMips mode",
158 .dependencies = 0,
158 .dependencies = featureSet(&[_]Feature{}),
159159 };
160160 result[@enumToInt(Feature.mips1)] = .{
161161 .index = @enumToInt(Feature.mips1),
162162 .name = @tagName(Feature.mips1),
163163 .llvm_name = "mips1",
164164 .description = "Mips I ISA Support [highly experimental]",
165 .dependencies = 0,
165 .dependencies = featureSet(&[_]Feature{}),
166166 };
167167 result[@enumToInt(Feature.mips16)] = .{
168168 .index = @enumToInt(Feature.mips16),
169169 .name = @tagName(Feature.mips16),
170170 .llvm_name = "mips16",
171171 .description = "Mips16 mode",
172 .dependencies = 0,
172 .dependencies = featureSet(&[_]Feature{}),
173173 };
174174 result[@enumToInt(Feature.mips2)] = .{
175175 .index = @enumToInt(Feature.mips2),
......@@ -251,14 +251,14 @@ pub const all_features = blk: {
251251 .name = @tagName(Feature.mips3_32),
252252 .llvm_name = "mips3_32",
253253 .description = "Subset of MIPS-III that is also in MIPS32 [highly experimental]",
254 .dependencies = 0,
254 .dependencies = featureSet(&[_]Feature{}),
255255 };
256256 result[@enumToInt(Feature.mips3_32r2)] = .{
257257 .index = @enumToInt(Feature.mips3_32r2),
258258 .name = @tagName(Feature.mips3_32r2),
259259 .llvm_name = "mips3_32r2",
260260 .description = "Subset of MIPS-III that is also in MIPS32r2 [highly experimental]",
261 .dependencies = 0,
261 .dependencies = featureSet(&[_]Feature{}),
262262 };
263263 result[@enumToInt(Feature.mips4)] = .{
264264 .index = @enumToInt(Feature.mips4),
......@@ -276,14 +276,14 @@ pub const all_features = blk: {
276276 .name = @tagName(Feature.mips4_32),
277277 .llvm_name = "mips4_32",
278278 .description = "Subset of MIPS-IV that is also in MIPS32 [highly experimental]",
279 .dependencies = 0,
279 .dependencies = featureSet(&[_]Feature{}),
280280 };
281281 result[@enumToInt(Feature.mips4_32r2)] = .{
282282 .index = @enumToInt(Feature.mips4_32r2),
283283 .name = @tagName(Feature.mips4_32r2),
284284 .llvm_name = "mips4_32r2",
285285 .description = "Subset of MIPS-IV that is also in MIPS32r2 [highly experimental]",
286 .dependencies = 0,
286 .dependencies = featureSet(&[_]Feature{}),
287287 };
288288 result[@enumToInt(Feature.mips5)] = .{
289289 .index = @enumToInt(Feature.mips5),
......@@ -300,7 +300,7 @@ pub const all_features = blk: {
300300 .name = @tagName(Feature.mips5_32r2),
301301 .llvm_name = "mips5_32r2",
302302 .description = "Subset of MIPS-V that is also in MIPS32r2 [highly experimental]",
303 .dependencies = 0,
303 .dependencies = featureSet(&[_]Feature{}),
304304 };
305305 result[@enumToInt(Feature.mips64)] = .{
306306 .index = @enumToInt(Feature.mips64),
......@@ -359,42 +359,42 @@ pub const all_features = blk: {
359359 .name = @tagName(Feature.msa),
360360 .llvm_name = "msa",
361361 .description = "Mips MSA ASE",
362 .dependencies = 0,
362 .dependencies = featureSet(&[_]Feature{}),
363363 };
364364 result[@enumToInt(Feature.mt)] = .{
365365 .index = @enumToInt(Feature.mt),
366366 .name = @tagName(Feature.mt),
367367 .llvm_name = "mt",
368368 .description = "Mips MT ASE",
369 .dependencies = 0,
369 .dependencies = featureSet(&[_]Feature{}),
370370 };
371371 result[@enumToInt(Feature.nan2008)] = .{
372372 .index = @enumToInt(Feature.nan2008),
373373 .name = @tagName(Feature.nan2008),
374374 .llvm_name = "nan2008",
375375 .description = "IEEE 754-2008 NaN encoding",
376 .dependencies = 0,
376 .dependencies = featureSet(&[_]Feature{}),
377377 };
378378 result[@enumToInt(Feature.noabicalls)] = .{
379379 .index = @enumToInt(Feature.noabicalls),
380380 .name = @tagName(Feature.noabicalls),
381381 .llvm_name = "noabicalls",
382382 .description = "Disable SVR4-style position-independent code",
383 .dependencies = 0,
383 .dependencies = featureSet(&[_]Feature{}),
384384 };
385385 result[@enumToInt(Feature.nomadd4)] = .{
386386 .index = @enumToInt(Feature.nomadd4),
387387 .name = @tagName(Feature.nomadd4),
388388 .llvm_name = "nomadd4",
389389 .description = "Disable 4-operand madd.fmt and related instructions",
390 .dependencies = 0,
390 .dependencies = featureSet(&[_]Feature{}),
391391 };
392392 result[@enumToInt(Feature.nooddspreg)] = .{
393393 .index = @enumToInt(Feature.nooddspreg),
394394 .name = @tagName(Feature.nooddspreg),
395395 .llvm_name = "nooddspreg",
396396 .description = "Disable odd numbered single-precision registers",
397 .dependencies = 0,
397 .dependencies = featureSet(&[_]Feature{}),
398398 };
399399 result[@enumToInt(Feature.p5600)] = .{
400400 .index = @enumToInt(Feature.p5600),
......@@ -410,56 +410,56 @@ pub const all_features = blk: {
410410 .name = @tagName(Feature.ptr64),
411411 .llvm_name = "ptr64",
412412 .description = "Pointers are 64-bit wide",
413 .dependencies = 0,
413 .dependencies = featureSet(&[_]Feature{}),
414414 };
415415 result[@enumToInt(Feature.single_float)] = .{
416416 .index = @enumToInt(Feature.single_float),
417417 .name = @tagName(Feature.single_float),
418418 .llvm_name = "single-float",
419419 .description = "Only supports single precision float",
420 .dependencies = 0,
420 .dependencies = featureSet(&[_]Feature{}),
421421 };
422422 result[@enumToInt(Feature.soft_float)] = .{
423423 .index = @enumToInt(Feature.soft_float),
424424 .name = @tagName(Feature.soft_float),
425425 .llvm_name = "soft-float",
426426 .description = "Does not support floating point instructions",
427 .dependencies = 0,
427 .dependencies = featureSet(&[_]Feature{}),
428428 };
429429 result[@enumToInt(Feature.sym32)] = .{
430430 .index = @enumToInt(Feature.sym32),
431431 .name = @tagName(Feature.sym32),
432432 .llvm_name = "sym32",
433433 .description = "Symbols are 32 bit on Mips64",
434 .dependencies = 0,
434 .dependencies = featureSet(&[_]Feature{}),
435435 };
436436 result[@enumToInt(Feature.use_indirect_jump_hazard)] = .{
437437 .index = @enumToInt(Feature.use_indirect_jump_hazard),
438438 .name = @tagName(Feature.use_indirect_jump_hazard),
439439 .llvm_name = "use-indirect-jump-hazard",
440440 .description = "Use indirect jump guards to prevent certain speculation based attacks",
441 .dependencies = 0,
441 .dependencies = featureSet(&[_]Feature{}),
442442 };
443443 result[@enumToInt(Feature.use_tcc_in_div)] = .{
444444 .index = @enumToInt(Feature.use_tcc_in_div),
445445 .name = @tagName(Feature.use_tcc_in_div),
446446 .llvm_name = "use-tcc-in-div",
447447 .description = "Force the assembler to use trapping",
448 .dependencies = 0,
448 .dependencies = featureSet(&[_]Feature{}),
449449 };
450450 result[@enumToInt(Feature.vfpu)] = .{
451451 .index = @enumToInt(Feature.vfpu),
452452 .name = @tagName(Feature.vfpu),
453453 .llvm_name = "vfpu",
454454 .description = "Enable vector FPU instructions",
455 .dependencies = 0,
455 .dependencies = featureSet(&[_]Feature{}),
456456 };
457457 result[@enumToInt(Feature.virt)] = .{
458458 .index = @enumToInt(Feature.virt),
459459 .name = @tagName(Feature.virt),
460460 .llvm_name = "virt",
461461 .description = "Mips Virtualization ASE",
462 .dependencies = 0,
462 .dependencies = featureSet(&[_]Feature{}),
463463 };
464464 break :blk result;
465465};
lib/std/target/msp430.zig+7-7
......@@ -12,35 +12,35 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
1212
1313pub const all_features = blk: {
1414 const len = @typeInfo(Feature).Enum.fields.len;
15 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
15 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
1616 var result: [len]Cpu.Feature = undefined;
1717 result[@enumToInt(Feature.ext)] = .{
1818 .index = @enumToInt(Feature.ext),
1919 .name = @tagName(Feature.ext),
2020 .llvm_name = "ext",
2121 .description = "Enable MSP430-X extensions",
22 .dependencies = 0,
22 .dependencies = featureSet(&[_]Feature{}),
2323 };
2424 result[@enumToInt(Feature.hwmult16)] = .{
2525 .index = @enumToInt(Feature.hwmult16),
2626 .name = @tagName(Feature.hwmult16),
2727 .llvm_name = "hwmult16",
2828 .description = "Enable 16-bit hardware multiplier",
29 .dependencies = 0,
29 .dependencies = featureSet(&[_]Feature{}),
3030 };
3131 result[@enumToInt(Feature.hwmult32)] = .{
3232 .index = @enumToInt(Feature.hwmult32),
3333 .name = @tagName(Feature.hwmult32),
3434 .llvm_name = "hwmult32",
3535 .description = "Enable 32-bit hardware multiplier",
36 .dependencies = 0,
36 .dependencies = featureSet(&[_]Feature{}),
3737 };
3838 result[@enumToInt(Feature.hwmultf5)] = .{
3939 .index = @enumToInt(Feature.hwmultf5),
4040 .name = @tagName(Feature.hwmultf5),
4141 .llvm_name = "hwmultf5",
4242 .description = "Enable F5 series hardware multiplier",
43 .dependencies = 0,
43 .dependencies = featureSet(&[_]Feature{}),
4444 };
4545 break :blk result;
4646};
......@@ -49,12 +49,12 @@ pub const cpu = struct {
4949 pub const generic = Cpu{
5050 .name = "generic",
5151 .llvm_name = "generic",
52 .features = 0,
52 .features = featureSet(&[_]Feature{}),
5353 };
5454 pub const msp430 = Cpu{
5555 .name = "msp430",
5656 .llvm_name = "msp430",
57 .features = 0,
57 .features = featureSet(&[_]Feature{}),
5858 };
5959 pub const msp430x = Cpu{
6060 .name = "msp430x",
lib/std/target/nvptx.zig+26-26
......@@ -33,182 +33,182 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
3333
3434pub const all_features = blk: {
3535 const len = @typeInfo(Feature).Enum.fields.len;
36 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
36 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
3737 var result: [len]Cpu.Feature = undefined;
3838 result[@enumToInt(Feature.ptx32)] = .{
3939 .index = @enumToInt(Feature.ptx32),
4040 .name = @tagName(Feature.ptx32),
4141 .llvm_name = "ptx32",
4242 .description = "Use PTX version 3.2",
43 .dependencies = 0,
43 .dependencies = featureSet(&[_]Feature{}),
4444 };
4545 result[@enumToInt(Feature.ptx40)] = .{
4646 .index = @enumToInt(Feature.ptx40),
4747 .name = @tagName(Feature.ptx40),
4848 .llvm_name = "ptx40",
4949 .description = "Use PTX version 4.0",
50 .dependencies = 0,
50 .dependencies = featureSet(&[_]Feature{}),
5151 };
5252 result[@enumToInt(Feature.ptx41)] = .{
5353 .index = @enumToInt(Feature.ptx41),
5454 .name = @tagName(Feature.ptx41),
5555 .llvm_name = "ptx41",
5656 .description = "Use PTX version 4.1",
57 .dependencies = 0,
57 .dependencies = featureSet(&[_]Feature{}),
5858 };
5959 result[@enumToInt(Feature.ptx42)] = .{
6060 .index = @enumToInt(Feature.ptx42),
6161 .name = @tagName(Feature.ptx42),
6262 .llvm_name = "ptx42",
6363 .description = "Use PTX version 4.2",
64 .dependencies = 0,
64 .dependencies = featureSet(&[_]Feature{}),
6565 };
6666 result[@enumToInt(Feature.ptx43)] = .{
6767 .index = @enumToInt(Feature.ptx43),
6868 .name = @tagName(Feature.ptx43),
6969 .llvm_name = "ptx43",
7070 .description = "Use PTX version 4.3",
71 .dependencies = 0,
71 .dependencies = featureSet(&[_]Feature{}),
7272 };
7373 result[@enumToInt(Feature.ptx50)] = .{
7474 .index = @enumToInt(Feature.ptx50),
7575 .name = @tagName(Feature.ptx50),
7676 .llvm_name = "ptx50",
7777 .description = "Use PTX version 5.0",
78 .dependencies = 0,
78 .dependencies = featureSet(&[_]Feature{}),
7979 };
8080 result[@enumToInt(Feature.ptx60)] = .{
8181 .index = @enumToInt(Feature.ptx60),
8282 .name = @tagName(Feature.ptx60),
8383 .llvm_name = "ptx60",
8484 .description = "Use PTX version 6.0",
85 .dependencies = 0,
85 .dependencies = featureSet(&[_]Feature{}),
8686 };
8787 result[@enumToInt(Feature.ptx61)] = .{
8888 .index = @enumToInt(Feature.ptx61),
8989 .name = @tagName(Feature.ptx61),
9090 .llvm_name = "ptx61",
9191 .description = "Use PTX version 6.1",
92 .dependencies = 0,
92 .dependencies = featureSet(&[_]Feature{}),
9393 };
9494 result[@enumToInt(Feature.ptx63)] = .{
9595 .index = @enumToInt(Feature.ptx63),
9696 .name = @tagName(Feature.ptx63),
9797 .llvm_name = "ptx63",
9898 .description = "Use PTX version 6.3",
99 .dependencies = 0,
99 .dependencies = featureSet(&[_]Feature{}),
100100 };
101101 result[@enumToInt(Feature.ptx64)] = .{
102102 .index = @enumToInt(Feature.ptx64),
103103 .name = @tagName(Feature.ptx64),
104104 .llvm_name = "ptx64",
105105 .description = "Use PTX version 6.4",
106 .dependencies = 0,
106 .dependencies = featureSet(&[_]Feature{}),
107107 };
108108 result[@enumToInt(Feature.sm_20)] = .{
109109 .index = @enumToInt(Feature.sm_20),
110110 .name = @tagName(Feature.sm_20),
111111 .llvm_name = "sm_20",
112112 .description = "Target SM 2.0",
113 .dependencies = 0,
113 .dependencies = featureSet(&[_]Feature{}),
114114 };
115115 result[@enumToInt(Feature.sm_21)] = .{
116116 .index = @enumToInt(Feature.sm_21),
117117 .name = @tagName(Feature.sm_21),
118118 .llvm_name = "sm_21",
119119 .description = "Target SM 2.1",
120 .dependencies = 0,
120 .dependencies = featureSet(&[_]Feature{}),
121121 };
122122 result[@enumToInt(Feature.sm_30)] = .{
123123 .index = @enumToInt(Feature.sm_30),
124124 .name = @tagName(Feature.sm_30),
125125 .llvm_name = "sm_30",
126126 .description = "Target SM 3.0",
127 .dependencies = 0,
127 .dependencies = featureSet(&[_]Feature{}),
128128 };
129129 result[@enumToInt(Feature.sm_32)] = .{
130130 .index = @enumToInt(Feature.sm_32),
131131 .name = @tagName(Feature.sm_32),
132132 .llvm_name = "sm_32",
133133 .description = "Target SM 3.2",
134 .dependencies = 0,
134 .dependencies = featureSet(&[_]Feature{}),
135135 };
136136 result[@enumToInt(Feature.sm_35)] = .{
137137 .index = @enumToInt(Feature.sm_35),
138138 .name = @tagName(Feature.sm_35),
139139 .llvm_name = "sm_35",
140140 .description = "Target SM 3.5",
141 .dependencies = 0,
141 .dependencies = featureSet(&[_]Feature{}),
142142 };
143143 result[@enumToInt(Feature.sm_37)] = .{
144144 .index = @enumToInt(Feature.sm_37),
145145 .name = @tagName(Feature.sm_37),
146146 .llvm_name = "sm_37",
147147 .description = "Target SM 3.7",
148 .dependencies = 0,
148 .dependencies = featureSet(&[_]Feature{}),
149149 };
150150 result[@enumToInt(Feature.sm_50)] = .{
151151 .index = @enumToInt(Feature.sm_50),
152152 .name = @tagName(Feature.sm_50),
153153 .llvm_name = "sm_50",
154154 .description = "Target SM 5.0",
155 .dependencies = 0,
155 .dependencies = featureSet(&[_]Feature{}),
156156 };
157157 result[@enumToInt(Feature.sm_52)] = .{
158158 .index = @enumToInt(Feature.sm_52),
159159 .name = @tagName(Feature.sm_52),
160160 .llvm_name = "sm_52",
161161 .description = "Target SM 5.2",
162 .dependencies = 0,
162 .dependencies = featureSet(&[_]Feature{}),
163163 };
164164 result[@enumToInt(Feature.sm_53)] = .{
165165 .index = @enumToInt(Feature.sm_53),
166166 .name = @tagName(Feature.sm_53),
167167 .llvm_name = "sm_53",
168168 .description = "Target SM 5.3",
169 .dependencies = 0,
169 .dependencies = featureSet(&[_]Feature{}),
170170 };
171171 result[@enumToInt(Feature.sm_60)] = .{
172172 .index = @enumToInt(Feature.sm_60),
173173 .name = @tagName(Feature.sm_60),
174174 .llvm_name = "sm_60",
175175 .description = "Target SM 6.0",
176 .dependencies = 0,
176 .dependencies = featureSet(&[_]Feature{}),
177177 };
178178 result[@enumToInt(Feature.sm_61)] = .{
179179 .index = @enumToInt(Feature.sm_61),
180180 .name = @tagName(Feature.sm_61),
181181 .llvm_name = "sm_61",
182182 .description = "Target SM 6.1",
183 .dependencies = 0,
183 .dependencies = featureSet(&[_]Feature{}),
184184 };
185185 result[@enumToInt(Feature.sm_62)] = .{
186186 .index = @enumToInt(Feature.sm_62),
187187 .name = @tagName(Feature.sm_62),
188188 .llvm_name = "sm_62",
189189 .description = "Target SM 6.2",
190 .dependencies = 0,
190 .dependencies = featureSet(&[_]Feature{}),
191191 };
192192 result[@enumToInt(Feature.sm_70)] = .{
193193 .index = @enumToInt(Feature.sm_70),
194194 .name = @tagName(Feature.sm_70),
195195 .llvm_name = "sm_70",
196196 .description = "Target SM 7.0",
197 .dependencies = 0,
197 .dependencies = featureSet(&[_]Feature{}),
198198 };
199199 result[@enumToInt(Feature.sm_72)] = .{
200200 .index = @enumToInt(Feature.sm_72),
201201 .name = @tagName(Feature.sm_72),
202202 .llvm_name = "sm_72",
203203 .description = "Target SM 7.2",
204 .dependencies = 0,
204 .dependencies = featureSet(&[_]Feature{}),
205205 };
206206 result[@enumToInt(Feature.sm_75)] = .{
207207 .index = @enumToInt(Feature.sm_75),
208208 .name = @tagName(Feature.sm_75),
209209 .llvm_name = "sm_75",
210210 .description = "Target SM 7.5",
211 .dependencies = 0,
211 .dependencies = featureSet(&[_]Feature{}),
212212 };
213213 break :blk result;
214214};
lib/std/target/powerpc.zig+44-44
......@@ -59,21 +59,21 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
5959
6060pub const all_features = blk: {
6161 const len = @typeInfo(Feature).Enum.fields.len;
62 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
62 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
6363 var result: [len]Cpu.Feature = undefined;
6464 result[@enumToInt(Feature.@"64bit")] = .{
6565 .index = @enumToInt(Feature.@"64bit"),
6666 .name = @tagName(Feature.@"64bit"),
6767 .llvm_name = "64bit",
6868 .description = "Enable 64-bit instructions",
69 .dependencies = 0,
69 .dependencies = featureSet(&[_]Feature{}),
7070 };
7171 result[@enumToInt(Feature.@"64bitregs")] = .{
7272 .index = @enumToInt(Feature.@"64bitregs"),
7373 .name = @tagName(Feature.@"64bitregs"),
7474 .llvm_name = "64bitregs",
7575 .description = "Enable 64-bit registers usage for ppc32 [beta]",
76 .dependencies = 0,
76 .dependencies = featureSet(&[_]Feature{}),
7777 };
7878 result[@enumToInt(Feature.altivec)] = .{
7979 .index = @enumToInt(Feature.altivec),
......@@ -98,21 +98,21 @@ pub const all_features = blk: {
9898 .name = @tagName(Feature.bpermd),
9999 .llvm_name = "bpermd",
100100 .description = "Enable the bpermd instruction",
101 .dependencies = 0,
101 .dependencies = featureSet(&[_]Feature{}),
102102 };
103103 result[@enumToInt(Feature.cmpb)] = .{
104104 .index = @enumToInt(Feature.cmpb),
105105 .name = @tagName(Feature.cmpb),
106106 .llvm_name = "cmpb",
107107 .description = "Enable the cmpb instruction",
108 .dependencies = 0,
108 .dependencies = featureSet(&[_]Feature{}),
109109 };
110110 result[@enumToInt(Feature.crbits)] = .{
111111 .index = @enumToInt(Feature.crbits),
112112 .name = @tagName(Feature.crbits),
113113 .llvm_name = "crbits",
114114 .description = "Use condition-register bits individually",
115 .dependencies = 0,
115 .dependencies = featureSet(&[_]Feature{}),
116116 };
117117 result[@enumToInt(Feature.crypto)] = .{
118118 .index = @enumToInt(Feature.crypto),
......@@ -137,14 +137,14 @@ pub const all_features = blk: {
137137 .name = @tagName(Feature.e500),
138138 .llvm_name = "e500",
139139 .description = "Enable E500/E500mc instructions",
140 .dependencies = 0,
140 .dependencies = featureSet(&[_]Feature{}),
141141 };
142142 result[@enumToInt(Feature.extdiv)] = .{
143143 .index = @enumToInt(Feature.extdiv),
144144 .name = @tagName(Feature.extdiv),
145145 .llvm_name = "extdiv",
146146 .description = "Enable extended divide instructions",
147 .dependencies = 0,
147 .dependencies = featureSet(&[_]Feature{}),
148148 };
149149 result[@enumToInt(Feature.fcpsgn)] = .{
150150 .index = @enumToInt(Feature.fcpsgn),
......@@ -241,49 +241,49 @@ pub const all_features = blk: {
241241 .name = @tagName(Feature.hard_float),
242242 .llvm_name = "hard-float",
243243 .description = "Enable floating-point instructions",
244 .dependencies = 0,
244 .dependencies = featureSet(&[_]Feature{}),
245245 };
246246 result[@enumToInt(Feature.htm)] = .{
247247 .index = @enumToInt(Feature.htm),
248248 .name = @tagName(Feature.htm),
249249 .llvm_name = "htm",
250250 .description = "Enable Hardware Transactional Memory instructions",
251 .dependencies = 0,
251 .dependencies = featureSet(&[_]Feature{}),
252252 };
253253 result[@enumToInt(Feature.icbt)] = .{
254254 .index = @enumToInt(Feature.icbt),
255255 .name = @tagName(Feature.icbt),
256256 .llvm_name = "icbt",
257257 .description = "Enable icbt instruction",
258 .dependencies = 0,
258 .dependencies = featureSet(&[_]Feature{}),
259259 };
260260 result[@enumToInt(Feature.invariant_function_descriptors)] = .{
261261 .index = @enumToInt(Feature.invariant_function_descriptors),
262262 .name = @tagName(Feature.invariant_function_descriptors),
263263 .llvm_name = "invariant-function-descriptors",
264264 .description = "Assume function descriptors are invariant",
265 .dependencies = 0,
265 .dependencies = featureSet(&[_]Feature{}),
266266 };
267267 result[@enumToInt(Feature.isa_v30_instructions)] = .{
268268 .index = @enumToInt(Feature.isa_v30_instructions),
269269 .name = @tagName(Feature.isa_v30_instructions),
270270 .llvm_name = "isa-v30-instructions",
271271 .description = "Enable instructions added in ISA 3.0.",
272 .dependencies = 0,
272 .dependencies = featureSet(&[_]Feature{}),
273273 };
274274 result[@enumToInt(Feature.isel)] = .{
275275 .index = @enumToInt(Feature.isel),
276276 .name = @tagName(Feature.isel),
277277 .llvm_name = "isel",
278278 .description = "Enable the isel instruction",
279 .dependencies = 0,
279 .dependencies = featureSet(&[_]Feature{}),
280280 };
281281 result[@enumToInt(Feature.ldbrx)] = .{
282282 .index = @enumToInt(Feature.ldbrx),
283283 .name = @tagName(Feature.ldbrx),
284284 .llvm_name = "ldbrx",
285285 .description = "Enable the ldbrx instruction",
286 .dependencies = 0,
286 .dependencies = featureSet(&[_]Feature{}),
287287 };
288288 result[@enumToInt(Feature.lfiwax)] = .{
289289 .index = @enumToInt(Feature.lfiwax),
......@@ -299,14 +299,14 @@ pub const all_features = blk: {
299299 .name = @tagName(Feature.longcall),
300300 .llvm_name = "longcall",
301301 .description = "Always use indirect calls",
302 .dependencies = 0,
302 .dependencies = featureSet(&[_]Feature{}),
303303 };
304304 result[@enumToInt(Feature.mfocrf)] = .{
305305 .index = @enumToInt(Feature.mfocrf),
306306 .name = @tagName(Feature.mfocrf),
307307 .llvm_name = "mfocrf",
308308 .description = "Enable the MFOCRF instruction",
309 .dependencies = 0,
309 .dependencies = featureSet(&[_]Feature{}),
310310 };
311311 result[@enumToInt(Feature.msync)] = .{
312312 .index = @enumToInt(Feature.msync),
......@@ -322,14 +322,14 @@ pub const all_features = blk: {
322322 .name = @tagName(Feature.partword_atomics),
323323 .llvm_name = "partword-atomics",
324324 .description = "Enable l[bh]arx and st[bh]cx.",
325 .dependencies = 0,
325 .dependencies = featureSet(&[_]Feature{}),
326326 };
327327 result[@enumToInt(Feature.popcntd)] = .{
328328 .index = @enumToInt(Feature.popcntd),
329329 .name = @tagName(Feature.popcntd),
330330 .llvm_name = "popcntd",
331331 .description = "Enable the popcnt[dw] instructions",
332 .dependencies = 0,
332 .dependencies = featureSet(&[_]Feature{}),
333333 };
334334 result[@enumToInt(Feature.power8_altivec)] = .{
335335 .index = @enumToInt(Feature.power8_altivec),
......@@ -376,28 +376,28 @@ pub const all_features = blk: {
376376 .name = @tagName(Feature.ppc_postra_sched),
377377 .llvm_name = "ppc-postra-sched",
378378 .description = "Use PowerPC post-RA scheduling strategy",
379 .dependencies = 0,
379 .dependencies = featureSet(&[_]Feature{}),
380380 };
381381 result[@enumToInt(Feature.ppc_prera_sched)] = .{
382382 .index = @enumToInt(Feature.ppc_prera_sched),
383383 .name = @tagName(Feature.ppc_prera_sched),
384384 .llvm_name = "ppc-prera-sched",
385385 .description = "Use PowerPC pre-RA scheduling strategy",
386 .dependencies = 0,
386 .dependencies = featureSet(&[_]Feature{}),
387387 };
388388 result[@enumToInt(Feature.ppc4xx)] = .{
389389 .index = @enumToInt(Feature.ppc4xx),
390390 .name = @tagName(Feature.ppc4xx),
391391 .llvm_name = "ppc4xx",
392392 .description = "Enable PPC 4xx instructions",
393 .dependencies = 0,
393 .dependencies = featureSet(&[_]Feature{}),
394394 };
395395 result[@enumToInt(Feature.ppc6xx)] = .{
396396 .index = @enumToInt(Feature.ppc6xx),
397397 .name = @tagName(Feature.ppc6xx),
398398 .llvm_name = "ppc6xx",
399399 .description = "Enable PPC 6xx instructions",
400 .dependencies = 0,
400 .dependencies = featureSet(&[_]Feature{}),
401401 };
402402 result[@enumToInt(Feature.qpx)] = .{
403403 .index = @enumToInt(Feature.qpx),
......@@ -413,21 +413,21 @@ pub const all_features = blk: {
413413 .name = @tagName(Feature.recipprec),
414414 .llvm_name = "recipprec",
415415 .description = "Assume higher precision reciprocal estimates",
416 .dependencies = 0,
416 .dependencies = featureSet(&[_]Feature{}),
417417 };
418418 result[@enumToInt(Feature.secure_plt)] = .{
419419 .index = @enumToInt(Feature.secure_plt),
420420 .name = @tagName(Feature.secure_plt),
421421 .llvm_name = "secure-plt",
422422 .description = "Enable secure plt mode",
423 .dependencies = 0,
423 .dependencies = featureSet(&[_]Feature{}),
424424 };
425425 result[@enumToInt(Feature.slow_popcntd)] = .{
426426 .index = @enumToInt(Feature.slow_popcntd),
427427 .name = @tagName(Feature.slow_popcntd),
428428 .llvm_name = "slow-popcntd",
429429 .description = "Has slow popcnt[dw] instructions",
430 .dependencies = 0,
430 .dependencies = featureSet(&[_]Feature{}),
431431 };
432432 result[@enumToInt(Feature.spe)] = .{
433433 .index = @enumToInt(Feature.spe),
......@@ -452,14 +452,14 @@ pub const all_features = blk: {
452452 .name = @tagName(Feature.two_const_nr),
453453 .llvm_name = "two-const-nr",
454454 .description = "Requires two constant Newton-Raphson computation",
455 .dependencies = 0,
455 .dependencies = featureSet(&[_]Feature{}),
456456 };
457457 result[@enumToInt(Feature.vectors_use_two_units)] = .{
458458 .index = @enumToInt(Feature.vectors_use_two_units),
459459 .name = @tagName(Feature.vectors_use_two_units),
460460 .llvm_name = "vectors-use-two-units",
461461 .description = "Vectors use two units",
462 .dependencies = 0,
462 .dependencies = featureSet(&[_]Feature{}),
463463 };
464464 result[@enumToInt(Feature.vsx)] = .{
465465 .index = @enumToInt(Feature.vsx),
......@@ -475,7 +475,7 @@ pub const all_features = blk: {
475475
476476pub const cpu = struct {
477477 pub const @"440" = Cpu{
478 .name = "@"440"",
478 .name = "440",
479479 .llvm_name = "440",
480480 .features = featureSet(&[_]Feature{
481481 .booke,
......@@ -487,7 +487,7 @@ pub const cpu = struct {
487487 }),
488488 };
489489 pub const @"450" = Cpu{
490 .name = "@"450"",
490 .name = "450",
491491 .llvm_name = "450",
492492 .features = featureSet(&[_]Feature{
493493 .booke,
......@@ -499,21 +499,21 @@ pub const cpu = struct {
499499 }),
500500 };
501501 pub const @"601" = Cpu{
502 .name = "@"601"",
502 .name = "601",
503503 .llvm_name = "601",
504504 .features = featureSet(&[_]Feature{
505505 .fpu,
506506 }),
507507 };
508508 pub const @"602" = Cpu{
509 .name = "@"602"",
509 .name = "602",
510510 .llvm_name = "602",
511511 .features = featureSet(&[_]Feature{
512512 .fpu,
513513 }),
514514 };
515515 pub const @"603" = Cpu{
516 .name = "@"603"",
516 .name = "603",
517517 .llvm_name = "603",
518518 .features = featureSet(&[_]Feature{
519519 .fres,
......@@ -521,7 +521,7 @@ pub const cpu = struct {
521521 }),
522522 };
523523 pub const @"603e" = Cpu{
524 .name = "@"603e"",
524 .name = "603e",
525525 .llvm_name = "603e",
526526 .features = featureSet(&[_]Feature{
527527 .fres,
......@@ -529,7 +529,7 @@ pub const cpu = struct {
529529 }),
530530 };
531531 pub const @"603ev" = Cpu{
532 .name = "@"603ev"",
532 .name = "603ev",
533533 .llvm_name = "603ev",
534534 .features = featureSet(&[_]Feature{
535535 .fres,
......@@ -537,7 +537,7 @@ pub const cpu = struct {
537537 }),
538538 };
539539 pub const @"604" = Cpu{
540 .name = "@"604"",
540 .name = "604",
541541 .llvm_name = "604",
542542 .features = featureSet(&[_]Feature{
543543 .fres,
......@@ -545,7 +545,7 @@ pub const cpu = struct {
545545 }),
546546 };
547547 pub const @"604e" = Cpu{
548 .name = "@"604e"",
548 .name = "604e",
549549 .llvm_name = "604e",
550550 .features = featureSet(&[_]Feature{
551551 .fres,
......@@ -553,7 +553,7 @@ pub const cpu = struct {
553553 }),
554554 };
555555 pub const @"620" = Cpu{
556 .name = "@"620"",
556 .name = "620",
557557 .llvm_name = "620",
558558 .features = featureSet(&[_]Feature{
559559 .fres,
......@@ -561,7 +561,7 @@ pub const cpu = struct {
561561 }),
562562 };
563563 pub const @"7400" = Cpu{
564 .name = "@"7400"",
564 .name = "7400",
565565 .llvm_name = "7400",
566566 .features = featureSet(&[_]Feature{
567567 .altivec,
......@@ -570,7 +570,7 @@ pub const cpu = struct {
570570 }),
571571 };
572572 pub const @"7450" = Cpu{
573 .name = "@"7450"",
573 .name = "7450",
574574 .llvm_name = "7450",
575575 .features = featureSet(&[_]Feature{
576576 .altivec,
......@@ -579,7 +579,7 @@ pub const cpu = struct {
579579 }),
580580 };
581581 pub const @"750" = Cpu{
582 .name = "@"750"",
582 .name = "750",
583583 .llvm_name = "750",
584584 .features = featureSet(&[_]Feature{
585585 .fres,
......@@ -587,7 +587,7 @@ pub const cpu = struct {
587587 }),
588588 };
589589 pub const @"970" = Cpu{
590 .name = "@"970"",
590 .name = "970",
591591 .llvm_name = "970",
592592 .features = featureSet(&[_]Feature{
593593 .@"64bit",
......@@ -698,7 +698,7 @@ pub const cpu = struct {
698698 .frsqrte,
699699 }),
700700 };
701 pub const g4+ = Cpu{
701 pub const @"g4+" = Cpu{
702702 .name = "g4+",
703703 .llvm_name = "g4+",
704704 .features = featureSet(&[_]Feature{
......@@ -1016,7 +1016,7 @@ pub const all_cpus = &[_]*const Cpu{
10161016 &cpu.e5500,
10171017 &cpu.g3,
10181018 &cpu.g4,
1019 &cpu.g4+,
1019 &cpu.@"g4+",
10201020 &cpu.g5,
10211021 &cpu.generic,
10221022 &cpu.ppc,
lib/std/target/riscv.zig+9-9
......@@ -16,28 +16,28 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
1616
1717pub const all_features = blk: {
1818 const len = @typeInfo(Feature).Enum.fields.len;
19 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
19 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
2020 var result: [len]Cpu.Feature = undefined;
2121 result[@enumToInt(Feature.@"64bit")] = .{
2222 .index = @enumToInt(Feature.@"64bit"),
2323 .name = @tagName(Feature.@"64bit"),
2424 .llvm_name = "64bit",
2525 .description = "Implements RV64",
26 .dependencies = 0,
26 .dependencies = featureSet(&[_]Feature{}),
2727 };
2828 result[@enumToInt(Feature.a)] = .{
2929 .index = @enumToInt(Feature.a),
3030 .name = @tagName(Feature.a),
3131 .llvm_name = "a",
3232 .description = "'A' (Atomic Instructions)",
33 .dependencies = 0,
33 .dependencies = featureSet(&[_]Feature{}),
3434 };
3535 result[@enumToInt(Feature.c)] = .{
3636 .index = @enumToInt(Feature.c),
3737 .name = @tagName(Feature.c),
3838 .llvm_name = "c",
3939 .description = "'C' (Compressed Instructions)",
40 .dependencies = 0,
40 .dependencies = featureSet(&[_]Feature{}),
4141 };
4242 result[@enumToInt(Feature.d)] = .{
4343 .index = @enumToInt(Feature.d),
......@@ -53,28 +53,28 @@ pub const all_features = blk: {
5353 .name = @tagName(Feature.e),
5454 .llvm_name = "e",
5555 .description = "Implements RV32E (provides 16 rather than 32 GPRs)",
56 .dependencies = 0,
56 .dependencies = featureSet(&[_]Feature{}),
5757 };
5858 result[@enumToInt(Feature.f)] = .{
5959 .index = @enumToInt(Feature.f),
6060 .name = @tagName(Feature.f),
6161 .llvm_name = "f",
6262 .description = "'F' (Single-Precision Floating-Point)",
63 .dependencies = 0,
63 .dependencies = featureSet(&[_]Feature{}),
6464 };
6565 result[@enumToInt(Feature.m)] = .{
6666 .index = @enumToInt(Feature.m),
6767 .name = @tagName(Feature.m),
6868 .llvm_name = "m",
6969 .description = "'M' (Integer Multiplication and Division)",
70 .dependencies = 0,
70 .dependencies = featureSet(&[_]Feature{}),
7171 };
7272 result[@enumToInt(Feature.relax)] = .{
7373 .index = @enumToInt(Feature.relax),
7474 .name = @tagName(Feature.relax),
7575 .llvm_name = "relax",
7676 .description = "Enable Linker relaxation.",
77 .dependencies = 0,
77 .dependencies = featureSet(&[_]Feature{}),
7878 };
7979 break :blk result;
8080};
......@@ -83,7 +83,7 @@ pub const cpu = struct {
8383 pub const generic_rv32 = Cpu{
8484 .name = "generic_rv32",
8585 .llvm_name = "generic-rv32",
86 .features = 0,
86 .features = featureSet(&[_]Feature{}),
8787 };
8888 pub const generic_rv64 = Cpu{
8989 .name = "generic_rv64",
lib/std/target/sparc.zig+29-29
......@@ -27,140 +27,140 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
2727
2828pub const all_features = blk: {
2929 const len = @typeInfo(Feature).Enum.fields.len;
30 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
30 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
3131 var result: [len]Cpu.Feature = undefined;
3232 result[@enumToInt(Feature.deprecated_v8)] = .{
3333 .index = @enumToInt(Feature.deprecated_v8),
3434 .name = @tagName(Feature.deprecated_v8),
3535 .llvm_name = "deprecated-v8",
3636 .description = "Enable deprecated V8 instructions in V9 mode",
37 .dependencies = 0,
37 .dependencies = featureSet(&[_]Feature{}),
3838 };
3939 result[@enumToInt(Feature.detectroundchange)] = .{
4040 .index = @enumToInt(Feature.detectroundchange),
4141 .name = @tagName(Feature.detectroundchange),
4242 .llvm_name = "detectroundchange",
4343 .description = "LEON3 erratum detection: Detects any rounding mode change request: use only the round-to-nearest rounding mode",
44 .dependencies = 0,
44 .dependencies = featureSet(&[_]Feature{}),
4545 };
4646 result[@enumToInt(Feature.fixallfdivsqrt)] = .{
4747 .index = @enumToInt(Feature.fixallfdivsqrt),
4848 .name = @tagName(Feature.fixallfdivsqrt),
4949 .llvm_name = "fixallfdivsqrt",
5050 .description = "LEON erratum fix: Fix FDIVS/FDIVD/FSQRTS/FSQRTD instructions with NOPs and floating-point store",
51 .dependencies = 0,
51 .dependencies = featureSet(&[_]Feature{}),
5252 };
5353 result[@enumToInt(Feature.hard_quad_float)] = .{
5454 .index = @enumToInt(Feature.hard_quad_float),
5555 .name = @tagName(Feature.hard_quad_float),
5656 .llvm_name = "hard-quad-float",
5757 .description = "Enable quad-word floating point instructions",
58 .dependencies = 0,
58 .dependencies = featureSet(&[_]Feature{}),
5959 };
6060 result[@enumToInt(Feature.hasleoncasa)] = .{
6161 .index = @enumToInt(Feature.hasleoncasa),
6262 .name = @tagName(Feature.hasleoncasa),
6363 .llvm_name = "hasleoncasa",
6464 .description = "Enable CASA instruction for LEON3 and LEON4 processors",
65 .dependencies = 0,
65 .dependencies = featureSet(&[_]Feature{}),
6666 };
6767 result[@enumToInt(Feature.hasumacsmac)] = .{
6868 .index = @enumToInt(Feature.hasumacsmac),
6969 .name = @tagName(Feature.hasumacsmac),
7070 .llvm_name = "hasumacsmac",
7171 .description = "Enable UMAC and SMAC for LEON3 and LEON4 processors",
72 .dependencies = 0,
72 .dependencies = featureSet(&[_]Feature{}),
7373 };
7474 result[@enumToInt(Feature.insertnopload)] = .{
7575 .index = @enumToInt(Feature.insertnopload),
7676 .name = @tagName(Feature.insertnopload),
7777 .llvm_name = "insertnopload",
7878 .description = "LEON3 erratum fix: Insert a NOP instruction after every single-cycle load instruction when the next instruction is another load/store instruction",
79 .dependencies = 0,
79 .dependencies = featureSet(&[_]Feature{}),
8080 };
8181 result[@enumToInt(Feature.leon)] = .{
8282 .index = @enumToInt(Feature.leon),
8383 .name = @tagName(Feature.leon),
8484 .llvm_name = "leon",
8585 .description = "Enable LEON extensions",
86 .dependencies = 0,
86 .dependencies = featureSet(&[_]Feature{}),
8787 };
8888 result[@enumToInt(Feature.leoncyclecounter)] = .{
8989 .index = @enumToInt(Feature.leoncyclecounter),
9090 .name = @tagName(Feature.leoncyclecounter),
9191 .llvm_name = "leoncyclecounter",
9292 .description = "Use the Leon cycle counter register",
93 .dependencies = 0,
93 .dependencies = featureSet(&[_]Feature{}),
9494 };
9595 result[@enumToInt(Feature.leonpwrpsr)] = .{
9696 .index = @enumToInt(Feature.leonpwrpsr),
9797 .name = @tagName(Feature.leonpwrpsr),
9898 .llvm_name = "leonpwrpsr",
9999 .description = "Enable the PWRPSR instruction",
100 .dependencies = 0,
100 .dependencies = featureSet(&[_]Feature{}),
101101 };
102102 result[@enumToInt(Feature.no_fmuls)] = .{
103103 .index = @enumToInt(Feature.no_fmuls),
104104 .name = @tagName(Feature.no_fmuls),
105105 .llvm_name = "no-fmuls",
106106 .description = "Disable the fmuls instruction.",
107 .dependencies = 0,
107 .dependencies = featureSet(&[_]Feature{}),
108108 };
109109 result[@enumToInt(Feature.no_fsmuld)] = .{
110110 .index = @enumToInt(Feature.no_fsmuld),
111111 .name = @tagName(Feature.no_fsmuld),
112112 .llvm_name = "no-fsmuld",
113113 .description = "Disable the fsmuld instruction.",
114 .dependencies = 0,
114 .dependencies = featureSet(&[_]Feature{}),
115115 };
116116 result[@enumToInt(Feature.popc)] = .{
117117 .index = @enumToInt(Feature.popc),
118118 .name = @tagName(Feature.popc),
119119 .llvm_name = "popc",
120120 .description = "Use the popc (population count) instruction",
121 .dependencies = 0,
121 .dependencies = featureSet(&[_]Feature{}),
122122 };
123123 result[@enumToInt(Feature.soft_float)] = .{
124124 .index = @enumToInt(Feature.soft_float),
125125 .name = @tagName(Feature.soft_float),
126126 .llvm_name = "soft-float",
127127 .description = "Use software emulation for floating point",
128 .dependencies = 0,
128 .dependencies = featureSet(&[_]Feature{}),
129129 };
130130 result[@enumToInt(Feature.soft_mul_div)] = .{
131131 .index = @enumToInt(Feature.soft_mul_div),
132132 .name = @tagName(Feature.soft_mul_div),
133133 .llvm_name = "soft-mul-div",
134134 .description = "Use software emulation for integer multiply and divide",
135 .dependencies = 0,
135 .dependencies = featureSet(&[_]Feature{}),
136136 };
137137 result[@enumToInt(Feature.v9)] = .{
138138 .index = @enumToInt(Feature.v9),
139139 .name = @tagName(Feature.v9),
140140 .llvm_name = "v9",
141141 .description = "Enable SPARC-V9 instructions",
142 .dependencies = 0,
142 .dependencies = featureSet(&[_]Feature{}),
143143 };
144144 result[@enumToInt(Feature.vis)] = .{
145145 .index = @enumToInt(Feature.vis),
146146 .name = @tagName(Feature.vis),
147147 .llvm_name = "vis",
148148 .description = "Enable UltraSPARC Visual Instruction Set extensions",
149 .dependencies = 0,
149 .dependencies = featureSet(&[_]Feature{}),
150150 };
151151 result[@enumToInt(Feature.vis2)] = .{
152152 .index = @enumToInt(Feature.vis2),
153153 .name = @tagName(Feature.vis2),
154154 .llvm_name = "vis2",
155155 .description = "Enable Visual Instruction Set extensions II",
156 .dependencies = 0,
156 .dependencies = featureSet(&[_]Feature{}),
157157 };
158158 result[@enumToInt(Feature.vis3)] = .{
159159 .index = @enumToInt(Feature.vis3),
160160 .name = @tagName(Feature.vis3),
161161 .llvm_name = "vis3",
162162 .description = "Enable Visual Instruction Set extensions III",
163 .dependencies = 0,
163 .dependencies = featureSet(&[_]Feature{}),
164164 };
165165 break :blk result;
166166};
......@@ -185,12 +185,12 @@ pub const cpu = struct {
185185 pub const f934 = Cpu{
186186 .name = "f934",
187187 .llvm_name = "f934",
188 .features = 0,
188 .features = featureSet(&[_]Feature{}),
189189 };
190190 pub const generic = Cpu{
191191 .name = "generic",
192192 .llvm_name = "generic",
193 .features = 0,
193 .features = featureSet(&[_]Feature{}),
194194 };
195195 pub const gr712rc = Cpu{
196196 .name = "gr712rc",
......@@ -214,7 +214,7 @@ pub const cpu = struct {
214214 pub const hypersparc = Cpu{
215215 .name = "hypersparc",
216216 .llvm_name = "hypersparc",
217 .features = 0,
217 .features = featureSet(&[_]Feature{}),
218218 };
219219 pub const leon2 = Cpu{
220220 .name = "leon2",
......@@ -407,27 +407,27 @@ pub const cpu = struct {
407407 pub const sparclet = Cpu{
408408 .name = "sparclet",
409409 .llvm_name = "sparclet",
410 .features = 0,
410 .features = featureSet(&[_]Feature{}),
411411 };
412412 pub const sparclite = Cpu{
413413 .name = "sparclite",
414414 .llvm_name = "sparclite",
415 .features = 0,
415 .features = featureSet(&[_]Feature{}),
416416 };
417417 pub const sparclite86x = Cpu{
418418 .name = "sparclite86x",
419419 .llvm_name = "sparclite86x",
420 .features = 0,
420 .features = featureSet(&[_]Feature{}),
421421 };
422422 pub const supersparc = Cpu{
423423 .name = "supersparc",
424424 .llvm_name = "supersparc",
425 .features = 0,
425 .features = featureSet(&[_]Feature{}),
426426 };
427427 pub const tsc701 = Cpu{
428428 .name = "tsc701",
429429 .llvm_name = "tsc701",
430 .features = 0,
430 .features = featureSet(&[_]Feature{}),
431431 };
432432 pub const ultrasparc = Cpu{
433433 .name = "ultrasparc",
......@@ -470,7 +470,7 @@ pub const cpu = struct {
470470 pub const v8 = Cpu{
471471 .name = "v8",
472472 .llvm_name = "v8",
473 .features = 0,
473 .features = featureSet(&[_]Feature{}),
474474 };
475475 pub const v9 = Cpu{
476476 .name = "v9",
lib/std/target/systemz.zig+39-39
......@@ -43,252 +43,252 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
4343
4444pub const all_features = blk: {
4545 const len = @typeInfo(Feature).Enum.fields.len;
46 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
46 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
4747 var result: [len]Cpu.Feature = undefined;
4848 result[@enumToInt(Feature.deflate_conversion)] = .{
4949 .index = @enumToInt(Feature.deflate_conversion),
5050 .name = @tagName(Feature.deflate_conversion),
5151 .llvm_name = "deflate-conversion",
5252 .description = "Assume that the deflate-conversion facility is installed",
53 .dependencies = 0,
53 .dependencies = featureSet(&[_]Feature{}),
5454 };
5555 result[@enumToInt(Feature.dfp_packed_conversion)] = .{
5656 .index = @enumToInt(Feature.dfp_packed_conversion),
5757 .name = @tagName(Feature.dfp_packed_conversion),
5858 .llvm_name = "dfp-packed-conversion",
5959 .description = "Assume that the DFP packed-conversion facility is installed",
60 .dependencies = 0,
60 .dependencies = featureSet(&[_]Feature{}),
6161 };
6262 result[@enumToInt(Feature.dfp_zoned_conversion)] = .{
6363 .index = @enumToInt(Feature.dfp_zoned_conversion),
6464 .name = @tagName(Feature.dfp_zoned_conversion),
6565 .llvm_name = "dfp-zoned-conversion",
6666 .description = "Assume that the DFP zoned-conversion facility is installed",
67 .dependencies = 0,
67 .dependencies = featureSet(&[_]Feature{}),
6868 };
6969 result[@enumToInt(Feature.distinct_ops)] = .{
7070 .index = @enumToInt(Feature.distinct_ops),
7171 .name = @tagName(Feature.distinct_ops),
7272 .llvm_name = "distinct-ops",
7373 .description = "Assume that the distinct-operands facility is installed",
74 .dependencies = 0,
74 .dependencies = featureSet(&[_]Feature{}),
7575 };
7676 result[@enumToInt(Feature.enhanced_dat_2)] = .{
7777 .index = @enumToInt(Feature.enhanced_dat_2),
7878 .name = @tagName(Feature.enhanced_dat_2),
7979 .llvm_name = "enhanced-dat-2",
8080 .description = "Assume that the enhanced-DAT facility 2 is installed",
81 .dependencies = 0,
81 .dependencies = featureSet(&[_]Feature{}),
8282 };
8383 result[@enumToInt(Feature.enhanced_sort)] = .{
8484 .index = @enumToInt(Feature.enhanced_sort),
8585 .name = @tagName(Feature.enhanced_sort),
8686 .llvm_name = "enhanced-sort",
8787 .description = "Assume that the enhanced-sort facility is installed",
88 .dependencies = 0,
88 .dependencies = featureSet(&[_]Feature{}),
8989 };
9090 result[@enumToInt(Feature.execution_hint)] = .{
9191 .index = @enumToInt(Feature.execution_hint),
9292 .name = @tagName(Feature.execution_hint),
9393 .llvm_name = "execution-hint",
9494 .description = "Assume that the execution-hint facility is installed",
95 .dependencies = 0,
95 .dependencies = featureSet(&[_]Feature{}),
9696 };
9797 result[@enumToInt(Feature.fast_serialization)] = .{
9898 .index = @enumToInt(Feature.fast_serialization),
9999 .name = @tagName(Feature.fast_serialization),
100100 .llvm_name = "fast-serialization",
101101 .description = "Assume that the fast-serialization facility is installed",
102 .dependencies = 0,
102 .dependencies = featureSet(&[_]Feature{}),
103103 };
104104 result[@enumToInt(Feature.fp_extension)] = .{
105105 .index = @enumToInt(Feature.fp_extension),
106106 .name = @tagName(Feature.fp_extension),
107107 .llvm_name = "fp-extension",
108108 .description = "Assume that the floating-point extension facility is installed",
109 .dependencies = 0,
109 .dependencies = featureSet(&[_]Feature{}),
110110 };
111111 result[@enumToInt(Feature.guarded_storage)] = .{
112112 .index = @enumToInt(Feature.guarded_storage),
113113 .name = @tagName(Feature.guarded_storage),
114114 .llvm_name = "guarded-storage",
115115 .description = "Assume that the guarded-storage facility is installed",
116 .dependencies = 0,
116 .dependencies = featureSet(&[_]Feature{}),
117117 };
118118 result[@enumToInt(Feature.high_word)] = .{
119119 .index = @enumToInt(Feature.high_word),
120120 .name = @tagName(Feature.high_word),
121121 .llvm_name = "high-word",
122122 .description = "Assume that the high-word facility is installed",
123 .dependencies = 0,
123 .dependencies = featureSet(&[_]Feature{}),
124124 };
125125 result[@enumToInt(Feature.insert_reference_bits_multiple)] = .{
126126 .index = @enumToInt(Feature.insert_reference_bits_multiple),
127127 .name = @tagName(Feature.insert_reference_bits_multiple),
128128 .llvm_name = "insert-reference-bits-multiple",
129129 .description = "Assume that the insert-reference-bits-multiple facility is installed",
130 .dependencies = 0,
130 .dependencies = featureSet(&[_]Feature{}),
131131 };
132132 result[@enumToInt(Feature.interlocked_access1)] = .{
133133 .index = @enumToInt(Feature.interlocked_access1),
134134 .name = @tagName(Feature.interlocked_access1),
135135 .llvm_name = "interlocked-access1",
136136 .description = "Assume that interlocked-access facility 1 is installed",
137 .dependencies = 0,
137 .dependencies = featureSet(&[_]Feature{}),
138138 };
139139 result[@enumToInt(Feature.load_and_trap)] = .{
140140 .index = @enumToInt(Feature.load_and_trap),
141141 .name = @tagName(Feature.load_and_trap),
142142 .llvm_name = "load-and-trap",
143143 .description = "Assume that the load-and-trap facility is installed",
144 .dependencies = 0,
144 .dependencies = featureSet(&[_]Feature{}),
145145 };
146146 result[@enumToInt(Feature.load_and_zero_rightmost_byte)] = .{
147147 .index = @enumToInt(Feature.load_and_zero_rightmost_byte),
148148 .name = @tagName(Feature.load_and_zero_rightmost_byte),
149149 .llvm_name = "load-and-zero-rightmost-byte",
150150 .description = "Assume that the load-and-zero-rightmost-byte facility is installed",
151 .dependencies = 0,
151 .dependencies = featureSet(&[_]Feature{}),
152152 };
153153 result[@enumToInt(Feature.load_store_on_cond)] = .{
154154 .index = @enumToInt(Feature.load_store_on_cond),
155155 .name = @tagName(Feature.load_store_on_cond),
156156 .llvm_name = "load-store-on-cond",
157157 .description = "Assume that the load/store-on-condition facility is installed",
158 .dependencies = 0,
158 .dependencies = featureSet(&[_]Feature{}),
159159 };
160160 result[@enumToInt(Feature.load_store_on_cond_2)] = .{
161161 .index = @enumToInt(Feature.load_store_on_cond_2),
162162 .name = @tagName(Feature.load_store_on_cond_2),
163163 .llvm_name = "load-store-on-cond-2",
164164 .description = "Assume that the load/store-on-condition facility 2 is installed",
165 .dependencies = 0,
165 .dependencies = featureSet(&[_]Feature{}),
166166 };
167167 result[@enumToInt(Feature.message_security_assist_extension3)] = .{
168168 .index = @enumToInt(Feature.message_security_assist_extension3),
169169 .name = @tagName(Feature.message_security_assist_extension3),
170170 .llvm_name = "message-security-assist-extension3",
171171 .description = "Assume that the message-security-assist extension facility 3 is installed",
172 .dependencies = 0,
172 .dependencies = featureSet(&[_]Feature{}),
173173 };
174174 result[@enumToInt(Feature.message_security_assist_extension4)] = .{
175175 .index = @enumToInt(Feature.message_security_assist_extension4),
176176 .name = @tagName(Feature.message_security_assist_extension4),
177177 .llvm_name = "message-security-assist-extension4",
178178 .description = "Assume that the message-security-assist extension facility 4 is installed",
179 .dependencies = 0,
179 .dependencies = featureSet(&[_]Feature{}),
180180 };
181181 result[@enumToInt(Feature.message_security_assist_extension5)] = .{
182182 .index = @enumToInt(Feature.message_security_assist_extension5),
183183 .name = @tagName(Feature.message_security_assist_extension5),
184184 .llvm_name = "message-security-assist-extension5",
185185 .description = "Assume that the message-security-assist extension facility 5 is installed",
186 .dependencies = 0,
186 .dependencies = featureSet(&[_]Feature{}),
187187 };
188188 result[@enumToInt(Feature.message_security_assist_extension7)] = .{
189189 .index = @enumToInt(Feature.message_security_assist_extension7),
190190 .name = @tagName(Feature.message_security_assist_extension7),
191191 .llvm_name = "message-security-assist-extension7",
192192 .description = "Assume that the message-security-assist extension facility 7 is installed",
193 .dependencies = 0,
193 .dependencies = featureSet(&[_]Feature{}),
194194 };
195195 result[@enumToInt(Feature.message_security_assist_extension8)] = .{
196196 .index = @enumToInt(Feature.message_security_assist_extension8),
197197 .name = @tagName(Feature.message_security_assist_extension8),
198198 .llvm_name = "message-security-assist-extension8",
199199 .description = "Assume that the message-security-assist extension facility 8 is installed",
200 .dependencies = 0,
200 .dependencies = featureSet(&[_]Feature{}),
201201 };
202202 result[@enumToInt(Feature.message_security_assist_extension9)] = .{
203203 .index = @enumToInt(Feature.message_security_assist_extension9),
204204 .name = @tagName(Feature.message_security_assist_extension9),
205205 .llvm_name = "message-security-assist-extension9",
206206 .description = "Assume that the message-security-assist extension facility 9 is installed",
207 .dependencies = 0,
207 .dependencies = featureSet(&[_]Feature{}),
208208 };
209209 result[@enumToInt(Feature.miscellaneous_extensions)] = .{
210210 .index = @enumToInt(Feature.miscellaneous_extensions),
211211 .name = @tagName(Feature.miscellaneous_extensions),
212212 .llvm_name = "miscellaneous-extensions",
213213 .description = "Assume that the miscellaneous-extensions facility is installed",
214 .dependencies = 0,
214 .dependencies = featureSet(&[_]Feature{}),
215215 };
216216 result[@enumToInt(Feature.miscellaneous_extensions_2)] = .{
217217 .index = @enumToInt(Feature.miscellaneous_extensions_2),
218218 .name = @tagName(Feature.miscellaneous_extensions_2),
219219 .llvm_name = "miscellaneous-extensions-2",
220220 .description = "Assume that the miscellaneous-extensions facility 2 is installed",
221 .dependencies = 0,
221 .dependencies = featureSet(&[_]Feature{}),
222222 };
223223 result[@enumToInt(Feature.miscellaneous_extensions_3)] = .{
224224 .index = @enumToInt(Feature.miscellaneous_extensions_3),
225225 .name = @tagName(Feature.miscellaneous_extensions_3),
226226 .llvm_name = "miscellaneous-extensions-3",
227227 .description = "Assume that the miscellaneous-extensions facility 3 is installed",
228 .dependencies = 0,
228 .dependencies = featureSet(&[_]Feature{}),
229229 };
230230 result[@enumToInt(Feature.population_count)] = .{
231231 .index = @enumToInt(Feature.population_count),
232232 .name = @tagName(Feature.population_count),
233233 .llvm_name = "population-count",
234234 .description = "Assume that the population-count facility is installed",
235 .dependencies = 0,
235 .dependencies = featureSet(&[_]Feature{}),
236236 };
237237 result[@enumToInt(Feature.processor_assist)] = .{
238238 .index = @enumToInt(Feature.processor_assist),
239239 .name = @tagName(Feature.processor_assist),
240240 .llvm_name = "processor-assist",
241241 .description = "Assume that the processor-assist facility is installed",
242 .dependencies = 0,
242 .dependencies = featureSet(&[_]Feature{}),
243243 };
244244 result[@enumToInt(Feature.reset_reference_bits_multiple)] = .{
245245 .index = @enumToInt(Feature.reset_reference_bits_multiple),
246246 .name = @tagName(Feature.reset_reference_bits_multiple),
247247 .llvm_name = "reset-reference-bits-multiple",
248248 .description = "Assume that the reset-reference-bits-multiple facility is installed",
249 .dependencies = 0,
249 .dependencies = featureSet(&[_]Feature{}),
250250 };
251251 result[@enumToInt(Feature.transactional_execution)] = .{
252252 .index = @enumToInt(Feature.transactional_execution),
253253 .name = @tagName(Feature.transactional_execution),
254254 .llvm_name = "transactional-execution",
255255 .description = "Assume that the transactional-execution facility is installed",
256 .dependencies = 0,
256 .dependencies = featureSet(&[_]Feature{}),
257257 };
258258 result[@enumToInt(Feature.vector)] = .{
259259 .index = @enumToInt(Feature.vector),
260260 .name = @tagName(Feature.vector),
261261 .llvm_name = "vector",
262262 .description = "Assume that the vectory facility is installed",
263 .dependencies = 0,
263 .dependencies = featureSet(&[_]Feature{}),
264264 };
265265 result[@enumToInt(Feature.vector_enhancements_1)] = .{
266266 .index = @enumToInt(Feature.vector_enhancements_1),
267267 .name = @tagName(Feature.vector_enhancements_1),
268268 .llvm_name = "vector-enhancements-1",
269269 .description = "Assume that the vector enhancements facility 1 is installed",
270 .dependencies = 0,
270 .dependencies = featureSet(&[_]Feature{}),
271271 };
272272 result[@enumToInt(Feature.vector_enhancements_2)] = .{
273273 .index = @enumToInt(Feature.vector_enhancements_2),
274274 .name = @tagName(Feature.vector_enhancements_2),
275275 .llvm_name = "vector-enhancements-2",
276276 .description = "Assume that the vector enhancements facility 2 is installed",
277 .dependencies = 0,
277 .dependencies = featureSet(&[_]Feature{}),
278278 };
279279 result[@enumToInt(Feature.vector_packed_decimal)] = .{
280280 .index = @enumToInt(Feature.vector_packed_decimal),
281281 .name = @tagName(Feature.vector_packed_decimal),
282282 .llvm_name = "vector-packed-decimal",
283283 .description = "Assume that the vector packed decimal facility is installed",
284 .dependencies = 0,
284 .dependencies = featureSet(&[_]Feature{}),
285285 };
286286 result[@enumToInt(Feature.vector_packed_decimal_enhancement)] = .{
287287 .index = @enumToInt(Feature.vector_packed_decimal_enhancement),
288288 .name = @tagName(Feature.vector_packed_decimal_enhancement),
289289 .llvm_name = "vector-packed-decimal-enhancement",
290290 .description = "Assume that the vector packed decimal enhancement facility is installed",
291 .dependencies = 0,
291 .dependencies = featureSet(&[_]Feature{}),
292292 };
293293 break :blk result;
294294};
......@@ -424,7 +424,7 @@ pub const cpu = struct {
424424 pub const arch8 = Cpu{
425425 .name = "arch8",
426426 .llvm_name = "arch8",
427 .features = 0,
427 .features = featureSet(&[_]Feature{}),
428428 };
429429 pub const arch9 = Cpu{
430430 .name = "arch9",
......@@ -445,12 +445,12 @@ pub const cpu = struct {
445445 pub const generic = Cpu{
446446 .name = "generic",
447447 .llvm_name = "generic",
448 .features = 0,
448 .features = featureSet(&[_]Feature{}),
449449 };
450450 pub const z10 = Cpu{
451451 .name = "z10",
452452 .llvm_name = "z10",
453 .features = 0,
453 .features = featureSet(&[_]Feature{}),
454454 };
455455 pub const z13 = Cpu{
456456 .name = "z13",
lib/std/target/wasm.zig+12-12
......@@ -18,70 +18,70 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
1818
1919pub const all_features = blk: {
2020 const len = @typeInfo(Feature).Enum.fields.len;
21 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
21 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
2222 var result: [len]Cpu.Feature = undefined;
2323 result[@enumToInt(Feature.atomics)] = .{
2424 .index = @enumToInt(Feature.atomics),
2525 .name = @tagName(Feature.atomics),
2626 .llvm_name = "atomics",
2727 .description = "Enable Atomics",
28 .dependencies = 0,
28 .dependencies = featureSet(&[_]Feature{}),
2929 };
3030 result[@enumToInt(Feature.bulk_memory)] = .{
3131 .index = @enumToInt(Feature.bulk_memory),
3232 .name = @tagName(Feature.bulk_memory),
3333 .llvm_name = "bulk-memory",
3434 .description = "Enable bulk memory operations",
35 .dependencies = 0,
35 .dependencies = featureSet(&[_]Feature{}),
3636 };
3737 result[@enumToInt(Feature.exception_handling)] = .{
3838 .index = @enumToInt(Feature.exception_handling),
3939 .name = @tagName(Feature.exception_handling),
4040 .llvm_name = "exception-handling",
4141 .description = "Enable Wasm exception handling",
42 .dependencies = 0,
42 .dependencies = featureSet(&[_]Feature{}),
4343 };
4444 result[@enumToInt(Feature.multivalue)] = .{
4545 .index = @enumToInt(Feature.multivalue),
4646 .name = @tagName(Feature.multivalue),
4747 .llvm_name = "multivalue",
4848 .description = "Enable multivalue blocks, instructions, and functions",
49 .dependencies = 0,
49 .dependencies = featureSet(&[_]Feature{}),
5050 };
5151 result[@enumToInt(Feature.mutable_globals)] = .{
5252 .index = @enumToInt(Feature.mutable_globals),
5353 .name = @tagName(Feature.mutable_globals),
5454 .llvm_name = "mutable-globals",
5555 .description = "Enable mutable globals",
56 .dependencies = 0,
56 .dependencies = featureSet(&[_]Feature{}),
5757 };
5858 result[@enumToInt(Feature.nontrapping_fptoint)] = .{
5959 .index = @enumToInt(Feature.nontrapping_fptoint),
6060 .name = @tagName(Feature.nontrapping_fptoint),
6161 .llvm_name = "nontrapping-fptoint",
6262 .description = "Enable non-trapping float-to-int conversion operators",
63 .dependencies = 0,
63 .dependencies = featureSet(&[_]Feature{}),
6464 };
6565 result[@enumToInt(Feature.sign_ext)] = .{
6666 .index = @enumToInt(Feature.sign_ext),
6767 .name = @tagName(Feature.sign_ext),
6868 .llvm_name = "sign-ext",
6969 .description = "Enable sign extension operators",
70 .dependencies = 0,
70 .dependencies = featureSet(&[_]Feature{}),
7171 };
7272 result[@enumToInt(Feature.simd128)] = .{
7373 .index = @enumToInt(Feature.simd128),
7474 .name = @tagName(Feature.simd128),
7575 .llvm_name = "simd128",
7676 .description = "Enable 128-bit SIMD",
77 .dependencies = 0,
77 .dependencies = featureSet(&[_]Feature{}),
7878 };
7979 result[@enumToInt(Feature.tail_call)] = .{
8080 .index = @enumToInt(Feature.tail_call),
8181 .name = @tagName(Feature.tail_call),
8282 .llvm_name = "tail-call",
8383 .description = "Enable tail call instructions",
84 .dependencies = 0,
84 .dependencies = featureSet(&[_]Feature{}),
8585 };
8686 result[@enumToInt(Feature.unimplemented_simd128)] = .{
8787 .index = @enumToInt(Feature.unimplemented_simd128),
......@@ -110,12 +110,12 @@ pub const cpu = struct {
110110 pub const generic = Cpu{
111111 .name = "generic",
112112 .llvm_name = "generic",
113 .features = 0,
113 .features = featureSet(&[_]Feature{}),
114114 };
115115 pub const mvp = Cpu{
116116 .name = "mvp",
117117 .llvm_name = "mvp",
118 .features = 0,
118 .features = featureSet(&[_]Feature{}),
119119 };
120120};
121121
lib/std/target/x86.zig+87-87
......@@ -132,21 +132,21 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
132132
133133pub const all_features = blk: {
134134 const len = @typeInfo(Feature).Enum.fields.len;
135 std.debug.assert(len <= @typeInfo(Cpu.Feature.Set).Int.bits);
135 std.debug.assert(len <= Cpu.Feature.Set.bit_count);
136136 var result: [len]Cpu.Feature = undefined;
137137 result[@enumToInt(Feature.@"16bit_mode")] = .{
138138 .index = @enumToInt(Feature.@"16bit_mode"),
139139 .name = @tagName(Feature.@"16bit_mode"),
140140 .llvm_name = "16bit-mode",
141141 .description = "16-bit mode (i8086)",
142 .dependencies = 0,
142 .dependencies = featureSet(&[_]Feature{}),
143143 };
144144 result[@enumToInt(Feature.@"32bit_mode")] = .{
145145 .index = @enumToInt(Feature.@"32bit_mode"),
146146 .name = @tagName(Feature.@"32bit_mode"),
147147 .llvm_name = "32bit-mode",
148148 .description = "32-bit mode (80386)",
149 .dependencies = 0,
149 .dependencies = featureSet(&[_]Feature{}),
150150 };
151151 result[@enumToInt(Feature.@"3dnow")] = .{
152152 .index = @enumToInt(Feature.@"3dnow"),
......@@ -171,21 +171,21 @@ pub const all_features = blk: {
171171 .name = @tagName(Feature.@"64bit"),
172172 .llvm_name = "64bit",
173173 .description = "Support 64-bit instructions",
174 .dependencies = 0,
174 .dependencies = featureSet(&[_]Feature{}),
175175 };
176176 result[@enumToInt(Feature.@"64bit_mode")] = .{
177177 .index = @enumToInt(Feature.@"64bit_mode"),
178178 .name = @tagName(Feature.@"64bit_mode"),
179179 .llvm_name = "64bit-mode",
180180 .description = "64-bit mode (x86_64)",
181 .dependencies = 0,
181 .dependencies = featureSet(&[_]Feature{}),
182182 };
183183 result[@enumToInt(Feature.adx)] = .{
184184 .index = @enumToInt(Feature.adx),
185185 .name = @tagName(Feature.adx),
186186 .llvm_name = "adx",
187187 .description = "Support ADX instructions",
188 .dependencies = 0,
188 .dependencies = featureSet(&[_]Feature{}),
189189 };
190190 result[@enumToInt(Feature.aes)] = .{
191191 .index = @enumToInt(Feature.aes),
......@@ -356,56 +356,56 @@ pub const all_features = blk: {
356356 .name = @tagName(Feature.bmi),
357357 .llvm_name = "bmi",
358358 .description = "Support BMI instructions",
359 .dependencies = 0,
359 .dependencies = featureSet(&[_]Feature{}),
360360 };
361361 result[@enumToInt(Feature.bmi2)] = .{
362362 .index = @enumToInt(Feature.bmi2),
363363 .name = @tagName(Feature.bmi2),
364364 .llvm_name = "bmi2",
365365 .description = "Support BMI2 instructions",
366 .dependencies = 0,
366 .dependencies = featureSet(&[_]Feature{}),
367367 };
368368 result[@enumToInt(Feature.branchfusion)] = .{
369369 .index = @enumToInt(Feature.branchfusion),
370370 .name = @tagName(Feature.branchfusion),
371371 .llvm_name = "branchfusion",
372372 .description = "CMP/TEST can be fused with conditional branches",
373 .dependencies = 0,
373 .dependencies = featureSet(&[_]Feature{}),
374374 };
375375 result[@enumToInt(Feature.cldemote)] = .{
376376 .index = @enumToInt(Feature.cldemote),
377377 .name = @tagName(Feature.cldemote),
378378 .llvm_name = "cldemote",
379379 .description = "Enable Cache Demote",
380 .dependencies = 0,
380 .dependencies = featureSet(&[_]Feature{}),
381381 };
382382 result[@enumToInt(Feature.clflushopt)] = .{
383383 .index = @enumToInt(Feature.clflushopt),
384384 .name = @tagName(Feature.clflushopt),
385385 .llvm_name = "clflushopt",
386386 .description = "Flush A Cache Line Optimized",
387 .dependencies = 0,
387 .dependencies = featureSet(&[_]Feature{}),
388388 };
389389 result[@enumToInt(Feature.clwb)] = .{
390390 .index = @enumToInt(Feature.clwb),
391391 .name = @tagName(Feature.clwb),
392392 .llvm_name = "clwb",
393393 .description = "Cache Line Write Back",
394 .dependencies = 0,
394 .dependencies = featureSet(&[_]Feature{}),
395395 };
396396 result[@enumToInt(Feature.clzero)] = .{
397397 .index = @enumToInt(Feature.clzero),
398398 .name = @tagName(Feature.clzero),
399399 .llvm_name = "clzero",
400400 .description = "Enable Cache Line Zero",
401 .dependencies = 0,
401 .dependencies = featureSet(&[_]Feature{}),
402402 };
403403 result[@enumToInt(Feature.cmov)] = .{
404404 .index = @enumToInt(Feature.cmov),
405405 .name = @tagName(Feature.cmov),
406406 .llvm_name = "cmov",
407407 .description = "Enable conditional move instructions",
408 .dependencies = 0,
408 .dependencies = featureSet(&[_]Feature{}),
409409 };
410410 result[@enumToInt(Feature.cx16)] = .{
411411 .index = @enumToInt(Feature.cx16),
......@@ -421,21 +421,21 @@ pub const all_features = blk: {
421421 .name = @tagName(Feature.cx8),
422422 .llvm_name = "cx8",
423423 .description = "Support CMPXCHG8B instructions",
424 .dependencies = 0,
424 .dependencies = featureSet(&[_]Feature{}),
425425 };
426426 result[@enumToInt(Feature.enqcmd)] = .{
427427 .index = @enumToInt(Feature.enqcmd),
428428 .name = @tagName(Feature.enqcmd),
429429 .llvm_name = "enqcmd",
430430 .description = "Has ENQCMD instructions",
431 .dependencies = 0,
431 .dependencies = featureSet(&[_]Feature{}),
432432 };
433433 result[@enumToInt(Feature.ermsb)] = .{
434434 .index = @enumToInt(Feature.ermsb),
435435 .name = @tagName(Feature.ermsb),
436436 .llvm_name = "ermsb",
437437 .description = "REP MOVS/STOS are fast",
438 .dependencies = 0,
438 .dependencies = featureSet(&[_]Feature{}),
439439 };
440440 result[@enumToInt(Feature.f16c)] = .{
441441 .index = @enumToInt(Feature.f16c),
......@@ -451,42 +451,42 @@ pub const all_features = blk: {
451451 .name = @tagName(Feature.false_deps_lzcnt_tzcnt),
452452 .llvm_name = "false-deps-lzcnt-tzcnt",
453453 .description = "LZCNT/TZCNT have a false dependency on dest register",
454 .dependencies = 0,
454 .dependencies = featureSet(&[_]Feature{}),
455455 };
456456 result[@enumToInt(Feature.false_deps_popcnt)] = .{
457457 .index = @enumToInt(Feature.false_deps_popcnt),
458458 .name = @tagName(Feature.false_deps_popcnt),
459459 .llvm_name = "false-deps-popcnt",
460460 .description = "POPCNT has a false dependency on dest register",
461 .dependencies = 0,
461 .dependencies = featureSet(&[_]Feature{}),
462462 };
463463 result[@enumToInt(Feature.fast_11bytenop)] = .{
464464 .index = @enumToInt(Feature.fast_11bytenop),
465465 .name = @tagName(Feature.fast_11bytenop),
466466 .llvm_name = "fast-11bytenop",
467467 .description = "Target can quickly decode up to 11 byte NOPs",
468 .dependencies = 0,
468 .dependencies = featureSet(&[_]Feature{}),
469469 };
470470 result[@enumToInt(Feature.fast_15bytenop)] = .{
471471 .index = @enumToInt(Feature.fast_15bytenop),
472472 .name = @tagName(Feature.fast_15bytenop),
473473 .llvm_name = "fast-15bytenop",
474474 .description = "Target can quickly decode up to 15 byte NOPs",
475 .dependencies = 0,
475 .dependencies = featureSet(&[_]Feature{}),
476476 };
477477 result[@enumToInt(Feature.fast_bextr)] = .{
478478 .index = @enumToInt(Feature.fast_bextr),
479479 .name = @tagName(Feature.fast_bextr),
480480 .llvm_name = "fast-bextr",
481481 .description = "Indicates that the BEXTR instruction is implemented as a single uop with good throughput",
482 .dependencies = 0,
482 .dependencies = featureSet(&[_]Feature{}),
483483 };
484484 result[@enumToInt(Feature.fast_gather)] = .{
485485 .index = @enumToInt(Feature.fast_gather),
486486 .name = @tagName(Feature.fast_gather),
487487 .llvm_name = "fast-gather",
488488 .description = "Indicates if gather is reasonably fast",
489 .dependencies = 0,
489 .dependencies = featureSet(&[_]Feature{}),
490490 };
491491 result[@enumToInt(Feature.fast_hops)] = .{
492492 .index = @enumToInt(Feature.fast_hops),
......@@ -502,56 +502,56 @@ pub const all_features = blk: {
502502 .name = @tagName(Feature.fast_lzcnt),
503503 .llvm_name = "fast-lzcnt",
504504 .description = "LZCNT instructions are as fast as most simple integer ops",
505 .dependencies = 0,
505 .dependencies = featureSet(&[_]Feature{}),
506506 };
507507 result[@enumToInt(Feature.fast_partial_ymm_or_zmm_write)] = .{
508508 .index = @enumToInt(Feature.fast_partial_ymm_or_zmm_write),
509509 .name = @tagName(Feature.fast_partial_ymm_or_zmm_write),
510510 .llvm_name = "fast-partial-ymm-or-zmm-write",
511511 .description = "Partial writes to YMM/ZMM registers are fast",
512 .dependencies = 0,
512 .dependencies = featureSet(&[_]Feature{}),
513513 };
514514 result[@enumToInt(Feature.fast_scalar_fsqrt)] = .{
515515 .index = @enumToInt(Feature.fast_scalar_fsqrt),
516516 .name = @tagName(Feature.fast_scalar_fsqrt),
517517 .llvm_name = "fast-scalar-fsqrt",
518518 .description = "Scalar SQRT is fast (disable Newton-Raphson)",
519 .dependencies = 0,
519 .dependencies = featureSet(&[_]Feature{}),
520520 };
521521 result[@enumToInt(Feature.fast_scalar_shift_masks)] = .{
522522 .index = @enumToInt(Feature.fast_scalar_shift_masks),
523523 .name = @tagName(Feature.fast_scalar_shift_masks),
524524 .llvm_name = "fast-scalar-shift-masks",
525525 .description = "Prefer a left/right scalar logical shift pair over a shift+and pair",
526 .dependencies = 0,
526 .dependencies = featureSet(&[_]Feature{}),
527527 };
528528 result[@enumToInt(Feature.fast_shld_rotate)] = .{
529529 .index = @enumToInt(Feature.fast_shld_rotate),
530530 .name = @tagName(Feature.fast_shld_rotate),
531531 .llvm_name = "fast-shld-rotate",
532532 .description = "SHLD can be used as a faster rotate",
533 .dependencies = 0,
533 .dependencies = featureSet(&[_]Feature{}),
534534 };
535535 result[@enumToInt(Feature.fast_variable_shuffle)] = .{
536536 .index = @enumToInt(Feature.fast_variable_shuffle),
537537 .name = @tagName(Feature.fast_variable_shuffle),
538538 .llvm_name = "fast-variable-shuffle",
539539 .description = "Shuffles with variable masks are fast",
540 .dependencies = 0,
540 .dependencies = featureSet(&[_]Feature{}),
541541 };
542542 result[@enumToInt(Feature.fast_vector_fsqrt)] = .{
543543 .index = @enumToInt(Feature.fast_vector_fsqrt),
544544 .name = @tagName(Feature.fast_vector_fsqrt),
545545 .llvm_name = "fast-vector-fsqrt",
546546 .description = "Vector SQRT is fast (disable Newton-Raphson)",
547 .dependencies = 0,
547 .dependencies = featureSet(&[_]Feature{}),
548548 };
549549 result[@enumToInt(Feature.fast_vector_shift_masks)] = .{
550550 .index = @enumToInt(Feature.fast_vector_shift_masks),
551551 .name = @tagName(Feature.fast_vector_shift_masks),
552552 .llvm_name = "fast-vector-shift-masks",
553553 .description = "Prefer a left/right vector logical shift pair over a shift+and pair",
554 .dependencies = 0,
554 .dependencies = featureSet(&[_]Feature{}),
555555 };
556556 result[@enumToInt(Feature.fma)] = .{
557557 .index = @enumToInt(Feature.fma),
......@@ -577,14 +577,14 @@ pub const all_features = blk: {
577577 .name = @tagName(Feature.fsgsbase),
578578 .llvm_name = "fsgsbase",
579579 .description = "Support FS/GS Base instructions",
580 .dependencies = 0,
580 .dependencies = featureSet(&[_]Feature{}),
581581 };
582582 result[@enumToInt(Feature.fxsr)] = .{
583583 .index = @enumToInt(Feature.fxsr),
584584 .name = @tagName(Feature.fxsr),
585585 .llvm_name = "fxsr",
586586 .description = "Support fxsave/fxrestore instructions",
587 .dependencies = 0,
587 .dependencies = featureSet(&[_]Feature{}),
588588 };
589589 result[@enumToInt(Feature.gfni)] = .{
590590 .index = @enumToInt(Feature.gfni),
......@@ -600,119 +600,119 @@ pub const all_features = blk: {
600600 .name = @tagName(Feature.idivl_to_divb),
601601 .llvm_name = "idivl-to-divb",
602602 .description = "Use 8-bit divide for positive values less than 256",
603 .dependencies = 0,
603 .dependencies = featureSet(&[_]Feature{}),
604604 };
605605 result[@enumToInt(Feature.idivq_to_divl)] = .{
606606 .index = @enumToInt(Feature.idivq_to_divl),
607607 .name = @tagName(Feature.idivq_to_divl),
608608 .llvm_name = "idivq-to-divl",
609609 .description = "Use 32-bit divide for positive values less than 2^32",
610 .dependencies = 0,
610 .dependencies = featureSet(&[_]Feature{}),
611611 };
612612 result[@enumToInt(Feature.invpcid)] = .{
613613 .index = @enumToInt(Feature.invpcid),
614614 .name = @tagName(Feature.invpcid),
615615 .llvm_name = "invpcid",
616616 .description = "Invalidate Process-Context Identifier",
617 .dependencies = 0,
617 .dependencies = featureSet(&[_]Feature{}),
618618 };
619619 result[@enumToInt(Feature.lea_sp)] = .{
620620 .index = @enumToInt(Feature.lea_sp),
621621 .name = @tagName(Feature.lea_sp),
622622 .llvm_name = "lea-sp",
623623 .description = "Use LEA for adjusting the stack pointer",
624 .dependencies = 0,
624 .dependencies = featureSet(&[_]Feature{}),
625625 };
626626 result[@enumToInt(Feature.lea_uses_ag)] = .{
627627 .index = @enumToInt(Feature.lea_uses_ag),
628628 .name = @tagName(Feature.lea_uses_ag),
629629 .llvm_name = "lea-uses-ag",
630630 .description = "LEA instruction needs inputs at AG stage",
631 .dependencies = 0,
631 .dependencies = featureSet(&[_]Feature{}),
632632 };
633633 result[@enumToInt(Feature.lwp)] = .{
634634 .index = @enumToInt(Feature.lwp),
635635 .name = @tagName(Feature.lwp),
636636 .llvm_name = "lwp",
637637 .description = "Enable LWP instructions",
638 .dependencies = 0,
638 .dependencies = featureSet(&[_]Feature{}),
639639 };
640640 result[@enumToInt(Feature.lzcnt)] = .{
641641 .index = @enumToInt(Feature.lzcnt),
642642 .name = @tagName(Feature.lzcnt),
643643 .llvm_name = "lzcnt",
644644 .description = "Support LZCNT instruction",
645 .dependencies = 0,
645 .dependencies = featureSet(&[_]Feature{}),
646646 };
647647 result[@enumToInt(Feature.macrofusion)] = .{
648648 .index = @enumToInt(Feature.macrofusion),
649649 .name = @tagName(Feature.macrofusion),
650650 .llvm_name = "macrofusion",
651651 .description = "Various instructions can be fused with conditional branches",
652 .dependencies = 0,
652 .dependencies = featureSet(&[_]Feature{}),
653653 };
654654 result[@enumToInt(Feature.merge_to_threeway_branch)] = .{
655655 .index = @enumToInt(Feature.merge_to_threeway_branch),
656656 .name = @tagName(Feature.merge_to_threeway_branch),
657657 .llvm_name = "merge-to-threeway-branch",
658658 .description = "Merge branches to a three-way conditional branch",
659 .dependencies = 0,
659 .dependencies = featureSet(&[_]Feature{}),
660660 };
661661 result[@enumToInt(Feature.mmx)] = .{
662662 .index = @enumToInt(Feature.mmx),
663663 .name = @tagName(Feature.mmx),
664664 .llvm_name = "mmx",
665665 .description = "Enable MMX instructions",
666 .dependencies = 0,
666 .dependencies = featureSet(&[_]Feature{}),
667667 };
668668 result[@enumToInt(Feature.movbe)] = .{
669669 .index = @enumToInt(Feature.movbe),
670670 .name = @tagName(Feature.movbe),
671671 .llvm_name = "movbe",
672672 .description = "Support MOVBE instruction",
673 .dependencies = 0,
673 .dependencies = featureSet(&[_]Feature{}),
674674 };
675675 result[@enumToInt(Feature.movdir64b)] = .{
676676 .index = @enumToInt(Feature.movdir64b),
677677 .name = @tagName(Feature.movdir64b),
678678 .llvm_name = "movdir64b",
679679 .description = "Support movdir64b instruction",
680 .dependencies = 0,
680 .dependencies = featureSet(&[_]Feature{}),
681681 };
682682 result[@enumToInt(Feature.movdiri)] = .{
683683 .index = @enumToInt(Feature.movdiri),
684684 .name = @tagName(Feature.movdiri),
685685 .llvm_name = "movdiri",
686686 .description = "Support movdiri instruction",
687 .dependencies = 0,
687 .dependencies = featureSet(&[_]Feature{}),
688688 };
689689 result[@enumToInt(Feature.mpx)] = .{
690690 .index = @enumToInt(Feature.mpx),
691691 .name = @tagName(Feature.mpx),
692692 .llvm_name = "mpx",
693693 .description = "Support MPX instructions",
694 .dependencies = 0,
694 .dependencies = featureSet(&[_]Feature{}),
695695 };
696696 result[@enumToInt(Feature.mwaitx)] = .{
697697 .index = @enumToInt(Feature.mwaitx),
698698 .name = @tagName(Feature.mwaitx),
699699 .llvm_name = "mwaitx",
700700 .description = "Enable MONITORX/MWAITX timer functionality",
701 .dependencies = 0,
701 .dependencies = featureSet(&[_]Feature{}),
702702 };
703703 result[@enumToInt(Feature.nopl)] = .{
704704 .index = @enumToInt(Feature.nopl),
705705 .name = @tagName(Feature.nopl),
706706 .llvm_name = "nopl",
707707 .description = "Enable NOPL instruction",
708 .dependencies = 0,
708 .dependencies = featureSet(&[_]Feature{}),
709709 };
710710 result[@enumToInt(Feature.pad_short_functions)] = .{
711711 .index = @enumToInt(Feature.pad_short_functions),
712712 .name = @tagName(Feature.pad_short_functions),
713713 .llvm_name = "pad-short-functions",
714714 .description = "Pad short functions",
715 .dependencies = 0,
715 .dependencies = featureSet(&[_]Feature{}),
716716 };
717717 result[@enumToInt(Feature.pclmul)] = .{
718718 .index = @enumToInt(Feature.pclmul),
......@@ -728,70 +728,70 @@ pub const all_features = blk: {
728728 .name = @tagName(Feature.pconfig),
729729 .llvm_name = "pconfig",
730730 .description = "platform configuration instruction",
731 .dependencies = 0,
731 .dependencies = featureSet(&[_]Feature{}),
732732 };
733733 result[@enumToInt(Feature.pku)] = .{
734734 .index = @enumToInt(Feature.pku),
735735 .name = @tagName(Feature.pku),
736736 .llvm_name = "pku",
737737 .description = "Enable protection keys",
738 .dependencies = 0,
738 .dependencies = featureSet(&[_]Feature{}),
739739 };
740740 result[@enumToInt(Feature.popcnt)] = .{
741741 .index = @enumToInt(Feature.popcnt),
742742 .name = @tagName(Feature.popcnt),
743743 .llvm_name = "popcnt",
744744 .description = "Support POPCNT instruction",
745 .dependencies = 0,
745 .dependencies = featureSet(&[_]Feature{}),
746746 };
747747 result[@enumToInt(Feature.prefer_256_bit)] = .{
748748 .index = @enumToInt(Feature.prefer_256_bit),
749749 .name = @tagName(Feature.prefer_256_bit),
750750 .llvm_name = "prefer-256-bit",
751751 .description = "Prefer 256-bit AVX instructions",
752 .dependencies = 0,
752 .dependencies = featureSet(&[_]Feature{}),
753753 };
754754 result[@enumToInt(Feature.prefetchwt1)] = .{
755755 .index = @enumToInt(Feature.prefetchwt1),
756756 .name = @tagName(Feature.prefetchwt1),
757757 .llvm_name = "prefetchwt1",
758758 .description = "Prefetch with Intent to Write and T1 Hint",
759 .dependencies = 0,
759 .dependencies = featureSet(&[_]Feature{}),
760760 };
761761 result[@enumToInt(Feature.prfchw)] = .{
762762 .index = @enumToInt(Feature.prfchw),
763763 .name = @tagName(Feature.prfchw),
764764 .llvm_name = "prfchw",
765765 .description = "Support PRFCHW instructions",
766 .dependencies = 0,
766 .dependencies = featureSet(&[_]Feature{}),
767767 };
768768 result[@enumToInt(Feature.ptwrite)] = .{
769769 .index = @enumToInt(Feature.ptwrite),
770770 .name = @tagName(Feature.ptwrite),
771771 .llvm_name = "ptwrite",
772772 .description = "Support ptwrite instruction",
773 .dependencies = 0,
773 .dependencies = featureSet(&[_]Feature{}),
774774 };
775775 result[@enumToInt(Feature.rdpid)] = .{
776776 .index = @enumToInt(Feature.rdpid),
777777 .name = @tagName(Feature.rdpid),
778778 .llvm_name = "rdpid",
779779 .description = "Support RDPID instructions",
780 .dependencies = 0,
780 .dependencies = featureSet(&[_]Feature{}),
781781 };
782782 result[@enumToInt(Feature.rdrnd)] = .{
783783 .index = @enumToInt(Feature.rdrnd),
784784 .name = @tagName(Feature.rdrnd),
785785 .llvm_name = "rdrnd",
786786 .description = "Support RDRAND instruction",
787 .dependencies = 0,
787 .dependencies = featureSet(&[_]Feature{}),
788788 };
789789 result[@enumToInt(Feature.rdseed)] = .{
790790 .index = @enumToInt(Feature.rdseed),
791791 .name = @tagName(Feature.rdseed),
792792 .llvm_name = "rdseed",
793793 .description = "Support RDSEED instruction",
794 .dependencies = 0,
794 .dependencies = featureSet(&[_]Feature{}),
795795 };
796796 result[@enumToInt(Feature.retpoline)] = .{
797797 .index = @enumToInt(Feature.retpoline),
......@@ -817,35 +817,35 @@ pub const all_features = blk: {
817817 .name = @tagName(Feature.retpoline_indirect_branches),
818818 .llvm_name = "retpoline-indirect-branches",
819819 .description = "Remove speculation of indirect branches from the generated code",
820 .dependencies = 0,
820 .dependencies = featureSet(&[_]Feature{}),
821821 };
822822 result[@enumToInt(Feature.retpoline_indirect_calls)] = .{
823823 .index = @enumToInt(Feature.retpoline_indirect_calls),
824824 .name = @tagName(Feature.retpoline_indirect_calls),
825825 .llvm_name = "retpoline-indirect-calls",
826826 .description = "Remove speculation of indirect calls from the generated code",
827 .dependencies = 0,
827 .dependencies = featureSet(&[_]Feature{}),
828828 };
829829 result[@enumToInt(Feature.rtm)] = .{
830830 .index = @enumToInt(Feature.rtm),
831831 .name = @tagName(Feature.rtm),
832832 .llvm_name = "rtm",
833833 .description = "Support RTM instructions",
834 .dependencies = 0,
834 .dependencies = featureSet(&[_]Feature{}),
835835 };
836836 result[@enumToInt(Feature.sahf)] = .{
837837 .index = @enumToInt(Feature.sahf),
838838 .name = @tagName(Feature.sahf),
839839 .llvm_name = "sahf",
840840 .description = "Support LAHF and SAHF instructions",
841 .dependencies = 0,
841 .dependencies = featureSet(&[_]Feature{}),
842842 };
843843 result[@enumToInt(Feature.sgx)] = .{
844844 .index = @enumToInt(Feature.sgx),
845845 .name = @tagName(Feature.sgx),
846846 .llvm_name = "sgx",
847847 .description = "Enable Software Guard Extensions",
848 .dependencies = 0,
848 .dependencies = featureSet(&[_]Feature{}),
849849 };
850850 result[@enumToInt(Feature.sha)] = .{
851851 .index = @enumToInt(Feature.sha),
......@@ -861,91 +861,91 @@ pub const all_features = blk: {
861861 .name = @tagName(Feature.shstk),
862862 .llvm_name = "shstk",
863863 .description = "Support CET Shadow-Stack instructions",
864 .dependencies = 0,
864 .dependencies = featureSet(&[_]Feature{}),
865865 };
866866 result[@enumToInt(Feature.slow_3ops_lea)] = .{
867867 .index = @enumToInt(Feature.slow_3ops_lea),
868868 .name = @tagName(Feature.slow_3ops_lea),
869869 .llvm_name = "slow-3ops-lea",
870870 .description = "LEA instruction with 3 ops or certain registers is slow",
871 .dependencies = 0,
871 .dependencies = featureSet(&[_]Feature{}),
872872 };
873873 result[@enumToInt(Feature.slow_incdec)] = .{
874874 .index = @enumToInt(Feature.slow_incdec),
875875 .name = @tagName(Feature.slow_incdec),
876876 .llvm_name = "slow-incdec",
877877 .description = "INC and DEC instructions are slower than ADD and SUB",
878 .dependencies = 0,
878 .dependencies = featureSet(&[_]Feature{}),
879879 };
880880 result[@enumToInt(Feature.slow_lea)] = .{
881881 .index = @enumToInt(Feature.slow_lea),
882882 .name = @tagName(Feature.slow_lea),
883883 .llvm_name = "slow-lea",
884884 .description = "LEA instruction with certain arguments is slow",
885 .dependencies = 0,
885 .dependencies = featureSet(&[_]Feature{}),
886886 };
887887 result[@enumToInt(Feature.slow_pmaddwd)] = .{
888888 .index = @enumToInt(Feature.slow_pmaddwd),
889889 .name = @tagName(Feature.slow_pmaddwd),
890890 .llvm_name = "slow-pmaddwd",
891891 .description = "PMADDWD is slower than PMULLD",
892 .dependencies = 0,
892 .dependencies = featureSet(&[_]Feature{}),
893893 };
894894 result[@enumToInt(Feature.slow_pmulld)] = .{
895895 .index = @enumToInt(Feature.slow_pmulld),
896896 .name = @tagName(Feature.slow_pmulld),
897897 .llvm_name = "slow-pmulld",
898898 .description = "PMULLD instruction is slow",
899 .dependencies = 0,
899 .dependencies = featureSet(&[_]Feature{}),
900900 };
901901 result[@enumToInt(Feature.slow_shld)] = .{
902902 .index = @enumToInt(Feature.slow_shld),
903903 .name = @tagName(Feature.slow_shld),
904904 .llvm_name = "slow-shld",
905905 .description = "SHLD instruction is slow",
906 .dependencies = 0,
906 .dependencies = featureSet(&[_]Feature{}),
907907 };
908908 result[@enumToInt(Feature.slow_two_mem_ops)] = .{
909909 .index = @enumToInt(Feature.slow_two_mem_ops),
910910 .name = @tagName(Feature.slow_two_mem_ops),
911911 .llvm_name = "slow-two-mem-ops",
912912 .description = "Two memory operand instructions are slow",
913 .dependencies = 0,
913 .dependencies = featureSet(&[_]Feature{}),
914914 };
915915 result[@enumToInt(Feature.slow_unaligned_mem_16)] = .{
916916 .index = @enumToInt(Feature.slow_unaligned_mem_16),
917917 .name = @tagName(Feature.slow_unaligned_mem_16),
918918 .llvm_name = "slow-unaligned-mem-16",
919919 .description = "Slow unaligned 16-byte memory access",
920 .dependencies = 0,
920 .dependencies = featureSet(&[_]Feature{}),
921921 };
922922 result[@enumToInt(Feature.slow_unaligned_mem_32)] = .{
923923 .index = @enumToInt(Feature.slow_unaligned_mem_32),
924924 .name = @tagName(Feature.slow_unaligned_mem_32),
925925 .llvm_name = "slow-unaligned-mem-32",
926926 .description = "Slow unaligned 32-byte memory access",
927 .dependencies = 0,
927 .dependencies = featureSet(&[_]Feature{}),
928928 };
929929 result[@enumToInt(Feature.soft_float)] = .{
930930 .index = @enumToInt(Feature.soft_float),
931931 .name = @tagName(Feature.soft_float),
932932 .llvm_name = "soft-float",
933933 .description = "Use software floating point features",
934 .dependencies = 0,
934 .dependencies = featureSet(&[_]Feature{}),
935935 };
936936 result[@enumToInt(Feature.sse)] = .{
937937 .index = @enumToInt(Feature.sse),
938938 .name = @tagName(Feature.sse),
939939 .llvm_name = "sse",
940940 .description = "Enable SSE instructions",
941 .dependencies = 0,
941 .dependencies = featureSet(&[_]Feature{}),
942942 };
943943 result[@enumToInt(Feature.sse_unaligned_mem)] = .{
944944 .index = @enumToInt(Feature.sse_unaligned_mem),
945945 .name = @tagName(Feature.sse_unaligned_mem),
946946 .llvm_name = "sse-unaligned-mem",
947947 .description = "Allow unaligned memory operands with SSE instructions",
948 .dependencies = 0,
948 .dependencies = featureSet(&[_]Feature{}),
949949 };
950950 result[@enumToInt(Feature.sse2)] = .{
951951 .index = @enumToInt(Feature.sse2),
......@@ -1006,7 +1006,7 @@ pub const all_features = blk: {
10061006 .name = @tagName(Feature.tbm),
10071007 .llvm_name = "tbm",
10081008 .description = "Enable TBM instructions",
1009 .dependencies = 0,
1009 .dependencies = featureSet(&[_]Feature{}),
10101010 };
10111011 result[@enumToInt(Feature.vaes)] = .{
10121012 .index = @enumToInt(Feature.vaes),
......@@ -1033,21 +1033,21 @@ pub const all_features = blk: {
10331033 .name = @tagName(Feature.waitpkg),
10341034 .llvm_name = "waitpkg",
10351035 .description = "Wait and pause enhancements",
1036 .dependencies = 0,
1036 .dependencies = featureSet(&[_]Feature{}),
10371037 };
10381038 result[@enumToInt(Feature.wbnoinvd)] = .{
10391039 .index = @enumToInt(Feature.wbnoinvd),
10401040 .name = @tagName(Feature.wbnoinvd),
10411041 .llvm_name = "wbnoinvd",
10421042 .description = "Write Back No Invalidate",
1043 .dependencies = 0,
1043 .dependencies = featureSet(&[_]Feature{}),
10441044 };
10451045 result[@enumToInt(Feature.x87)] = .{
10461046 .index = @enumToInt(Feature.x87),
10471047 .name = @tagName(Feature.x87),
10481048 .llvm_name = "x87",
10491049 .description = "Enable X87 float instructions",
1050 .dependencies = 0,
1050 .dependencies = featureSet(&[_]Feature{}),
10511051 };
10521052 result[@enumToInt(Feature.xop)] = .{
10531053 .index = @enumToInt(Feature.xop),
......@@ -1063,28 +1063,28 @@ pub const all_features = blk: {
10631063 .name = @tagName(Feature.xsave),
10641064 .llvm_name = "xsave",
10651065 .description = "Support xsave instructions",
1066 .dependencies = 0,
1066 .dependencies = featureSet(&[_]Feature{}),
10671067 };
10681068 result[@enumToInt(Feature.xsavec)] = .{
10691069 .index = @enumToInt(Feature.xsavec),
10701070 .name = @tagName(Feature.xsavec),
10711071 .llvm_name = "xsavec",
10721072 .description = "Support xsavec instructions",
1073 .dependencies = 0,
1073 .dependencies = featureSet(&[_]Feature{}),
10741074 };
10751075 result[@enumToInt(Feature.xsaveopt)] = .{
10761076 .index = @enumToInt(Feature.xsaveopt),
10771077 .name = @tagName(Feature.xsaveopt),
10781078 .llvm_name = "xsaveopt",
10791079 .description = "Support xsaveopt instructions",
1080 .dependencies = 0,
1080 .dependencies = featureSet(&[_]Feature{}),
10811081 };
10821082 result[@enumToInt(Feature.xsaves)] = .{
10831083 .index = @enumToInt(Feature.xsaves),
10841084 .name = @tagName(Feature.xsaves),
10851085 .llvm_name = "xsaves",
10861086 .description = "Support xsaves instructions",
1087 .dependencies = 0,
1087 .dependencies = featureSet(&[_]Feature{}),
10881088 };
10891089 break :blk result;
10901090};
......@@ -2365,7 +2365,7 @@ pub const cpu = struct {
23652365 pub const lakemont = Cpu{
23662366 .name = "lakemont",
23672367 .llvm_name = "lakemont",
2368 .features = 0,
2368 .features = featureSet(&[_]Feature{}),
23692369 };
23702370 pub const nehalem = Cpu{
23712371 .name = "nehalem",
src-self-hosted/stage1.zig+58-19
......@@ -64,6 +64,7 @@ const Error = extern enum {
6464 CacheUnavailable,
6565 PathTooLong,
6666 CCompilerCannotFindFile,
67 NoCCompilerInstalled,
6768 ReadingDepFile,
6869 InvalidDepFile,
6970 MissingArchitecture,
......@@ -89,6 +90,7 @@ const Error = extern enum {
8990 UnknownCpuFeature,
9091 InvalidCpuFeatures,
9192 InvalidLlvmCpuFeaturesFormat,
93 UnknownApplicationBinaryInterface,
9294};
9395
9496const FILE = std.c.FILE;
......@@ -585,11 +587,12 @@ const Stage2CpuFeatures = struct {
585587
586588 fn createFromLLVM(
587589 allocator: *mem.Allocator,
588 arch_name: [*:0]const u8,
590 zig_triple: [*:0]const u8,
589591 llvm_cpu_name_z: [*:0]const u8,
590592 llvm_cpu_features: [*:0]const u8,
591593 ) !*Self {
592 const arch = try Target.parseArchSub(mem.toSliceConst(u8, arch_name));
594 const target = try Target.parse(mem.toSliceConst(u8, zig_triple));
595 const arch = target.Cross.arch;
593596 const llvm_cpu_name = mem.toSliceConst(u8, llvm_cpu_name_z);
594597
595598 for (arch.allCpus()) |cpu| {
......@@ -620,8 +623,8 @@ const Stage2CpuFeatures = struct {
620623 const this_llvm_name = feature.llvm_name orelse continue;
621624 if (mem.eql(u8, llvm_feat, this_llvm_name)) {
622625 switch (op) {
623 .add => set |= @as(Target.Cpu.Feature.Set, 1) << @intCast(u7, index),
624 .sub => set &= ~(@as(Target.Cpu.Feature.Set, 1) << @intCast(u7, index)),
626 .add => set.addFeature(@intCast(u8, index)),
627 .sub => set.removeFeature(@intCast(u8, index)),
625628 }
626629 break;
627630 }
......@@ -691,7 +694,7 @@ const Stage2CpuFeatures = struct {
691694 }
692695
693696 for (all_features) |feature, index| {
694 if (!Target.Cpu.Feature.isEnabled(feature_set, @intCast(u7, index))) continue;
697 if (!feature_set.isEnabled(@intCast(u8, index))) continue;
695698
696699 if (feature.llvm_name) |llvm_name| {
697700 try llvm_features_buffer.append("+");
......@@ -736,43 +739,75 @@ const Stage2CpuFeatures = struct {
736739// ABI warning
737740export fn stage2_cpu_features_parse_cpu(
738741 result: **Stage2CpuFeatures,
739 arch_name: [*:0]const u8,
742 zig_triple: [*:0]const u8,
740743 cpu_name: [*:0]const u8,
741744) Error {
742 result.* = parseCpu(arch_name, cpu_name) catch |err| switch (err) {
745 result.* = parseCpu(zig_triple, cpu_name) catch |err| switch (err) {
743746 error.OutOfMemory => return .OutOfMemory,
744 error.UnknownCpu => return .UnknownCpu,
745747 error.UnknownArchitecture => return .UnknownArchitecture,
746748 error.UnknownSubArchitecture => return .UnknownSubArchitecture,
749 error.UnknownOperatingSystem => return .UnknownOperatingSystem,
750 error.UnknownApplicationBinaryInterface => return .UnknownApplicationBinaryInterface,
751 error.MissingOperatingSystem => return .MissingOperatingSystem,
752 error.MissingArchitecture => return .MissingArchitecture,
747753 };
748754 return .None;
749755}
750756
751fn parseCpu(arch_name: [*:0]const u8, cpu_name: [*:0]const u8) !*Stage2CpuFeatures {
752 const arch = try Target.parseArchSub(mem.toSliceConst(u8, arch_name));
753 const cpu = try arch.parseCpu(mem.toSliceConst(u8, cpu_name));
757fn parseCpu(zig_triple: [*:0]const u8, cpu_name_z: [*:0]const u8) !*Stage2CpuFeatures {
758 const cpu_name = mem.toSliceConst(u8, cpu_name_z);
759 const target = try Target.parse(mem.toSliceConst(u8, zig_triple));
760 const arch = target.Cross.arch;
761 const cpu = arch.parseCpu(cpu_name) catch |err| switch (err) {
762 error.UnknownCpu => {
763 std.debug.warn("Unknown CPU: '{}'\nAvailable CPUs for architecture '{}':\n", .{
764 cpu_name,
765 @tagName(arch),
766 });
767 for (arch.allCpus()) |cpu| {
768 std.debug.warn(" {}\n", .{cpu.name});
769 }
770 process.exit(1);
771 },
772 else => |e| return e,
773 };
754774 return Stage2CpuFeatures.createFromCpu(std.heap.c_allocator, arch, cpu);
755775}
756776
757777// ABI warning
758778export fn stage2_cpu_features_parse_features(
759779 result: **Stage2CpuFeatures,
760 arch_name: [*:0]const u8,
780 zig_triple: [*:0]const u8,
761781 features_text: [*:0]const u8,
762782) Error {
763 result.* = parseFeatures(arch_name, features_text) catch |err| switch (err) {
783 result.* = parseFeatures(zig_triple, features_text) catch |err| switch (err) {
764784 error.OutOfMemory => return .OutOfMemory,
765 error.UnknownCpuFeature => return .UnknownCpuFeature,
766785 error.InvalidCpuFeatures => return .InvalidCpuFeatures,
767786 error.UnknownArchitecture => return .UnknownArchitecture,
768787 error.UnknownSubArchitecture => return .UnknownSubArchitecture,
788 error.UnknownOperatingSystem => return .UnknownOperatingSystem,
789 error.UnknownApplicationBinaryInterface => return .UnknownApplicationBinaryInterface,
790 error.MissingOperatingSystem => return .MissingOperatingSystem,
791 error.MissingArchitecture => return .MissingArchitecture,
769792 };
770793 return .None;
771794}
772795
773fn parseFeatures(arch_name: [*:0]const u8, features_text: [*:0]const u8) !*Stage2CpuFeatures {
774 const arch = try Target.parseArchSub(mem.toSliceConst(u8, arch_name));
775 const set = try arch.parseCpuFeatureSet(mem.toSliceConst(u8, features_text));
796fn parseFeatures(zig_triple: [*:0]const u8, features_text: [*:0]const u8) !*Stage2CpuFeatures {
797 const target = try Target.parse(mem.toSliceConst(u8, zig_triple));
798 const arch = target.Cross.arch;
799 const set = arch.parseCpuFeatureSet(mem.toSliceConst(u8, features_text)) catch |err| switch (err) {
800 error.UnknownCpuFeature => {
801 std.debug.warn("Unknown CPU features specified.\nAvailable CPU features for architecture '{}':\n", .{
802 @tagName(arch),
803 });
804 for (arch.allFeaturesList()) |feature| {
805 std.debug.warn(" {}\n", .{feature.name});
806 }
807 process.exit(1);
808 },
809 else => |e| return e,
810 };
776811 return Stage2CpuFeatures.createFromCpuFeatures(std.heap.c_allocator, arch, set);
777812}
778813
......@@ -787,13 +822,13 @@ export fn stage2_cpu_features_baseline(result: **Stage2CpuFeatures) Error {
787822// ABI warning
788823export fn stage2_cpu_features_llvm(
789824 result: **Stage2CpuFeatures,
790 arch_name: [*:0]const u8,
825 zig_triple: [*:0]const u8,
791826 llvm_cpu_name: [*:0]const u8,
792827 llvm_cpu_features: [*:0]const u8,
793828) Error {
794829 result.* = Stage2CpuFeatures.createFromLLVM(
795830 std.heap.c_allocator,
796 arch_name,
831 zig_triple,
797832 llvm_cpu_name,
798833 llvm_cpu_features,
799834 ) catch |err| switch (err) {
......@@ -801,6 +836,10 @@ export fn stage2_cpu_features_llvm(
801836 error.UnknownArchitecture => return .UnknownArchitecture,
802837 error.UnknownSubArchitecture => return .UnknownSubArchitecture,
803838 error.InvalidLlvmCpuFeaturesFormat => return .InvalidLlvmCpuFeaturesFormat,
839 error.UnknownOperatingSystem => return .UnknownOperatingSystem,
840 error.UnknownApplicationBinaryInterface => return .UnknownApplicationBinaryInterface,
841 error.MissingOperatingSystem => return .MissingOperatingSystem,
842 error.MissingArchitecture => return .MissingArchitecture,
804843 };
805844 return .None;
806845}
src/error.cpp+1
......@@ -63,6 +63,7 @@ const char *err_str(Error err) {
6363 case ErrorUnknownCpuFeature: return "unknown CPU feature";
6464 case ErrorInvalidCpuFeatures: return "invalid CPU features";
6565 case ErrorInvalidLlvmCpuFeaturesFormat: return "invalid LLVM CPU features format";
66 case ErrorUnknownApplicationBinaryInterface: return "unknown application binary interface";
6667 }
6768 return "(invalid error)";
6869}
src/main.cpp+7-6
......@@ -977,16 +977,19 @@ int main(int argc, char **argv) {
977977 }
978978 }
979979
980 Buf zig_triple_buf = BUF_INIT;
981 target_triple_zig(&zig_triple_buf, &target);
982
980983 if (cpu && features) {
981984 fprintf(stderr, "-target-cpu and -target-feature options not allowed together\n");
982985 return main_exit(root_progress_node, EXIT_FAILURE);
983986 } else if (cpu) {
984 if ((err = stage2_cpu_features_parse_cpu(&target.cpu_features, target_arch_name(target.arch), cpu))) {
987 if ((err = stage2_cpu_features_parse_cpu(&target.cpu_features, buf_ptr(&zig_triple_buf), cpu))) {
985988 fprintf(stderr, "-target-cpu error: %s\n", err_str(err));
986989 return main_exit(root_progress_node, EXIT_FAILURE);
987990 }
988991 } else if (features) {
989 if ((err = stage2_cpu_features_parse_features(&target.cpu_features, target_arch_name(target.arch),
992 if ((err = stage2_cpu_features_parse_features(&target.cpu_features, buf_ptr(&zig_triple_buf),
990993 features)))
991994 {
992995 fprintf(stderr, "-target-feature error: %s\n", err_str(err));
......@@ -995,7 +998,7 @@ int main(int argc, char **argv) {
995998 } else if (target.is_native) {
996999 const char *cpu_name = ZigLLVMGetHostCPUName();
9971000 const char *cpu_features = ZigLLVMGetNativeFeatures();
998 if ((err = stage2_cpu_features_llvm(&target.cpu_features, target_arch_name(target.arch),
1001 if ((err = stage2_cpu_features_llvm(&target.cpu_features, buf_ptr(&zig_triple_buf),
9991002 cpu_name, cpu_features)))
10001003 {
10011004 fprintf(stderr, "unable to determine native CPU features: %s\n", err_str(err));
......@@ -1014,9 +1017,7 @@ int main(int argc, char **argv) {
10141017 }
10151018
10161019 if (target_requires_pic(&target, have_libc) && want_pic == WantPICDisabled) {
1017 Buf triple_buf = BUF_INIT;
1018 target_triple_zig(&triple_buf, &target);
1019 fprintf(stderr, "`--disable-pic` is incompatible with target '%s'\n", buf_ptr(&triple_buf));
1020 fprintf(stderr, "`--disable-pic` is incompatible with target '%s'\n", buf_ptr(&zig_triple_buf));
10201021 return print_error_usage(arg0);
10211022 }
10221023
src/userland.cpp+3-3
......@@ -96,11 +96,11 @@ struct Stage2CpuFeatures {
9696 const char *cache_hash;
9797};
9898
99Error stage2_cpu_features_parse_cpu(Stage2CpuFeatures **out, const char *arch, const char *str) {
99Error stage2_cpu_features_parse_cpu(Stage2CpuFeatures **out, const char *zig_triple, const char *str) {
100100 const char *msg = "stage0 called stage2_cpu_features_parse_cpu";
101101 stage2_panic(msg, strlen(msg));
102102}
103Error stage2_cpu_features_parse_features(Stage2CpuFeatures **out, const char *arch, const char *str) {
103Error stage2_cpu_features_parse_features(Stage2CpuFeatures **out, const char *zig_triple, const char *str) {
104104 const char *msg = "stage0 called stage2_cpu_features_parse_features";
105105 stage2_panic(msg, strlen(msg));
106106}
......@@ -111,7 +111,7 @@ Error stage2_cpu_features_baseline(Stage2CpuFeatures **out) {
111111 *out = result;
112112 return ErrorNone;
113113}
114Error stage2_cpu_features_llvm(Stage2CpuFeatures **out, const char *arch,
114Error stage2_cpu_features_llvm(Stage2CpuFeatures **out, const char *zig_triple,
115115 const char *llvm_cpu_name, const char *llvm_features)
116116{
117117 Stage2CpuFeatures *result = allocate<Stage2CpuFeatures>(1, "Stage2CpuFeatures");
src/userland.h+4-3
......@@ -83,6 +83,7 @@ enum Error {
8383 ErrorUnknownCpuFeature,
8484 ErrorInvalidCpuFeatures,
8585 ErrorInvalidLlvmCpuFeaturesFormat,
86 ErrorUnknownApplicationBinaryInterface,
8687};
8788
8889// ABI warning
......@@ -184,18 +185,18 @@ struct Stage2CpuFeatures;
184185
185186// ABI warning
186187ZIG_EXTERN_C Error stage2_cpu_features_parse_cpu(struct Stage2CpuFeatures **result,
187 const char *arch, const char *cpu_name);
188 const char *zig_triple, const char *cpu_name);
188189
189190// ABI warning
190191ZIG_EXTERN_C Error stage2_cpu_features_parse_features(struct Stage2CpuFeatures **result,
191 const char *arch, const char *features);
192 const char *zig_triple, const char *features);
192193
193194// ABI warning
194195ZIG_EXTERN_C Error stage2_cpu_features_baseline(struct Stage2CpuFeatures **result);
195196
196197// ABI warning
197198ZIG_EXTERN_C Error stage2_cpu_features_llvm(struct Stage2CpuFeatures **result,
198 const char *arch, const char *llvm_cpu_name, const char *llvm_features);
199 const char *zig_triple, const char *llvm_cpu_name, const char *llvm_features);
199200
200201// ABI warning
201202ZIG_EXTERN_C const char *stage2_cpu_features_get_llvm_cpu(const struct Stage2CpuFeatures *cpu_features);