hit a comptime limitation with computing dense sets

lib/std/build.zig

@@ -1983,7 +1983,7 @@ pub const LibExeObjStep = struct {
 
                         var feature_str_buffer = try std.Buffer.initSize(builder.allocator, 0);
                         for (self.target.getArch().allFeaturesList()) |feature, i| {
-                            if (features.isEnabled(@intCast(u8, i))) {
+                            if (features.isEnabled(@intCast(Target.Cpu.Feature.Set.Index, i))) {
                                 try feature_str_buffer.append(feature.name);
                                 try feature_str_buffer.append(",");
                             }

lib/std/target.zig

@@ -172,6 +172,48 @@ pub const Target = union(enum) {
             r6,
         };
 
+        pub fn subArchFeature(arch: Arch) ?u8 {
+            return switch (arch) {
+                .arm, .armeb, .thumb, .thumbeb => |arm32| switch (arm32) {
+                    .v8_5a => @enumToInt(arm.Feature.armv8_5_a),
+                    .v8_4a => @enumToInt(arm.Feature.armv8_4_a),
+                    .v8_3a => @enumToInt(arm.Feature.armv8_3_a),
+                    .v8_2a => @enumToInt(arm.Feature.armv8_2_a),
+                    .v8_1a => @enumToInt(arm.Feature.armv8_1_a),
+                    .v8 => @enumToInt(arm.Feature.armv8_a),
+                    .v8r => @enumToInt(arm.Feature.armv8_r),
+                    .v8m_baseline => @enumToInt(arm.Feature.armv8_m_base),
+                    .v8m_mainline => @enumToInt(arm.Feature.armv8_m_main),
+                    .v8_1m_mainline => @enumToInt(arm.Feature.armv8_1_m_main),
+                    .v7 => @enumToInt(arm.Feature.armv7_a),
+                    .v7em => @enumToInt(arm.Feature.armv7e_m),
+                    .v7m => @enumToInt(arm.Feature.armv7_m),
+                    .v7s => @enumToInt(arm.Feature.armv7s),
+                    .v7k => @enumToInt(arm.Feature.armv7k),
+                    .v7ve => @enumToInt(arm.Feature.armv7ve),
+                    .v6 => @enumToInt(arm.Feature.armv6),
+                    .v6m => @enumToInt(arm.Feature.armv6_m),
+                    .v6k => @enumToInt(arm.Feature.armv6k),
+                    .v6t2 => @enumToInt(arm.Feature.armv6t2),
+                    .v5 => @enumToInt(arm.Feature.armv5t),
+                    .v5te => @enumToInt(arm.Feature.armv5te),
+                    .v4t => @enumToInt(arm.Feature.armv4t),
+                },
+                .aarch64, .aarch64_be, .aarch64_32 => |arm64| switch (arm64) {
+                    .v8_5a => @enumToInt(aarch64.Feature.v8_5a),
+                    .v8_4a => @enumToInt(aarch64.Feature.v8_4a),
+                    .v8_3a => @enumToInt(aarch64.Feature.v8_3a),
+                    .v8_2a => @enumToInt(aarch64.Feature.v8_2a),
+                    .v8_1a => @enumToInt(aarch64.Feature.v8_1a),
+                    .v8 => @enumToInt(aarch64.Feature.v8_1a),
+                    .v8r => @enumToInt(aarch64.Feature.v8_1a),
+                    .v8m_baseline => @enumToInt(aarch64.Feature.v8_1a),
+                    .v8m_mainline => @enumToInt(aarch64.Feature.v8_1a),
+                },
+                else => return null,
+            };
+        }
+
         pub fn isARM(arch: Arch) bool {
             return switch (arch) {
                 .arm, .armeb => true,
@@ -219,7 +261,7 @@ pub const Target = union(enum) {
         pub fn parseCpuFeatureSet(arch: Arch, features_text: []const u8) !Cpu.Feature.Set {
             // Here we compute both and choose the correct result at the end, based
             // on whether or not we saw + and - signs.
-            var whitelist_set = Cpu.Feature.Set.empty();
+            var whitelist_set = Cpu.Feature.Set.empty;
             var baseline_set = arch.baselineFeatures();
             var mode: enum {
                 unknown,
@@ -256,16 +298,18 @@ pub const Target = union(enum) {
                     op = .add;
                     feature_name = item_text;
                 }
-                for (arch.allFeaturesList()) |feature, index| {
+                const all_features = arch.allFeaturesList();
+                for (all_features) |feature, index_usize| {
+                    const index = @intCast(Cpu.Feature.Set.Index, index_usize);
                     if (mem.eql(u8, feature_name, feature.name)) {
                         switch (op) {
                             .add => {
-                                baseline_set.addFeature(@intCast(u8, index));
-                                whitelist_set.addFeature(@intCast(u8, index));
+                                baseline_set.addFeature(index, all_features);
+                                whitelist_set.addFeature(index, all_features);
                             },
                             .sub => {
-                                baseline_set.removeFeature(@intCast(u8, index));
-                                whitelist_set.removeFeature(@intCast(u8, index));
+                                baseline_set.removeFeature(index, all_features);
+                                whitelist_set.removeFeature(index, all_features);
                             },
                         }
                         break;
@@ -462,7 +506,7 @@ pub const Target = union(enum) {
                 .nvptx, .nvptx64 => nvptx.cpu.sm_20.features,
                 .wasm32, .wasm64 => wasm.cpu.generic.features,
 
-                else => Cpu.Feature.Set.empty(),
+                else => Cpu.Feature.Set.empty,
             };
         }
 
@@ -521,48 +565,130 @@ pub const Target = union(enum) {
         features: Feature.Set,
 
         pub const Feature = struct {
-            /// The bit index into `Set`.
-            index: u8,
-            name: []const u8,
+            /// The bit index into `Set`. Has a default value of `undefined` because the canonical
+            /// structures are populated via comptime logic.
+            index: Set.Index = undefined,
+
+            /// Has a default value of `undefined` because the canonical
+            /// structures are populated via comptime logic.
+            name: []const u8 = undefined,
+
+            /// If this corresponds to an LLVM-recognized feature, this will be populated;
+            /// otherwise null.
             llvm_name: ?[:0]const u8,
+
+            /// Human-friendly UTF-8 text.
             description: []const u8,
-            dependencies: Set,
+
+            /// `Set` of all features this depends on, and this feature itself.
+            /// Can be "or"ed with another set to remove this feature and all
+            /// its dependencies.
+            /// Has a default value of `undefined` because the canonical
+            /// structures are populated via comptime logic.
+            dependencies: Set = undefined,
 
             /// A bit set of all the features.
             pub const Set = struct {
-                bytes: [bit_count / 8]u8,
+                ints: [usize_count]usize,
 
-                pub const bit_count = 22 * 8;
+                pub const needed_bit_count = 174;
+                pub const byte_count = (needed_bit_count + 7) / 8;
+                pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize);
+                pub const Index = std.math.Log2Int(@IntType(false, usize_count * @bitSizeOf(usize)));
+                pub const ShiftInt = std.math.Log2Int(usize);
 
-                pub fn empty() Set {
-                    return .{ .bytes = [1]u8{0} ** 22 };
+                pub const empty = Set{ .ints = [1]usize{0} ** usize_count };
+
+                pub fn isEnabled(set: Set, arch_feature_index: Index) bool {
+                    const usize_index = arch_feature_index / @bitSizeOf(usize);
+                    const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
+                    return (set.ints[usize_index] & (@as(usize, 1) << bit_index)) != 0;
                 }
 
-                pub fn isEnabled(set: Set, arch_feature_index: u8) bool {
-                    const byte_index = arch_feature_index / 8;
-                    const bit_index = @intCast(u3, arch_feature_index % 8);
-                    return (set.bytes[byte_index] & (@as(u8, 1) << bit_index)) != 0;
+                /// Adds the specified feature and all its dependencies to the set. O(1).
+                pub fn addFeature(
+                    set: *Set,
+                    arch_feature_index: Index,
+                    all_features_list: []const Cpu.Feature,
+                ) void {
+                    set.ints = @as(@Vector(usize_count, usize), set.ints) |
+                        @as(@Vector(usize_count, usize), all_features_list[arch_feature_index].dependencies.ints);
                 }
 
-                pub fn addFeature(set: *Set, arch_feature_index: u8) void {
-                    const byte_index = arch_feature_index / 8;
-                    const bit_index = @intCast(u3, arch_feature_index % 8);
-                    set.bytes[byte_index] |= @as(u8, 1) << bit_index;
+                /// Removes the specified feature (TODO and all its dependents) from the set. O(1).
+                /// TODO improve this function to actually handle dependants rather than just calling
+                /// `removeSparseFeature`.
+                pub fn removeFeature(
+                    set: *Set,
+                    arch_feature_index: Index,
+                    all_features_list: []const Cpu.Feature,
+                ) void {
+                    set.removeSparseFeature(arch_feature_index);
                 }
 
-                pub fn removeFeature(set: *Set, arch_feature_index: u8) void {
-                    const byte_index = arch_feature_index / 8;
-                    const bit_index = @intCast(u3, arch_feature_index % 8);
-                    set.bytes[byte_index] &= ~(@as(u8, 1) << bit_index);
+                /// Adds the specified feature but not its dependencies.
+                pub fn addSparseFeature(set: *Set, arch_feature_index: Index) void {
+                    const usize_index = arch_feature_index / @bitSizeOf(usize);
+                    const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
+                    set.ints[usize_index] |= @as(usize, 1) << bit_index;
+                }
+
+                /// Removes the specified feature but not its dependents.
+                pub fn removeSparseFeature(set: *Set, arch_feature_index: Index) void {
+                    const usize_index = arch_feature_index / @bitSizeOf(usize);
+                    const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
+                    set.ints[usize_index] &= ~(@as(usize, 1) << bit_index);
+                }
+
+                pub fn initAsDependencies(
+                    set: *Set,
+                    arch_feature_index: Index,
+                    all_features_list: []const Cpu.Feature,
+                ) void {
+                    // fast-case to help reduce how much comptime code must execute
+                    const no_deps = for (set.ints) |elem| {
+                        if (elem != 0) break false;
+                    } else true;
+                    // add itself to its own dependencies for easy "or"ing later
+                    set.addSparseFeature(arch_feature_index);
+                    if (no_deps) return;
+
+                    var old = set.ints;
+                    while (true) {
+                        for (all_features_list) |feature, index| {
+                            const casted_index = @intCast(Index, index);
+                            if (set.isEnabled(casted_index)) {
+                                set.addFeature(casted_index, all_features_list);
+                            }
+                        }
+                        const nothing_changed = mem.eql(usize, &old, &set.ints);
+                        if (nothing_changed) return;
+                        old = set.ints;
+                    }
+                }
+
+                pub fn asBytes(set: *const Set) *const [byte_count]u8 {
+                    return @ptrCast(*const [byte_count]u8, &set.ints);
                 }
             };
 
             pub fn feature_set_fns(comptime F: type) type {
                 return struct {
-                    pub fn featureSet(features: []const F) Set {
-                        var x = Set.empty();
+                    /// Populates a set with the list of features and all their dependencies included.
+                    pub fn featureSet(all_features_list: []const Feature, features: []const F) Set {
+                        var x: Set = Set.empty;
                         for (features) |feature| {
-                            x.addFeature(@enumToInt(feature));
+                            x.addFeature(@enumToInt(feature), all_features_list);
+                        }
+                        @compileLog(Set.empty);
+                        return x;
+                    }
+
+                    /// Populates only the feature bits specified.
+                    pub fn sparseFeatureSet(features: []const F) Set {
+                        var x = Set.empty;
+                        for (features) |feature| {
+                            x.addSparseFeature(@enumToInt(feature));
                         }
                         return x;
                     }

lib/std/target/bpf.zig

@@ -11,29 +11,29 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.alu32)] = .{
-        .index = @enumToInt(Feature.alu32),
-        .name = @tagName(Feature.alu32),
         .llvm_name = "alu32",
         .description = "Enable ALU32 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dummy)] = .{
-        .index = @enumToInt(Feature.dummy),
-        .name = @tagName(Feature.dummy),
         .llvm_name = "dummy",
         .description = "unused feature",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dwarfris)] = .{
-        .index = @enumToInt(Feature.dwarfris),
-        .name = @tagName(Feature.dwarfris),
         .llvm_name = "dwarfris",
         .description = "Disable MCAsmInfo DwarfUsesRelocationsAcrossSections",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -41,27 +41,27 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const probe = Cpu{
         .name = "probe",
         .llvm_name = "probe",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const v1 = Cpu{
         .name = "v1",
         .llvm_name = "v1",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const v2 = Cpu{
         .name = "v2",
         .llvm_name = "v2",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const v3 = Cpu{
         .name = "v3",
         .llvm_name = "v3",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
 };
 

lib/std/target/hexagon.zig

@@ -32,76 +32,60 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.duplex)] = .{
-        .index = @enumToInt(Feature.duplex),
-        .name = @tagName(Feature.duplex),
         .llvm_name = "duplex",
         .description = "Enable generation of duplex instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hvx)] = .{
-        .index = @enumToInt(Feature.hvx),
-        .name = @tagName(Feature.hvx),
         .llvm_name = "hvx",
         .description = "Hexagon HVX instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hvx_length128b)] = .{
-        .index = @enumToInt(Feature.hvx_length128b),
-        .name = @tagName(Feature.hvx_length128b),
         .llvm_name = "hvx-length128b",
         .description = "Hexagon HVX 128B instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hvx,
         }),
     };
     result[@enumToInt(Feature.hvx_length64b)] = .{
-        .index = @enumToInt(Feature.hvx_length64b),
-        .name = @tagName(Feature.hvx_length64b),
         .llvm_name = "hvx-length64b",
         .description = "Hexagon HVX 64B instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hvx,
         }),
     };
     result[@enumToInt(Feature.hvxv60)] = .{
-        .index = @enumToInt(Feature.hvxv60),
-        .name = @tagName(Feature.hvxv60),
         .llvm_name = "hvxv60",
         .description = "Hexagon HVX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hvx,
         }),
     };
     result[@enumToInt(Feature.hvxv62)] = .{
-        .index = @enumToInt(Feature.hvxv62),
-        .name = @tagName(Feature.hvxv62),
         .llvm_name = "hvxv62",
         .description = "Hexagon HVX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hvx,
             .hvxv60,
         }),
     };
     result[@enumToInt(Feature.hvxv65)] = .{
-        .index = @enumToInt(Feature.hvxv65),
-        .name = @tagName(Feature.hvxv65),
         .llvm_name = "hvxv65",
         .description = "Hexagon HVX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hvx,
             .hvxv60,
             .hvxv62,
         }),
     };
     result[@enumToInt(Feature.hvxv66)] = .{
-        .index = @enumToInt(Feature.hvxv66),
-        .name = @tagName(Feature.hvxv66),
         .llvm_name = "hvxv66",
         .description = "Hexagon HVX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hvx,
             .hvxv60,
             .hvxv62,
@@ -110,121 +94,95 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.long_calls)] = .{
-        .index = @enumToInt(Feature.long_calls),
-        .name = @tagName(Feature.long_calls),
         .llvm_name = "long-calls",
         .description = "Use constant-extended calls",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mem_noshuf)] = .{
-        .index = @enumToInt(Feature.mem_noshuf),
-        .name = @tagName(Feature.mem_noshuf),
         .llvm_name = "mem_noshuf",
         .description = "Supports mem_noshuf feature",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.memops)] = .{
-        .index = @enumToInt(Feature.memops),
-        .name = @tagName(Feature.memops),
         .llvm_name = "memops",
         .description = "Use memop instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.noreturn_stack_elim)] = .{
-        .index = @enumToInt(Feature.noreturn_stack_elim),
-        .name = @tagName(Feature.noreturn_stack_elim),
         .llvm_name = "noreturn-stack-elim",
         .description = "Eliminate stack allocation in a noreturn function when possible",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nvj)] = .{
-        .index = @enumToInt(Feature.nvj),
-        .name = @tagName(Feature.nvj),
         .llvm_name = "nvj",
         .description = "Support for new-value jumps",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .packets,
         }),
     };
     result[@enumToInt(Feature.nvs)] = .{
-        .index = @enumToInt(Feature.nvs),
-        .name = @tagName(Feature.nvs),
         .llvm_name = "nvs",
         .description = "Support for new-value stores",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .packets,
         }),
     };
     result[@enumToInt(Feature.packets)] = .{
-        .index = @enumToInt(Feature.packets),
-        .name = @tagName(Feature.packets),
         .llvm_name = "packets",
         .description = "Support for instruction packets",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserved_r19)] = .{
-        .index = @enumToInt(Feature.reserved_r19),
-        .name = @tagName(Feature.reserved_r19),
         .llvm_name = "reserved-r19",
         .description = "Reserve register R19",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.small_data)] = .{
-        .index = @enumToInt(Feature.small_data),
-        .name = @tagName(Feature.small_data),
         .llvm_name = "small-data",
         .description = "Allow GP-relative addressing of global variables",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v5)] = .{
-        .index = @enumToInt(Feature.v5),
-        .name = @tagName(Feature.v5),
         .llvm_name = "v5",
         .description = "Enable Hexagon V5 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v55)] = .{
-        .index = @enumToInt(Feature.v55),
-        .name = @tagName(Feature.v55),
         .llvm_name = "v55",
         .description = "Enable Hexagon V55 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v60)] = .{
-        .index = @enumToInt(Feature.v60),
-        .name = @tagName(Feature.v60),
         .llvm_name = "v60",
         .description = "Enable Hexagon V60 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v62)] = .{
-        .index = @enumToInt(Feature.v62),
-        .name = @tagName(Feature.v62),
         .llvm_name = "v62",
         .description = "Enable Hexagon V62 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v65)] = .{
-        .index = @enumToInt(Feature.v65),
-        .name = @tagName(Feature.v65),
         .llvm_name = "v65",
         .description = "Enable Hexagon V65 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v66)] = .{
-        .index = @enumToInt(Feature.v66),
-        .name = @tagName(Feature.v66),
         .llvm_name = "v66",
         .description = "Enable Hexagon V66 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.zreg)] = .{
-        .index = @enumToInt(Feature.zreg),
-        .name = @tagName(Feature.zreg),
         .llvm_name = "zreg",
         .description = "Hexagon ZReg extension instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -232,7 +190,7 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .memops,
             .nvj,
@@ -247,7 +205,7 @@ pub const cpu = struct {
     pub const hexagonv5 = Cpu{
         .name = "hexagonv5",
         .llvm_name = "hexagonv5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .memops,
             .nvj,
@@ -260,7 +218,7 @@ pub const cpu = struct {
     pub const hexagonv55 = Cpu{
         .name = "hexagonv55",
         .llvm_name = "hexagonv55",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .memops,
             .nvj,
@@ -274,7 +232,7 @@ pub const cpu = struct {
     pub const hexagonv60 = Cpu{
         .name = "hexagonv60",
         .llvm_name = "hexagonv60",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .memops,
             .nvj,
@@ -289,7 +247,7 @@ pub const cpu = struct {
     pub const hexagonv62 = Cpu{
         .name = "hexagonv62",
         .llvm_name = "hexagonv62",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .memops,
             .nvj,
@@ -305,7 +263,7 @@ pub const cpu = struct {
     pub const hexagonv65 = Cpu{
         .name = "hexagonv65",
         .llvm_name = "hexagonv65",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .mem_noshuf,
             .memops,
@@ -323,7 +281,7 @@ pub const cpu = struct {
     pub const hexagonv66 = Cpu{
         .name = "hexagonv66",
         .llvm_name = "hexagonv66",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .duplex,
             .mem_noshuf,
             .memops,

lib/std/target/mips.zig

@@ -57,135 +57,101 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.abs2008)] = .{
-        .index = @enumToInt(Feature.abs2008),
-        .name = @tagName(Feature.abs2008),
         .llvm_name = "abs2008",
         .description = "Disable IEEE 754-2008 abs.fmt mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cnmips)] = .{
-        .index = @enumToInt(Feature.cnmips),
-        .name = @tagName(Feature.cnmips),
         .llvm_name = "cnmips",
         .description = "Octeon cnMIPS Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips64r2,
         }),
     };
     result[@enumToInt(Feature.crc)] = .{
-        .index = @enumToInt(Feature.crc),
-        .name = @tagName(Feature.crc),
         .llvm_name = "crc",
         .description = "Mips R6 CRC ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dsp)] = .{
-        .index = @enumToInt(Feature.dsp),
-        .name = @tagName(Feature.dsp),
         .llvm_name = "dsp",
         .description = "Mips DSP ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dspr2)] = .{
-        .index = @enumToInt(Feature.dspr2),
-        .name = @tagName(Feature.dspr2),
         .llvm_name = "dspr2",
         .description = "Mips DSP-R2 ASE",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dsp,
         }),
     };
     result[@enumToInt(Feature.dspr3)] = .{
-        .index = @enumToInt(Feature.dspr3),
-        .name = @tagName(Feature.dspr3),
         .llvm_name = "dspr3",
         .description = "Mips DSP-R3 ASE",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dsp,
             .dspr2,
         }),
     };
     result[@enumToInt(Feature.eva)] = .{
-        .index = @enumToInt(Feature.eva),
-        .name = @tagName(Feature.eva),
         .llvm_name = "eva",
         .description = "Mips EVA ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp64)] = .{
-        .index = @enumToInt(Feature.fp64),
-        .name = @tagName(Feature.fp64),
         .llvm_name = "fp64",
         .description = "Support 64-bit FP registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fpxx)] = .{
-        .index = @enumToInt(Feature.fpxx),
-        .name = @tagName(Feature.fpxx),
         .llvm_name = "fpxx",
         .description = "Support for FPXX",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ginv)] = .{
-        .index = @enumToInt(Feature.ginv),
-        .name = @tagName(Feature.ginv),
         .llvm_name = "ginv",
         .description = "Mips Global Invalidate ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.gp64)] = .{
-        .index = @enumToInt(Feature.gp64),
-        .name = @tagName(Feature.gp64),
         .llvm_name = "gp64",
         .description = "General Purpose Registers are 64-bit wide",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.long_calls)] = .{
-        .index = @enumToInt(Feature.long_calls),
-        .name = @tagName(Feature.long_calls),
         .llvm_name = "long-calls",
         .description = "Disable use of the jal instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.micromips)] = .{
-        .index = @enumToInt(Feature.micromips),
-        .name = @tagName(Feature.micromips),
         .llvm_name = "micromips",
         .description = "microMips mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips1)] = .{
-        .index = @enumToInt(Feature.mips1),
-        .name = @tagName(Feature.mips1),
         .llvm_name = "mips1",
         .description = "Mips I ISA Support [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips16)] = .{
-        .index = @enumToInt(Feature.mips16),
-        .name = @tagName(Feature.mips16),
         .llvm_name = "mips16",
         .description = "Mips16 mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips2)] = .{
-        .index = @enumToInt(Feature.mips2),
-        .name = @tagName(Feature.mips2),
         .llvm_name = "mips2",
         .description = "Mips II ISA Support [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips1,
         }),
     };
     result[@enumToInt(Feature.mips3)] = .{
-        .index = @enumToInt(Feature.mips3),
-        .name = @tagName(Feature.mips3),
         .llvm_name = "mips3",
         .description = "MIPS III ISA Support [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64,
             .gp64,
             .mips2,
@@ -194,22 +160,18 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.mips32)] = .{
-        .index = @enumToInt(Feature.mips32),
-        .name = @tagName(Feature.mips32),
         .llvm_name = "mips32",
         .description = "Mips32 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips2,
             .mips3_32,
             .mips4_32,
         }),
     };
     result[@enumToInt(Feature.mips32r2)] = .{
-        .index = @enumToInt(Feature.mips32r2),
-        .name = @tagName(Feature.mips32r2),
         .llvm_name = "mips32r2",
         .description = "Mips32r2 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32,
             .mips3_32r2,
             .mips4_32r2,
@@ -217,29 +179,23 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.mips32r3)] = .{
-        .index = @enumToInt(Feature.mips32r3),
-        .name = @tagName(Feature.mips32r3),
         .llvm_name = "mips32r3",
         .description = "Mips32r3 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32r2,
         }),
     };
     result[@enumToInt(Feature.mips32r5)] = .{
-        .index = @enumToInt(Feature.mips32r5),
-        .name = @tagName(Feature.mips32r5),
         .llvm_name = "mips32r5",
         .description = "Mips32r5 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32r3,
         }),
     };
     result[@enumToInt(Feature.mips32r6)] = .{
-        .index = @enumToInt(Feature.mips32r6),
-        .name = @tagName(Feature.mips32r6),
         .llvm_name = "mips32r6",
         .description = "Mips32r6 ISA Support [experimental]",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .abs2008,
             .fp64,
             .mips32r5,
@@ -247,107 +203,83 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.mips3_32)] = .{
-        .index = @enumToInt(Feature.mips3_32),
-        .name = @tagName(Feature.mips3_32),
         .llvm_name = "mips3_32",
         .description = "Subset of MIPS-III that is also in MIPS32 [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips3_32r2)] = .{
-        .index = @enumToInt(Feature.mips3_32r2),
-        .name = @tagName(Feature.mips3_32r2),
         .llvm_name = "mips3_32r2",
         .description = "Subset of MIPS-III that is also in MIPS32r2 [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips4)] = .{
-        .index = @enumToInt(Feature.mips4),
-        .name = @tagName(Feature.mips4),
         .llvm_name = "mips4",
         .description = "MIPS IV ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips3,
             .mips4_32,
             .mips4_32r2,
         }),
     };
     result[@enumToInt(Feature.mips4_32)] = .{
-        .index = @enumToInt(Feature.mips4_32),
-        .name = @tagName(Feature.mips4_32),
         .llvm_name = "mips4_32",
         .description = "Subset of MIPS-IV that is also in MIPS32 [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips4_32r2)] = .{
-        .index = @enumToInt(Feature.mips4_32r2),
-        .name = @tagName(Feature.mips4_32r2),
         .llvm_name = "mips4_32r2",
         .description = "Subset of MIPS-IV that is also in MIPS32r2 [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips5)] = .{
-        .index = @enumToInt(Feature.mips5),
-        .name = @tagName(Feature.mips5),
         .llvm_name = "mips5",
         .description = "MIPS V ISA Support [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips4,
             .mips5_32r2,
         }),
     };
     result[@enumToInt(Feature.mips5_32r2)] = .{
-        .index = @enumToInt(Feature.mips5_32r2),
-        .name = @tagName(Feature.mips5_32r2),
         .llvm_name = "mips5_32r2",
         .description = "Subset of MIPS-V that is also in MIPS32r2 [highly experimental]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mips64)] = .{
-        .index = @enumToInt(Feature.mips64),
-        .name = @tagName(Feature.mips64),
         .llvm_name = "mips64",
         .description = "Mips64 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32,
             .mips5,
         }),
     };
     result[@enumToInt(Feature.mips64r2)] = .{
-        .index = @enumToInt(Feature.mips64r2),
-        .name = @tagName(Feature.mips64r2),
         .llvm_name = "mips64r2",
         .description = "Mips64r2 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32r2,
             .mips64,
         }),
     };
     result[@enumToInt(Feature.mips64r3)] = .{
-        .index = @enumToInt(Feature.mips64r3),
-        .name = @tagName(Feature.mips64r3),
         .llvm_name = "mips64r3",
         .description = "Mips64r3 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32r3,
             .mips64r2,
         }),
     };
     result[@enumToInt(Feature.mips64r5)] = .{
-        .index = @enumToInt(Feature.mips64r5),
-        .name = @tagName(Feature.mips64r5),
         .llvm_name = "mips64r5",
         .description = "Mips64r5 ISA Support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32r5,
             .mips64r3,
         }),
     };
     result[@enumToInt(Feature.mips64r6)] = .{
-        .index = @enumToInt(Feature.mips64r6),
-        .name = @tagName(Feature.mips64r6),
         .llvm_name = "mips64r6",
         .description = "Mips64r6 ISA Support [experimental]",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .abs2008,
             .mips32r6,
             .mips64r5,
@@ -355,112 +287,88 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.msa)] = .{
-        .index = @enumToInt(Feature.msa),
-        .name = @tagName(Feature.msa),
         .llvm_name = "msa",
         .description = "Mips MSA ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mt)] = .{
-        .index = @enumToInt(Feature.mt),
-        .name = @tagName(Feature.mt),
         .llvm_name = "mt",
         .description = "Mips MT ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nan2008)] = .{
-        .index = @enumToInt(Feature.nan2008),
-        .name = @tagName(Feature.nan2008),
         .llvm_name = "nan2008",
         .description = "IEEE 754-2008 NaN encoding",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.noabicalls)] = .{
-        .index = @enumToInt(Feature.noabicalls),
-        .name = @tagName(Feature.noabicalls),
         .llvm_name = "noabicalls",
         .description = "Disable SVR4-style position-independent code",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nomadd4)] = .{
-        .index = @enumToInt(Feature.nomadd4),
-        .name = @tagName(Feature.nomadd4),
         .llvm_name = "nomadd4",
         .description = "Disable 4-operand madd.fmt and related instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nooddspreg)] = .{
-        .index = @enumToInt(Feature.nooddspreg),
-        .name = @tagName(Feature.nooddspreg),
         .llvm_name = "nooddspreg",
         .description = "Disable odd numbered single-precision registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.p5600)] = .{
-        .index = @enumToInt(Feature.p5600),
-        .name = @tagName(Feature.p5600),
         .llvm_name = "p5600",
         .description = "The P5600 Processor",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mips32r5,
         }),
     };
     result[@enumToInt(Feature.ptr64)] = .{
-        .index = @enumToInt(Feature.ptr64),
-        .name = @tagName(Feature.ptr64),
         .llvm_name = "ptr64",
         .description = "Pointers are 64-bit wide",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.single_float)] = .{
-        .index = @enumToInt(Feature.single_float),
-        .name = @tagName(Feature.single_float),
         .llvm_name = "single-float",
         .description = "Only supports single precision float",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.soft_float)] = .{
-        .index = @enumToInt(Feature.soft_float),
-        .name = @tagName(Feature.soft_float),
         .llvm_name = "soft-float",
         .description = "Does not support floating point instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sym32)] = .{
-        .index = @enumToInt(Feature.sym32),
-        .name = @tagName(Feature.sym32),
         .llvm_name = "sym32",
         .description = "Symbols are 32 bit on Mips64",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_indirect_jump_hazard)] = .{
-        .index = @enumToInt(Feature.use_indirect_jump_hazard),
-        .name = @tagName(Feature.use_indirect_jump_hazard),
         .llvm_name = "use-indirect-jump-hazard",
         .description = "Use indirect jump guards to prevent certain speculation based attacks",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_tcc_in_div)] = .{
-        .index = @enumToInt(Feature.use_tcc_in_div),
-        .name = @tagName(Feature.use_tcc_in_div),
         .llvm_name = "use-tcc-in-div",
         .description = "Force the assembler to use trapping",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vfpu)] = .{
-        .index = @enumToInt(Feature.vfpu),
-        .name = @tagName(Feature.vfpu),
         .llvm_name = "vfpu",
         .description = "Enable vector FPU instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.virt)] = .{
-        .index = @enumToInt(Feature.virt),
-        .name = @tagName(Feature.virt),
         .llvm_name = "virt",
         .description = "Mips Virtualization ASE",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -468,112 +376,112 @@ pub const cpu = struct {
     pub const mips1 = Cpu{
         .name = "mips1",
         .llvm_name = "mips1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips1,
         }),
     };
     pub const mips2 = Cpu{
         .name = "mips2",
         .llvm_name = "mips2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips2,
         }),
     };
     pub const mips3 = Cpu{
         .name = "mips3",
         .llvm_name = "mips3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips3,
         }),
     };
     pub const mips32 = Cpu{
         .name = "mips32",
         .llvm_name = "mips32",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips32,
         }),
     };
     pub const mips32r2 = Cpu{
         .name = "mips32r2",
         .llvm_name = "mips32r2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips32r2,
         }),
     };
     pub const mips32r3 = Cpu{
         .name = "mips32r3",
         .llvm_name = "mips32r3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips32r3,
         }),
     };
     pub const mips32r5 = Cpu{
         .name = "mips32r5",
         .llvm_name = "mips32r5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips32r5,
         }),
     };
     pub const mips32r6 = Cpu{
         .name = "mips32r6",
         .llvm_name = "mips32r6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips32r6,
         }),
     };
     pub const mips4 = Cpu{
         .name = "mips4",
         .llvm_name = "mips4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips4,
         }),
     };
     pub const mips5 = Cpu{
         .name = "mips5",
         .llvm_name = "mips5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips5,
         }),
     };
     pub const mips64 = Cpu{
         .name = "mips64",
         .llvm_name = "mips64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips64,
         }),
     };
     pub const mips64r2 = Cpu{
         .name = "mips64r2",
         .llvm_name = "mips64r2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips64r2,
         }),
     };
     pub const mips64r3 = Cpu{
         .name = "mips64r3",
         .llvm_name = "mips64r3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips64r3,
         }),
     };
     pub const mips64r5 = Cpu{
         .name = "mips64r5",
         .llvm_name = "mips64r5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips64r5,
         }),
     };
     pub const mips64r6 = Cpu{
         .name = "mips64r6",
         .llvm_name = "mips64r6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mips64r6,
         }),
     };
     pub const octeon = Cpu{
         .name = "octeon",
         .llvm_name = "octeon",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cnmips,
             .mips64r2,
         }),
@@ -581,7 +489,7 @@ pub const cpu = struct {
     pub const p5600 = Cpu{
         .name = "p5600",
         .llvm_name = "p5600",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .p5600,
         }),
     };

lib/std/target/msp430.zig

@@ -12,36 +12,34 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.ext)] = .{
-        .index = @enumToInt(Feature.ext),
-        .name = @tagName(Feature.ext),
         .llvm_name = "ext",
         .description = "Enable MSP430-X extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hwmult16)] = .{
-        .index = @enumToInt(Feature.hwmult16),
-        .name = @tagName(Feature.hwmult16),
         .llvm_name = "hwmult16",
         .description = "Enable 16-bit hardware multiplier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hwmult32)] = .{
-        .index = @enumToInt(Feature.hwmult32),
-        .name = @tagName(Feature.hwmult32),
         .llvm_name = "hwmult32",
         .description = "Enable 32-bit hardware multiplier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hwmultf5)] = .{
-        .index = @enumToInt(Feature.hwmultf5),
-        .name = @tagName(Feature.hwmultf5),
         .llvm_name = "hwmultf5",
         .description = "Enable F5 series hardware multiplier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -49,17 +47,17 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const msp430 = Cpu{
         .name = "msp430",
         .llvm_name = "msp430",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const msp430x = Cpu{
         .name = "msp430x",
         .llvm_name = "msp430x",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ext,
         }),
     };

lib/std/target/nvptx.zig

@@ -33,183 +33,139 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.ptx32)] = .{
-        .index = @enumToInt(Feature.ptx32),
-        .name = @tagName(Feature.ptx32),
         .llvm_name = "ptx32",
         .description = "Use PTX version 3.2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx40)] = .{
-        .index = @enumToInt(Feature.ptx40),
-        .name = @tagName(Feature.ptx40),
         .llvm_name = "ptx40",
         .description = "Use PTX version 4.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx41)] = .{
-        .index = @enumToInt(Feature.ptx41),
-        .name = @tagName(Feature.ptx41),
         .llvm_name = "ptx41",
         .description = "Use PTX version 4.1",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx42)] = .{
-        .index = @enumToInt(Feature.ptx42),
-        .name = @tagName(Feature.ptx42),
         .llvm_name = "ptx42",
         .description = "Use PTX version 4.2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx43)] = .{
-        .index = @enumToInt(Feature.ptx43),
-        .name = @tagName(Feature.ptx43),
         .llvm_name = "ptx43",
         .description = "Use PTX version 4.3",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx50)] = .{
-        .index = @enumToInt(Feature.ptx50),
-        .name = @tagName(Feature.ptx50),
         .llvm_name = "ptx50",
         .description = "Use PTX version 5.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx60)] = .{
-        .index = @enumToInt(Feature.ptx60),
-        .name = @tagName(Feature.ptx60),
         .llvm_name = "ptx60",
         .description = "Use PTX version 6.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx61)] = .{
-        .index = @enumToInt(Feature.ptx61),
-        .name = @tagName(Feature.ptx61),
         .llvm_name = "ptx61",
         .description = "Use PTX version 6.1",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx63)] = .{
-        .index = @enumToInt(Feature.ptx63),
-        .name = @tagName(Feature.ptx63),
         .llvm_name = "ptx63",
         .description = "Use PTX version 6.3",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptx64)] = .{
-        .index = @enumToInt(Feature.ptx64),
-        .name = @tagName(Feature.ptx64),
         .llvm_name = "ptx64",
         .description = "Use PTX version 6.4",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_20)] = .{
-        .index = @enumToInt(Feature.sm_20),
-        .name = @tagName(Feature.sm_20),
         .llvm_name = "sm_20",
         .description = "Target SM 2.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_21)] = .{
-        .index = @enumToInt(Feature.sm_21),
-        .name = @tagName(Feature.sm_21),
         .llvm_name = "sm_21",
         .description = "Target SM 2.1",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_30)] = .{
-        .index = @enumToInt(Feature.sm_30),
-        .name = @tagName(Feature.sm_30),
         .llvm_name = "sm_30",
         .description = "Target SM 3.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_32)] = .{
-        .index = @enumToInt(Feature.sm_32),
-        .name = @tagName(Feature.sm_32),
         .llvm_name = "sm_32",
         .description = "Target SM 3.2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_35)] = .{
-        .index = @enumToInt(Feature.sm_35),
-        .name = @tagName(Feature.sm_35),
         .llvm_name = "sm_35",
         .description = "Target SM 3.5",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_37)] = .{
-        .index = @enumToInt(Feature.sm_37),
-        .name = @tagName(Feature.sm_37),
         .llvm_name = "sm_37",
         .description = "Target SM 3.7",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_50)] = .{
-        .index = @enumToInt(Feature.sm_50),
-        .name = @tagName(Feature.sm_50),
         .llvm_name = "sm_50",
         .description = "Target SM 5.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_52)] = .{
-        .index = @enumToInt(Feature.sm_52),
-        .name = @tagName(Feature.sm_52),
         .llvm_name = "sm_52",
         .description = "Target SM 5.2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_53)] = .{
-        .index = @enumToInt(Feature.sm_53),
-        .name = @tagName(Feature.sm_53),
         .llvm_name = "sm_53",
         .description = "Target SM 5.3",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_60)] = .{
-        .index = @enumToInt(Feature.sm_60),
-        .name = @tagName(Feature.sm_60),
         .llvm_name = "sm_60",
         .description = "Target SM 6.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_61)] = .{
-        .index = @enumToInt(Feature.sm_61),
-        .name = @tagName(Feature.sm_61),
         .llvm_name = "sm_61",
         .description = "Target SM 6.1",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_62)] = .{
-        .index = @enumToInt(Feature.sm_62),
-        .name = @tagName(Feature.sm_62),
         .llvm_name = "sm_62",
         .description = "Target SM 6.2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_70)] = .{
-        .index = @enumToInt(Feature.sm_70),
-        .name = @tagName(Feature.sm_70),
         .llvm_name = "sm_70",
         .description = "Target SM 7.0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_72)] = .{
-        .index = @enumToInt(Feature.sm_72),
-        .name = @tagName(Feature.sm_72),
         .llvm_name = "sm_72",
         .description = "Target SM 7.2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm_75)] = .{
-        .index = @enumToInt(Feature.sm_75),
-        .name = @tagName(Feature.sm_75),
         .llvm_name = "sm_75",
         .description = "Target SM 7.5",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -217,28 +173,28 @@ pub const cpu = struct {
     pub const sm_20 = Cpu{
         .name = "sm_20",
         .llvm_name = "sm_20",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .sm_20,
         }),
     };
     pub const sm_21 = Cpu{
         .name = "sm_21",
         .llvm_name = "sm_21",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .sm_21,
         }),
     };
     pub const sm_30 = Cpu{
         .name = "sm_30",
         .llvm_name = "sm_30",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .sm_30,
         }),
     };
     pub const sm_32 = Cpu{
         .name = "sm_32",
         .llvm_name = "sm_32",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx40,
             .sm_32,
         }),
@@ -246,14 +202,14 @@ pub const cpu = struct {
     pub const sm_35 = Cpu{
         .name = "sm_35",
         .llvm_name = "sm_35",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .sm_35,
         }),
     };
     pub const sm_37 = Cpu{
         .name = "sm_37",
         .llvm_name = "sm_37",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx41,
             .sm_37,
         }),
@@ -261,7 +217,7 @@ pub const cpu = struct {
     pub const sm_50 = Cpu{
         .name = "sm_50",
         .llvm_name = "sm_50",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx40,
             .sm_50,
         }),
@@ -269,7 +225,7 @@ pub const cpu = struct {
     pub const sm_52 = Cpu{
         .name = "sm_52",
         .llvm_name = "sm_52",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx41,
             .sm_52,
         }),
@@ -277,7 +233,7 @@ pub const cpu = struct {
     pub const sm_53 = Cpu{
         .name = "sm_53",
         .llvm_name = "sm_53",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx42,
             .sm_53,
         }),
@@ -285,7 +241,7 @@ pub const cpu = struct {
     pub const sm_60 = Cpu{
         .name = "sm_60",
         .llvm_name = "sm_60",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx50,
             .sm_60,
         }),
@@ -293,7 +249,7 @@ pub const cpu = struct {
     pub const sm_61 = Cpu{
         .name = "sm_61",
         .llvm_name = "sm_61",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx50,
             .sm_61,
         }),
@@ -301,7 +257,7 @@ pub const cpu = struct {
     pub const sm_62 = Cpu{
         .name = "sm_62",
         .llvm_name = "sm_62",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx50,
             .sm_62,
         }),
@@ -309,7 +265,7 @@ pub const cpu = struct {
     pub const sm_70 = Cpu{
         .name = "sm_70",
         .llvm_name = "sm_70",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx60,
             .sm_70,
         }),
@@ -317,7 +273,7 @@ pub const cpu = struct {
     pub const sm_72 = Cpu{
         .name = "sm_72",
         .llvm_name = "sm_72",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx61,
             .sm_72,
         }),
@@ -325,7 +281,7 @@ pub const cpu = struct {
     pub const sm_75 = Cpu{
         .name = "sm_75",
         .llvm_name = "sm_75",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .ptx63,
             .sm_75,
         }),

lib/std/target/powerpc.zig

@@ -59,417 +59,321 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.@"64bit")] = .{
-        .index = @enumToInt(Feature.@"64bit"),
-        .name = @tagName(Feature.@"64bit"),
         .llvm_name = "64bit",
         .description = "Enable 64-bit instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.@"64bitregs")] = .{
-        .index = @enumToInt(Feature.@"64bitregs"),
-        .name = @tagName(Feature.@"64bitregs"),
         .llvm_name = "64bitregs",
         .description = "Enable 64-bit registers usage for ppc32 [beta]",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.altivec)] = .{
-        .index = @enumToInt(Feature.altivec),
-        .name = @tagName(Feature.altivec),
         .llvm_name = "altivec",
         .description = "Enable Altivec instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.booke)] = .{
-        .index = @enumToInt(Feature.booke),
-        .name = @tagName(Feature.booke),
         .llvm_name = "booke",
         .description = "Enable Book E instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .icbt,
         }),
     };
     result[@enumToInt(Feature.bpermd)] = .{
-        .index = @enumToInt(Feature.bpermd),
-        .name = @tagName(Feature.bpermd),
         .llvm_name = "bpermd",
         .description = "Enable the bpermd instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cmpb)] = .{
-        .index = @enumToInt(Feature.cmpb),
-        .name = @tagName(Feature.cmpb),
         .llvm_name = "cmpb",
         .description = "Enable the cmpb instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.crbits)] = .{
-        .index = @enumToInt(Feature.crbits),
-        .name = @tagName(Feature.crbits),
         .llvm_name = "crbits",
         .description = "Use condition-register bits individually",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.crypto)] = .{
-        .index = @enumToInt(Feature.crypto),
-        .name = @tagName(Feature.crypto),
         .llvm_name = "crypto",
         .description = "Enable POWER8 Crypto instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .power8_altivec,
         }),
     };
     result[@enumToInt(Feature.direct_move)] = .{
-        .index = @enumToInt(Feature.direct_move),
-        .name = @tagName(Feature.direct_move),
         .llvm_name = "direct-move",
         .description = "Enable Power8 direct move instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vsx,
         }),
     };
     result[@enumToInt(Feature.e500)] = .{
-        .index = @enumToInt(Feature.e500),
-        .name = @tagName(Feature.e500),
         .llvm_name = "e500",
         .description = "Enable E500/E500mc instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.extdiv)] = .{
-        .index = @enumToInt(Feature.extdiv),
-        .name = @tagName(Feature.extdiv),
         .llvm_name = "extdiv",
         .description = "Enable extended divide instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fcpsgn)] = .{
-        .index = @enumToInt(Feature.fcpsgn),
-        .name = @tagName(Feature.fcpsgn),
         .llvm_name = "fcpsgn",
         .description = "Enable the fcpsgn instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.float128)] = .{
-        .index = @enumToInt(Feature.float128),
-        .name = @tagName(Feature.float128),
         .llvm_name = "float128",
         .description = "Enable the __float128 data type for IEEE-754R Binary128.",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vsx,
         }),
     };
     result[@enumToInt(Feature.fpcvt)] = .{
-        .index = @enumToInt(Feature.fpcvt),
-        .name = @tagName(Feature.fpcvt),
         .llvm_name = "fpcvt",
         .description = "Enable fc[ft]* (unsigned and single-precision) and lfiwzx instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.fprnd)] = .{
-        .index = @enumToInt(Feature.fprnd),
-        .name = @tagName(Feature.fprnd),
         .llvm_name = "fprnd",
         .description = "Enable the fri[mnpz] instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.fpu)] = .{
-        .index = @enumToInt(Feature.fpu),
-        .name = @tagName(Feature.fpu),
         .llvm_name = "fpu",
         .description = "Enable classic FPU instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hard_float,
         }),
     };
     result[@enumToInt(Feature.fre)] = .{
-        .index = @enumToInt(Feature.fre),
-        .name = @tagName(Feature.fre),
         .llvm_name = "fre",
         .description = "Enable the fre instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.fres)] = .{
-        .index = @enumToInt(Feature.fres),
-        .name = @tagName(Feature.fres),
         .llvm_name = "fres",
         .description = "Enable the fres instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.frsqrte)] = .{
-        .index = @enumToInt(Feature.frsqrte),
-        .name = @tagName(Feature.frsqrte),
         .llvm_name = "frsqrte",
         .description = "Enable the frsqrte instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.frsqrtes)] = .{
-        .index = @enumToInt(Feature.frsqrtes),
-        .name = @tagName(Feature.frsqrtes),
         .llvm_name = "frsqrtes",
         .description = "Enable the frsqrtes instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.fsqrt)] = .{
-        .index = @enumToInt(Feature.fsqrt),
-        .name = @tagName(Feature.fsqrt),
         .llvm_name = "fsqrt",
         .description = "Enable the fsqrt instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.hard_float)] = .{
-        .index = @enumToInt(Feature.hard_float),
-        .name = @tagName(Feature.hard_float),
         .llvm_name = "hard-float",
         .description = "Enable floating-point instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.htm)] = .{
-        .index = @enumToInt(Feature.htm),
-        .name = @tagName(Feature.htm),
         .llvm_name = "htm",
         .description = "Enable Hardware Transactional Memory instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.icbt)] = .{
-        .index = @enumToInt(Feature.icbt),
-        .name = @tagName(Feature.icbt),
         .llvm_name = "icbt",
         .description = "Enable icbt instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.invariant_function_descriptors)] = .{
-        .index = @enumToInt(Feature.invariant_function_descriptors),
-        .name = @tagName(Feature.invariant_function_descriptors),
         .llvm_name = "invariant-function-descriptors",
         .description = "Assume function descriptors are invariant",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.isa_v30_instructions)] = .{
-        .index = @enumToInt(Feature.isa_v30_instructions),
-        .name = @tagName(Feature.isa_v30_instructions),
         .llvm_name = "isa-v30-instructions",
         .description = "Enable instructions added in ISA 3.0.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.isel)] = .{
-        .index = @enumToInt(Feature.isel),
-        .name = @tagName(Feature.isel),
         .llvm_name = "isel",
         .description = "Enable the isel instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ldbrx)] = .{
-        .index = @enumToInt(Feature.ldbrx),
-        .name = @tagName(Feature.ldbrx),
         .llvm_name = "ldbrx",
         .description = "Enable the ldbrx instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lfiwax)] = .{
-        .index = @enumToInt(Feature.lfiwax),
-        .name = @tagName(Feature.lfiwax),
         .llvm_name = "lfiwax",
         .description = "Enable the lfiwax instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.longcall)] = .{
-        .index = @enumToInt(Feature.longcall),
-        .name = @tagName(Feature.longcall),
         .llvm_name = "longcall",
         .description = "Always use indirect calls",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mfocrf)] = .{
-        .index = @enumToInt(Feature.mfocrf),
-        .name = @tagName(Feature.mfocrf),
         .llvm_name = "mfocrf",
         .description = "Enable the MFOCRF instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.msync)] = .{
-        .index = @enumToInt(Feature.msync),
-        .name = @tagName(Feature.msync),
         .llvm_name = "msync",
         .description = "Has only the msync instruction instead of sync",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .booke,
         }),
     };
     result[@enumToInt(Feature.partword_atomics)] = .{
-        .index = @enumToInt(Feature.partword_atomics),
-        .name = @tagName(Feature.partword_atomics),
         .llvm_name = "partword-atomics",
         .description = "Enable l[bh]arx and st[bh]cx.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.popcntd)] = .{
-        .index = @enumToInt(Feature.popcntd),
-        .name = @tagName(Feature.popcntd),
         .llvm_name = "popcntd",
         .description = "Enable the popcnt[dw] instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.power8_altivec)] = .{
-        .index = @enumToInt(Feature.power8_altivec),
-        .name = @tagName(Feature.power8_altivec),
         .llvm_name = "power8-altivec",
         .description = "Enable POWER8 Altivec instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .altivec,
         }),
     };
     result[@enumToInt(Feature.power8_vector)] = .{
-        .index = @enumToInt(Feature.power8_vector),
-        .name = @tagName(Feature.power8_vector),
         .llvm_name = "power8-vector",
         .description = "Enable POWER8 vector instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .power8_altivec,
             .vsx,
         }),
     };
     result[@enumToInt(Feature.power9_altivec)] = .{
-        .index = @enumToInt(Feature.power9_altivec),
-        .name = @tagName(Feature.power9_altivec),
         .llvm_name = "power9-altivec",
         .description = "Enable POWER9 Altivec instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .isa_v30_instructions,
             .power8_altivec,
         }),
     };
     result[@enumToInt(Feature.power9_vector)] = .{
-        .index = @enumToInt(Feature.power9_vector),
-        .name = @tagName(Feature.power9_vector),
         .llvm_name = "power9-vector",
         .description = "Enable POWER9 vector instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .isa_v30_instructions,
             .power8_vector,
             .power9_altivec,
         }),
     };
     result[@enumToInt(Feature.ppc_postra_sched)] = .{
-        .index = @enumToInt(Feature.ppc_postra_sched),
-        .name = @tagName(Feature.ppc_postra_sched),
         .llvm_name = "ppc-postra-sched",
         .description = "Use PowerPC post-RA scheduling strategy",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ppc_prera_sched)] = .{
-        .index = @enumToInt(Feature.ppc_prera_sched),
-        .name = @tagName(Feature.ppc_prera_sched),
         .llvm_name = "ppc-prera-sched",
         .description = "Use PowerPC pre-RA scheduling strategy",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ppc4xx)] = .{
-        .index = @enumToInt(Feature.ppc4xx),
-        .name = @tagName(Feature.ppc4xx),
         .llvm_name = "ppc4xx",
         .description = "Enable PPC 4xx instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ppc6xx)] = .{
-        .index = @enumToInt(Feature.ppc6xx),
-        .name = @tagName(Feature.ppc6xx),
         .llvm_name = "ppc6xx",
         .description = "Enable PPC 6xx instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.qpx)] = .{
-        .index = @enumToInt(Feature.qpx),
-        .name = @tagName(Feature.qpx),
         .llvm_name = "qpx",
         .description = "Enable QPX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.recipprec)] = .{
-        .index = @enumToInt(Feature.recipprec),
-        .name = @tagName(Feature.recipprec),
         .llvm_name = "recipprec",
         .description = "Assume higher precision reciprocal estimates",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.secure_plt)] = .{
-        .index = @enumToInt(Feature.secure_plt),
-        .name = @tagName(Feature.secure_plt),
         .llvm_name = "secure-plt",
         .description = "Enable secure plt mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_popcntd)] = .{
-        .index = @enumToInt(Feature.slow_popcntd),
-        .name = @tagName(Feature.slow_popcntd),
         .llvm_name = "slow-popcntd",
         .description = "Has slow popcnt[dw] instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.spe)] = .{
-        .index = @enumToInt(Feature.spe),
-        .name = @tagName(Feature.spe),
         .llvm_name = "spe",
         .description = "Enable SPE instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hard_float,
         }),
     };
     result[@enumToInt(Feature.stfiwx)] = .{
-        .index = @enumToInt(Feature.stfiwx),
-        .name = @tagName(Feature.stfiwx),
         .llvm_name = "stfiwx",
         .description = "Enable the stfiwx instruction",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpu,
         }),
     };
     result[@enumToInt(Feature.two_const_nr)] = .{
-        .index = @enumToInt(Feature.two_const_nr),
-        .name = @tagName(Feature.two_const_nr),
         .llvm_name = "two-const-nr",
         .description = "Requires two constant Newton-Raphson computation",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vectors_use_two_units)] = .{
-        .index = @enumToInt(Feature.vectors_use_two_units),
-        .name = @tagName(Feature.vectors_use_two_units),
         .llvm_name = "vectors-use-two-units",
         .description = "Vectors use two units",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vsx)] = .{
-        .index = @enumToInt(Feature.vsx),
-        .name = @tagName(Feature.vsx),
         .llvm_name = "vsx",
         .description = "Enable VSX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .altivec,
         }),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -477,7 +381,7 @@ pub const cpu = struct {
     pub const @"440" = Cpu{
         .name = "440",
         .llvm_name = "440",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .booke,
             .fres,
             .frsqrte,
@@ -489,7 +393,7 @@ pub const cpu = struct {
     pub const @"450" = Cpu{
         .name = "450",
         .llvm_name = "450",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .booke,
             .fres,
             .frsqrte,
@@ -501,21 +405,21 @@ pub const cpu = struct {
     pub const @"601" = Cpu{
         .name = "601",
         .llvm_name = "601",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fpu,
         }),
     };
     pub const @"602" = Cpu{
         .name = "602",
         .llvm_name = "602",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fpu,
         }),
     };
     pub const @"603" = Cpu{
         .name = "603",
         .llvm_name = "603",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -523,7 +427,7 @@ pub const cpu = struct {
     pub const @"603e" = Cpu{
         .name = "603e",
         .llvm_name = "603e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -531,7 +435,7 @@ pub const cpu = struct {
     pub const @"603ev" = Cpu{
         .name = "603ev",
         .llvm_name = "603ev",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -539,7 +443,7 @@ pub const cpu = struct {
     pub const @"604" = Cpu{
         .name = "604",
         .llvm_name = "604",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -547,7 +451,7 @@ pub const cpu = struct {
     pub const @"604e" = Cpu{
         .name = "604e",
         .llvm_name = "604e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -555,7 +459,7 @@ pub const cpu = struct {
     pub const @"620" = Cpu{
         .name = "620",
         .llvm_name = "620",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -563,7 +467,7 @@ pub const cpu = struct {
     pub const @"7400" = Cpu{
         .name = "7400",
         .llvm_name = "7400",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .altivec,
             .fres,
             .frsqrte,
@@ -572,7 +476,7 @@ pub const cpu = struct {
     pub const @"7450" = Cpu{
         .name = "7450",
         .llvm_name = "7450",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .altivec,
             .fres,
             .frsqrte,
@@ -581,7 +485,7 @@ pub const cpu = struct {
     pub const @"750" = Cpu{
         .name = "750",
         .llvm_name = "750",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -589,7 +493,7 @@ pub const cpu = struct {
     pub const @"970" = Cpu{
         .name = "970",
         .llvm_name = "970",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fres,
@@ -602,7 +506,7 @@ pub const cpu = struct {
     pub const a2 = Cpu{
         .name = "a2",
         .llvm_name = "a2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .booke,
             .cmpb,
@@ -627,7 +531,7 @@ pub const cpu = struct {
     pub const a2q = Cpu{
         .name = "a2q",
         .llvm_name = "a2q",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .booke,
             .cmpb,
@@ -653,7 +557,7 @@ pub const cpu = struct {
     pub const e500 = Cpu{
         .name = "e500",
         .llvm_name = "e500",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .booke,
             .icbt,
             .isel,
@@ -662,7 +566,7 @@ pub const cpu = struct {
     pub const e500mc = Cpu{
         .name = "e500mc",
         .llvm_name = "e500mc",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .booke,
             .icbt,
             .isel,
@@ -672,7 +576,7 @@ pub const cpu = struct {
     pub const e5500 = Cpu{
         .name = "e5500",
         .llvm_name = "e5500",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .booke,
             .icbt,
@@ -684,7 +588,7 @@ pub const cpu = struct {
     pub const g3 = Cpu{
         .name = "g3",
         .llvm_name = "g3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fres,
             .frsqrte,
         }),
@@ -692,7 +596,7 @@ pub const cpu = struct {
     pub const g4 = Cpu{
         .name = "g4",
         .llvm_name = "g4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .altivec,
             .fres,
             .frsqrte,
@@ -701,7 +605,7 @@ pub const cpu = struct {
     pub const @"g4+" = Cpu{
         .name = "g4+",
         .llvm_name = "g4+",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .altivec,
             .fres,
             .frsqrte,
@@ -710,7 +614,7 @@ pub const cpu = struct {
     pub const g5 = Cpu{
         .name = "g5",
         .llvm_name = "g5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fres,
@@ -723,28 +627,28 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hard_float,
         }),
     };
     pub const ppc = Cpu{
         .name = "ppc",
         .llvm_name = "ppc",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hard_float,
         }),
     };
     pub const ppc32 = Cpu{
         .name = "ppc32",
         .llvm_name = "ppc32",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hard_float,
         }),
     };
     pub const ppc64 = Cpu{
         .name = "ppc64",
         .llvm_name = "ppc64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fres,
@@ -757,7 +661,7 @@ pub const cpu = struct {
     pub const ppc64le = Cpu{
         .name = "ppc64le",
         .llvm_name = "ppc64le",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .bpermd,
@@ -792,7 +696,7 @@ pub const cpu = struct {
     pub const pwr3 = Cpu{
         .name = "pwr3",
         .llvm_name = "pwr3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fres,
@@ -804,7 +708,7 @@ pub const cpu = struct {
     pub const pwr4 = Cpu{
         .name = "pwr4",
         .llvm_name = "pwr4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fres,
@@ -817,7 +721,7 @@ pub const cpu = struct {
     pub const pwr5 = Cpu{
         .name = "pwr5",
         .llvm_name = "pwr5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fre,
@@ -832,7 +736,7 @@ pub const cpu = struct {
     pub const pwr5x = Cpu{
         .name = "pwr5x",
         .llvm_name = "pwr5x",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .fprnd,
@@ -848,7 +752,7 @@ pub const cpu = struct {
     pub const pwr6 = Cpu{
         .name = "pwr6",
         .llvm_name = "pwr6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .cmpb,
@@ -868,7 +772,7 @@ pub const cpu = struct {
     pub const pwr6x = Cpu{
         .name = "pwr6x",
         .llvm_name = "pwr6x",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .cmpb,
@@ -888,7 +792,7 @@ pub const cpu = struct {
     pub const pwr7 = Cpu{
         .name = "pwr7",
         .llvm_name = "pwr7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .bpermd,
@@ -916,7 +820,7 @@ pub const cpu = struct {
     pub const pwr8 = Cpu{
         .name = "pwr8",
         .llvm_name = "pwr8",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .bpermd,
@@ -951,7 +855,7 @@ pub const cpu = struct {
     pub const pwr9 = Cpu{
         .name = "pwr9",
         .llvm_name = "pwr9",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .altivec,
             .bpermd,

lib/std/target/riscv.zig

@@ -16,66 +16,56 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.@"64bit")] = .{
-        .index = @enumToInt(Feature.@"64bit"),
-        .name = @tagName(Feature.@"64bit"),
         .llvm_name = "64bit",
         .description = "Implements RV64",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a)] = .{
-        .index = @enumToInt(Feature.a),
-        .name = @tagName(Feature.a),
         .llvm_name = "a",
         .description = "'A' (Atomic Instructions)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.c)] = .{
-        .index = @enumToInt(Feature.c),
-        .name = @tagName(Feature.c),
         .llvm_name = "c",
         .description = "'C' (Compressed Instructions)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.d)] = .{
-        .index = @enumToInt(Feature.d),
-        .name = @tagName(Feature.d),
         .llvm_name = "d",
         .description = "'D' (Double-Precision Floating-Point)",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .f,
         }),
     };
     result[@enumToInt(Feature.e)] = .{
-        .index = @enumToInt(Feature.e),
-        .name = @tagName(Feature.e),
         .llvm_name = "e",
         .description = "Implements RV32E (provides 16 rather than 32 GPRs)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.f)] = .{
-        .index = @enumToInt(Feature.f),
-        .name = @tagName(Feature.f),
         .llvm_name = "f",
         .description = "'F' (Single-Precision Floating-Point)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.m)] = .{
-        .index = @enumToInt(Feature.m),
-        .name = @tagName(Feature.m),
         .llvm_name = "m",
         .description = "'M' (Integer Multiplication and Division)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.relax)] = .{
-        .index = @enumToInt(Feature.relax),
-        .name = @tagName(Feature.relax),
         .llvm_name = "relax",
         .description = "Enable Linker relaxation.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -83,12 +73,12 @@ pub const cpu = struct {
     pub const generic_rv32 = Cpu{
         .name = "generic_rv32",
         .llvm_name = "generic-rv32",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const generic_rv64 = Cpu{
         .name = "generic_rv64",
         .llvm_name = "generic-rv64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
         }),
     };
@@ -102,7 +92,7 @@ pub const all_cpus = &[_]*const Cpu{
     &cpu.generic_rv64,
 };
 
-pub const baseline_32_features = featureSet(&[_]Feature{
+pub const baseline_32_features = featureSet(&all_features, &[_]Feature{
     .a,
     .c,
     .d,
@@ -111,7 +101,7 @@ pub const baseline_32_features = featureSet(&[_]Feature{
     .relax,
 });
 
-pub const baseline_64_features = featureSet(&[_]Feature{
+pub const baseline_64_features = featureSet(&all_features, &[_]Feature{
     .@"64bit",
     .a,
     .c,

lib/std/target/sparc.zig

@@ -27,141 +27,109 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.deprecated_v8)] = .{
-        .index = @enumToInt(Feature.deprecated_v8),
-        .name = @tagName(Feature.deprecated_v8),
         .llvm_name = "deprecated-v8",
         .description = "Enable deprecated V8 instructions in V9 mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.detectroundchange)] = .{
-        .index = @enumToInt(Feature.detectroundchange),
-        .name = @tagName(Feature.detectroundchange),
         .llvm_name = "detectroundchange",
         .description = "LEON3 erratum detection: Detects any rounding mode change request: use only the round-to-nearest rounding mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fixallfdivsqrt)] = .{
-        .index = @enumToInt(Feature.fixallfdivsqrt),
-        .name = @tagName(Feature.fixallfdivsqrt),
         .llvm_name = "fixallfdivsqrt",
         .description = "LEON erratum fix: Fix FDIVS/FDIVD/FSQRTS/FSQRTD instructions with NOPs and floating-point store",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hard_quad_float)] = .{
-        .index = @enumToInt(Feature.hard_quad_float),
-        .name = @tagName(Feature.hard_quad_float),
         .llvm_name = "hard-quad-float",
         .description = "Enable quad-word floating point instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hasleoncasa)] = .{
-        .index = @enumToInt(Feature.hasleoncasa),
-        .name = @tagName(Feature.hasleoncasa),
         .llvm_name = "hasleoncasa",
         .description = "Enable CASA instruction for LEON3 and LEON4 processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hasumacsmac)] = .{
-        .index = @enumToInt(Feature.hasumacsmac),
-        .name = @tagName(Feature.hasumacsmac),
         .llvm_name = "hasumacsmac",
         .description = "Enable UMAC and SMAC for LEON3 and LEON4 processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.insertnopload)] = .{
-        .index = @enumToInt(Feature.insertnopload),
-        .name = @tagName(Feature.insertnopload),
         .llvm_name = "insertnopload",
         .description = "LEON3 erratum fix: Insert a NOP instruction after every single-cycle load instruction when the next instruction is another load/store instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.leon)] = .{
-        .index = @enumToInt(Feature.leon),
-        .name = @tagName(Feature.leon),
         .llvm_name = "leon",
         .description = "Enable LEON extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.leoncyclecounter)] = .{
-        .index = @enumToInt(Feature.leoncyclecounter),
-        .name = @tagName(Feature.leoncyclecounter),
         .llvm_name = "leoncyclecounter",
         .description = "Use the Leon cycle counter register",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.leonpwrpsr)] = .{
-        .index = @enumToInt(Feature.leonpwrpsr),
-        .name = @tagName(Feature.leonpwrpsr),
         .llvm_name = "leonpwrpsr",
         .description = "Enable the PWRPSR instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_fmuls)] = .{
-        .index = @enumToInt(Feature.no_fmuls),
-        .name = @tagName(Feature.no_fmuls),
         .llvm_name = "no-fmuls",
         .description = "Disable the fmuls instruction.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_fsmuld)] = .{
-        .index = @enumToInt(Feature.no_fsmuld),
-        .name = @tagName(Feature.no_fsmuld),
         .llvm_name = "no-fsmuld",
         .description = "Disable the fsmuld instruction.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.popc)] = .{
-        .index = @enumToInt(Feature.popc),
-        .name = @tagName(Feature.popc),
         .llvm_name = "popc",
         .description = "Use the popc (population count) instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.soft_float)] = .{
-        .index = @enumToInt(Feature.soft_float),
-        .name = @tagName(Feature.soft_float),
         .llvm_name = "soft-float",
         .description = "Use software emulation for floating point",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.soft_mul_div)] = .{
-        .index = @enumToInt(Feature.soft_mul_div),
-        .name = @tagName(Feature.soft_mul_div),
         .llvm_name = "soft-mul-div",
         .description = "Use software emulation for integer multiply and divide",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v9)] = .{
-        .index = @enumToInt(Feature.v9),
-        .name = @tagName(Feature.v9),
         .llvm_name = "v9",
         .description = "Enable SPARC-V9 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vis)] = .{
-        .index = @enumToInt(Feature.vis),
-        .name = @tagName(Feature.vis),
         .llvm_name = "vis",
         .description = "Enable UltraSPARC Visual Instruction Set extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vis2)] = .{
-        .index = @enumToInt(Feature.vis2),
-        .name = @tagName(Feature.vis2),
         .llvm_name = "vis2",
         .description = "Enable Visual Instruction Set extensions II",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vis3)] = .{
-        .index = @enumToInt(Feature.vis3),
-        .name = @tagName(Feature.vis3),
         .llvm_name = "vis3",
         .description = "Enable Visual Instruction Set extensions III",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -169,7 +137,7 @@ pub const cpu = struct {
     pub const at697e = Cpu{
         .name = "at697e",
         .llvm_name = "at697e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .insertnopload,
             .leon,
         }),
@@ -177,7 +145,7 @@ pub const cpu = struct {
     pub const at697f = Cpu{
         .name = "at697f",
         .llvm_name = "at697f",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .insertnopload,
             .leon,
         }),
@@ -185,17 +153,17 @@ pub const cpu = struct {
     pub const f934 = Cpu{
         .name = "f934",
         .llvm_name = "f934",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const gr712rc = Cpu{
         .name = "gr712rc",
         .llvm_name = "gr712rc",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -203,7 +171,7 @@ pub const cpu = struct {
     pub const gr740 = Cpu{
         .name = "gr740",
         .llvm_name = "gr740",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .hasumacsmac,
             .leon,
@@ -214,19 +182,19 @@ pub const cpu = struct {
     pub const hypersparc = Cpu{
         .name = "hypersparc",
         .llvm_name = "hypersparc",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const leon2 = Cpu{
         .name = "leon2",
         .llvm_name = "leon2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .leon,
         }),
     };
     pub const leon3 = Cpu{
         .name = "leon3",
         .llvm_name = "leon3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasumacsmac,
             .leon,
         }),
@@ -234,7 +202,7 @@ pub const cpu = struct {
     pub const leon4 = Cpu{
         .name = "leon4",
         .llvm_name = "leon4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .hasumacsmac,
             .leon,
@@ -243,7 +211,7 @@ pub const cpu = struct {
     pub const ma2080 = Cpu{
         .name = "ma2080",
         .llvm_name = "ma2080",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -251,7 +219,7 @@ pub const cpu = struct {
     pub const ma2085 = Cpu{
         .name = "ma2085",
         .llvm_name = "ma2085",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -259,7 +227,7 @@ pub const cpu = struct {
     pub const ma2100 = Cpu{
         .name = "ma2100",
         .llvm_name = "ma2100",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -267,7 +235,7 @@ pub const cpu = struct {
     pub const ma2150 = Cpu{
         .name = "ma2150",
         .llvm_name = "ma2150",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -275,7 +243,7 @@ pub const cpu = struct {
     pub const ma2155 = Cpu{
         .name = "ma2155",
         .llvm_name = "ma2155",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -283,7 +251,7 @@ pub const cpu = struct {
     pub const ma2450 = Cpu{
         .name = "ma2450",
         .llvm_name = "ma2450",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -291,7 +259,7 @@ pub const cpu = struct {
     pub const ma2455 = Cpu{
         .name = "ma2455",
         .llvm_name = "ma2455",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -299,7 +267,7 @@ pub const cpu = struct {
     pub const ma2480 = Cpu{
         .name = "ma2480",
         .llvm_name = "ma2480",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -307,7 +275,7 @@ pub const cpu = struct {
     pub const ma2485 = Cpu{
         .name = "ma2485",
         .llvm_name = "ma2485",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -315,7 +283,7 @@ pub const cpu = struct {
     pub const ma2x5x = Cpu{
         .name = "ma2x5x",
         .llvm_name = "ma2x5x",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -323,7 +291,7 @@ pub const cpu = struct {
     pub const ma2x8x = Cpu{
         .name = "ma2x8x",
         .llvm_name = "ma2x8x",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -331,7 +299,7 @@ pub const cpu = struct {
     pub const myriad2 = Cpu{
         .name = "myriad2",
         .llvm_name = "myriad2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -339,7 +307,7 @@ pub const cpu = struct {
     pub const myriad2_1 = Cpu{
         .name = "myriad2_1",
         .llvm_name = "myriad2.1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -347,7 +315,7 @@ pub const cpu = struct {
     pub const myriad2_2 = Cpu{
         .name = "myriad2_2",
         .llvm_name = "myriad2.2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -355,7 +323,7 @@ pub const cpu = struct {
     pub const myriad2_3 = Cpu{
         .name = "myriad2_3",
         .llvm_name = "myriad2.3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .hasleoncasa,
             .leon,
         }),
@@ -363,7 +331,7 @@ pub const cpu = struct {
     pub const niagara = Cpu{
         .name = "niagara",
         .llvm_name = "niagara",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deprecated_v8,
             .v9,
             .vis,
@@ -373,7 +341,7 @@ pub const cpu = struct {
     pub const niagara2 = Cpu{
         .name = "niagara2",
         .llvm_name = "niagara2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deprecated_v8,
             .popc,
             .v9,
@@ -384,7 +352,7 @@ pub const cpu = struct {
     pub const niagara3 = Cpu{
         .name = "niagara3",
         .llvm_name = "niagara3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deprecated_v8,
             .popc,
             .v9,
@@ -395,7 +363,7 @@ pub const cpu = struct {
     pub const niagara4 = Cpu{
         .name = "niagara4",
         .llvm_name = "niagara4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deprecated_v8,
             .popc,
             .v9,
@@ -407,32 +375,32 @@ pub const cpu = struct {
     pub const sparclet = Cpu{
         .name = "sparclet",
         .llvm_name = "sparclet",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const sparclite = Cpu{
         .name = "sparclite",
         .llvm_name = "sparclite",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const sparclite86x = Cpu{
         .name = "sparclite86x",
         .llvm_name = "sparclite86x",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const supersparc = Cpu{
         .name = "supersparc",
         .llvm_name = "supersparc",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const tsc701 = Cpu{
         .name = "tsc701",
         .llvm_name = "tsc701",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const ultrasparc = Cpu{
         .name = "ultrasparc",
         .llvm_name = "ultrasparc",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deprecated_v8,
             .v9,
             .vis,
@@ -441,7 +409,7 @@ pub const cpu = struct {
     pub const ultrasparc3 = Cpu{
         .name = "ultrasparc3",
         .llvm_name = "ultrasparc3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deprecated_v8,
             .v9,
             .vis,
@@ -451,7 +419,7 @@ pub const cpu = struct {
     pub const ut699 = Cpu{
         .name = "ut699",
         .llvm_name = "ut699",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fixallfdivsqrt,
             .insertnopload,
             .leon,
@@ -462,7 +430,7 @@ pub const cpu = struct {
     pub const v7 = Cpu{
         .name = "v7",
         .llvm_name = "v7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .no_fsmuld,
             .soft_mul_div,
         }),
@@ -470,12 +438,12 @@ pub const cpu = struct {
     pub const v8 = Cpu{
         .name = "v8",
         .llvm_name = "v8",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const v9 = Cpu{
         .name = "v9",
         .llvm_name = "v9",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .v9,
         }),
     };

lib/std/target/systemz.zig

@@ -43,253 +43,189 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.deflate_conversion)] = .{
-        .index = @enumToInt(Feature.deflate_conversion),
-        .name = @tagName(Feature.deflate_conversion),
         .llvm_name = "deflate-conversion",
         .description = "Assume that the deflate-conversion facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dfp_packed_conversion)] = .{
-        .index = @enumToInt(Feature.dfp_packed_conversion),
-        .name = @tagName(Feature.dfp_packed_conversion),
         .llvm_name = "dfp-packed-conversion",
         .description = "Assume that the DFP packed-conversion facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dfp_zoned_conversion)] = .{
-        .index = @enumToInt(Feature.dfp_zoned_conversion),
-        .name = @tagName(Feature.dfp_zoned_conversion),
         .llvm_name = "dfp-zoned-conversion",
         .description = "Assume that the DFP zoned-conversion facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.distinct_ops)] = .{
-        .index = @enumToInt(Feature.distinct_ops),
-        .name = @tagName(Feature.distinct_ops),
         .llvm_name = "distinct-ops",
         .description = "Assume that the distinct-operands facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.enhanced_dat_2)] = .{
-        .index = @enumToInt(Feature.enhanced_dat_2),
-        .name = @tagName(Feature.enhanced_dat_2),
         .llvm_name = "enhanced-dat-2",
         .description = "Assume that the enhanced-DAT facility 2 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.enhanced_sort)] = .{
-        .index = @enumToInt(Feature.enhanced_sort),
-        .name = @tagName(Feature.enhanced_sort),
         .llvm_name = "enhanced-sort",
         .description = "Assume that the enhanced-sort facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.execution_hint)] = .{
-        .index = @enumToInt(Feature.execution_hint),
-        .name = @tagName(Feature.execution_hint),
         .llvm_name = "execution-hint",
         .description = "Assume that the execution-hint facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_serialization)] = .{
-        .index = @enumToInt(Feature.fast_serialization),
-        .name = @tagName(Feature.fast_serialization),
         .llvm_name = "fast-serialization",
         .description = "Assume that the fast-serialization facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp_extension)] = .{
-        .index = @enumToInt(Feature.fp_extension),
-        .name = @tagName(Feature.fp_extension),
         .llvm_name = "fp-extension",
         .description = "Assume that the floating-point extension facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.guarded_storage)] = .{
-        .index = @enumToInt(Feature.guarded_storage),
-        .name = @tagName(Feature.guarded_storage),
         .llvm_name = "guarded-storage",
         .description = "Assume that the guarded-storage facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.high_word)] = .{
-        .index = @enumToInt(Feature.high_word),
-        .name = @tagName(Feature.high_word),
         .llvm_name = "high-word",
         .description = "Assume that the high-word facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.insert_reference_bits_multiple)] = .{
-        .index = @enumToInt(Feature.insert_reference_bits_multiple),
-        .name = @tagName(Feature.insert_reference_bits_multiple),
         .llvm_name = "insert-reference-bits-multiple",
         .description = "Assume that the insert-reference-bits-multiple facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.interlocked_access1)] = .{
-        .index = @enumToInt(Feature.interlocked_access1),
-        .name = @tagName(Feature.interlocked_access1),
         .llvm_name = "interlocked-access1",
         .description = "Assume that interlocked-access facility 1 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.load_and_trap)] = .{
-        .index = @enumToInt(Feature.load_and_trap),
-        .name = @tagName(Feature.load_and_trap),
         .llvm_name = "load-and-trap",
         .description = "Assume that the load-and-trap facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.load_and_zero_rightmost_byte)] = .{
-        .index = @enumToInt(Feature.load_and_zero_rightmost_byte),
-        .name = @tagName(Feature.load_and_zero_rightmost_byte),
         .llvm_name = "load-and-zero-rightmost-byte",
         .description = "Assume that the load-and-zero-rightmost-byte facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.load_store_on_cond)] = .{
-        .index = @enumToInt(Feature.load_store_on_cond),
-        .name = @tagName(Feature.load_store_on_cond),
         .llvm_name = "load-store-on-cond",
         .description = "Assume that the load/store-on-condition facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.load_store_on_cond_2)] = .{
-        .index = @enumToInt(Feature.load_store_on_cond_2),
-        .name = @tagName(Feature.load_store_on_cond_2),
         .llvm_name = "load-store-on-cond-2",
         .description = "Assume that the load/store-on-condition facility 2 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.message_security_assist_extension3)] = .{
-        .index = @enumToInt(Feature.message_security_assist_extension3),
-        .name = @tagName(Feature.message_security_assist_extension3),
         .llvm_name = "message-security-assist-extension3",
         .description = "Assume that the message-security-assist extension facility 3 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.message_security_assist_extension4)] = .{
-        .index = @enumToInt(Feature.message_security_assist_extension4),
-        .name = @tagName(Feature.message_security_assist_extension4),
         .llvm_name = "message-security-assist-extension4",
         .description = "Assume that the message-security-assist extension facility 4 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.message_security_assist_extension5)] = .{
-        .index = @enumToInt(Feature.message_security_assist_extension5),
-        .name = @tagName(Feature.message_security_assist_extension5),
         .llvm_name = "message-security-assist-extension5",
         .description = "Assume that the message-security-assist extension facility 5 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.message_security_assist_extension7)] = .{
-        .index = @enumToInt(Feature.message_security_assist_extension7),
-        .name = @tagName(Feature.message_security_assist_extension7),
         .llvm_name = "message-security-assist-extension7",
         .description = "Assume that the message-security-assist extension facility 7 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.message_security_assist_extension8)] = .{
-        .index = @enumToInt(Feature.message_security_assist_extension8),
-        .name = @tagName(Feature.message_security_assist_extension8),
         .llvm_name = "message-security-assist-extension8",
         .description = "Assume that the message-security-assist extension facility 8 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.message_security_assist_extension9)] = .{
-        .index = @enumToInt(Feature.message_security_assist_extension9),
-        .name = @tagName(Feature.message_security_assist_extension9),
         .llvm_name = "message-security-assist-extension9",
         .description = "Assume that the message-security-assist extension facility 9 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.miscellaneous_extensions)] = .{
-        .index = @enumToInt(Feature.miscellaneous_extensions),
-        .name = @tagName(Feature.miscellaneous_extensions),
         .llvm_name = "miscellaneous-extensions",
         .description = "Assume that the miscellaneous-extensions facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.miscellaneous_extensions_2)] = .{
-        .index = @enumToInt(Feature.miscellaneous_extensions_2),
-        .name = @tagName(Feature.miscellaneous_extensions_2),
         .llvm_name = "miscellaneous-extensions-2",
         .description = "Assume that the miscellaneous-extensions facility 2 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.miscellaneous_extensions_3)] = .{
-        .index = @enumToInt(Feature.miscellaneous_extensions_3),
-        .name = @tagName(Feature.miscellaneous_extensions_3),
         .llvm_name = "miscellaneous-extensions-3",
         .description = "Assume that the miscellaneous-extensions facility 3 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.population_count)] = .{
-        .index = @enumToInt(Feature.population_count),
-        .name = @tagName(Feature.population_count),
         .llvm_name = "population-count",
         .description = "Assume that the population-count facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.processor_assist)] = .{
-        .index = @enumToInt(Feature.processor_assist),
-        .name = @tagName(Feature.processor_assist),
         .llvm_name = "processor-assist",
         .description = "Assume that the processor-assist facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reset_reference_bits_multiple)] = .{
-        .index = @enumToInt(Feature.reset_reference_bits_multiple),
-        .name = @tagName(Feature.reset_reference_bits_multiple),
         .llvm_name = "reset-reference-bits-multiple",
         .description = "Assume that the reset-reference-bits-multiple facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.transactional_execution)] = .{
-        .index = @enumToInt(Feature.transactional_execution),
-        .name = @tagName(Feature.transactional_execution),
         .llvm_name = "transactional-execution",
         .description = "Assume that the transactional-execution facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vector)] = .{
-        .index = @enumToInt(Feature.vector),
-        .name = @tagName(Feature.vector),
         .llvm_name = "vector",
         .description = "Assume that the vectory facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vector_enhancements_1)] = .{
-        .index = @enumToInt(Feature.vector_enhancements_1),
-        .name = @tagName(Feature.vector_enhancements_1),
         .llvm_name = "vector-enhancements-1",
         .description = "Assume that the vector enhancements facility 1 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vector_enhancements_2)] = .{
-        .index = @enumToInt(Feature.vector_enhancements_2),
-        .name = @tagName(Feature.vector_enhancements_2),
         .llvm_name = "vector-enhancements-2",
         .description = "Assume that the vector enhancements facility 2 is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vector_packed_decimal)] = .{
-        .index = @enumToInt(Feature.vector_packed_decimal),
-        .name = @tagName(Feature.vector_packed_decimal),
         .llvm_name = "vector-packed-decimal",
         .description = "Assume that the vector packed decimal facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vector_packed_decimal_enhancement)] = .{
-        .index = @enumToInt(Feature.vector_packed_decimal_enhancement),
-        .name = @tagName(Feature.vector_packed_decimal_enhancement),
         .llvm_name = "vector-packed-decimal-enhancement",
         .description = "Assume that the vector packed decimal enhancement facility is installed",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -297,7 +233,7 @@ pub const cpu = struct {
     pub const arch10 = Cpu{
         .name = "arch10",
         .llvm_name = "arch10",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .dfp_zoned_conversion,
             .distinct_ops,
             .enhanced_dat_2,
@@ -320,7 +256,7 @@ pub const cpu = struct {
     pub const arch11 = Cpu{
         .name = "arch11",
         .llvm_name = "arch11",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .dfp_packed_conversion,
             .dfp_zoned_conversion,
             .distinct_ops,
@@ -348,7 +284,7 @@ pub const cpu = struct {
     pub const arch12 = Cpu{
         .name = "arch12",
         .llvm_name = "arch12",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .dfp_packed_conversion,
             .dfp_zoned_conversion,
             .distinct_ops,
@@ -383,7 +319,7 @@ pub const cpu = struct {
     pub const arch13 = Cpu{
         .name = "arch13",
         .llvm_name = "arch13",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .deflate_conversion,
             .dfp_packed_conversion,
             .dfp_zoned_conversion,
@@ -424,12 +360,12 @@ pub const cpu = struct {
     pub const arch8 = Cpu{
         .name = "arch8",
         .llvm_name = "arch8",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const arch9 = Cpu{
         .name = "arch9",
         .llvm_name = "arch9",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .distinct_ops,
             .fast_serialization,
             .fp_extension,
@@ -445,17 +381,17 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const z10 = Cpu{
         .name = "z10",
         .llvm_name = "z10",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const z13 = Cpu{
         .name = "z13",
         .llvm_name = "z13",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .dfp_packed_conversion,
             .dfp_zoned_conversion,
             .distinct_ops,
@@ -483,7 +419,7 @@ pub const cpu = struct {
     pub const z14 = Cpu{
         .name = "z14",
         .llvm_name = "z14",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .dfp_packed_conversion,
             .dfp_zoned_conversion,
             .distinct_ops,
@@ -518,7 +454,7 @@ pub const cpu = struct {
     pub const z196 = Cpu{
         .name = "z196",
         .llvm_name = "z196",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .distinct_ops,
             .fast_serialization,
             .fp_extension,
@@ -534,7 +470,7 @@ pub const cpu = struct {
     pub const zEC12 = Cpu{
         .name = "zEC12",
         .llvm_name = "zEC12",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .dfp_zoned_conversion,
             .distinct_ops,
             .enhanced_dat_2,

lib/std/target/wasm.zig

@@ -18,80 +18,66 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
     const len = @typeInfo(Feature).Enum.fields.len;
-    std.debug.assert(len <= Cpu.Feature.Set.bit_count);
+    std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
     var result: [len]Cpu.Feature = undefined;
     result[@enumToInt(Feature.atomics)] = .{
-        .index = @enumToInt(Feature.atomics),
-        .name = @tagName(Feature.atomics),
         .llvm_name = "atomics",
         .description = "Enable Atomics",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.bulk_memory)] = .{
-        .index = @enumToInt(Feature.bulk_memory),
-        .name = @tagName(Feature.bulk_memory),
         .llvm_name = "bulk-memory",
         .description = "Enable bulk memory operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.exception_handling)] = .{
-        .index = @enumToInt(Feature.exception_handling),
-        .name = @tagName(Feature.exception_handling),
         .llvm_name = "exception-handling",
         .description = "Enable Wasm exception handling",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.multivalue)] = .{
-        .index = @enumToInt(Feature.multivalue),
-        .name = @tagName(Feature.multivalue),
         .llvm_name = "multivalue",
         .description = "Enable multivalue blocks, instructions, and functions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mutable_globals)] = .{
-        .index = @enumToInt(Feature.mutable_globals),
-        .name = @tagName(Feature.mutable_globals),
         .llvm_name = "mutable-globals",
         .description = "Enable mutable globals",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nontrapping_fptoint)] = .{
-        .index = @enumToInt(Feature.nontrapping_fptoint),
-        .name = @tagName(Feature.nontrapping_fptoint),
         .llvm_name = "nontrapping-fptoint",
         .description = "Enable non-trapping float-to-int conversion operators",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sign_ext)] = .{
-        .index = @enumToInt(Feature.sign_ext),
-        .name = @tagName(Feature.sign_ext),
         .llvm_name = "sign-ext",
         .description = "Enable sign extension operators",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.simd128)] = .{
-        .index = @enumToInt(Feature.simd128),
-        .name = @tagName(Feature.simd128),
         .llvm_name = "simd128",
         .description = "Enable 128-bit SIMD",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tail_call)] = .{
-        .index = @enumToInt(Feature.tail_call),
-        .name = @tagName(Feature.tail_call),
         .llvm_name = "tail-call",
         .description = "Enable tail call instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.unimplemented_simd128)] = .{
-        .index = @enumToInt(Feature.unimplemented_simd128),
-        .name = @tagName(Feature.unimplemented_simd128),
         .llvm_name = "unimplemented-simd128",
         .description = "Enable 128-bit SIMD not yet implemented in engines",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .simd128,
         }),
     };
+    const ti = @typeInfo(Feature);
+    for (result) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.Enum.fields[i].name;
+        elem.dependencies.initAsDependencies(i, &result);
+    }
     break :blk result;
 };
 
@@ -99,7 +85,7 @@ pub const cpu = struct {
     pub const bleeding_edge = Cpu{
         .name = "bleeding_edge",
         .llvm_name = "bleeding-edge",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .atomics,
             .mutable_globals,
             .nontrapping_fptoint,
@@ -110,12 +96,12 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const mvp = Cpu{
         .name = "mvp",
         .llvm_name = "mvp",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
 };
 

src-self-hosted/stage1.zig

@@ -581,8 +581,8 @@ fn cpuFeaturesFromLLVM(
             const this_llvm_name = feature.llvm_name orelse continue;
             if (mem.eql(u8, llvm_feat, this_llvm_name)) {
                 switch (op) {
-                    .add => set.addFeature(@intCast(u8, index)),
-                    .sub => set.removeFeature(@intCast(u8, index)),
+                    .add => set.addSparseFeature(@intCast(u8, index)),
+                    .sub => set.removeSparseFeature(@intCast(u8, index)),
                 }
                 break;
             }
@@ -676,7 +676,7 @@ const Stage2CpuFeatures = struct {
         });
         errdefer allocator.free(builtin_str);
 
-        const cache_hash = try std.fmt.allocPrint0(allocator, "{}\n{x}", .{ cpu.name, cpu.features.bytes });
+        const cache_hash = try std.fmt.allocPrint0(allocator, "{}\n{}", .{ cpu.name, cpu.features.asBytes() });
         errdefer allocator.free(cache_hash);
 
         self.* = Self{
@@ -699,10 +699,13 @@ const Stage2CpuFeatures = struct {
         defer llvm_features_buffer.deinit();
 
         const all_features = arch.allFeaturesList();
+        var populated_feature_set = feature_set;
+        if (arch.subArchFeature()) |sub_arch_index| {
+            populated_feature_set.addFeature(sub_arch_index, all_features);
+        }
         for (all_features) |feature, index| {
             const llvm_name = feature.llvm_name orelse continue;
-
-            const plus_or_minus = "-+"[@boolToInt(feature_set.isEnabled(@intCast(u8, index)))];
+            const plus_or_minus = "-+"[@boolToInt(populated_feature_set.isEnabled(@intCast(u8, index)))];
             try llvm_features_buffer.appendByte(plus_or_minus);
             try llvm_features_buffer.append(llvm_name);
             try llvm_features_buffer.append(",");
@@ -721,7 +724,7 @@ const Stage2CpuFeatures = struct {
         const self = try allocator.create(Self);
         errdefer allocator.destroy(self);
 
-        const cache_hash = try std.fmt.allocPrint0(allocator, "\n{}", .{feature_set.bytes});
+        const cache_hash = try std.fmt.allocPrint0(allocator, "\n{}", .{feature_set.asBytes()});
         errdefer allocator.free(cache_hash);
 
         const generic_arch_name = arch.genericName();

src/all_types.hpp

@@ -2144,6 +2144,7 @@ struct CodeGen {
     bool verbose_llvm_ir;
     bool verbose_cimport;
     bool verbose_cc;
+    bool verbose_llvm_cpu_features;
     bool error_during_imports;
     bool generate_error_name_table;
     bool enable_cache; // mutually exclusive with output_dir

src/codegen.cpp

@@ -8802,8 +8802,10 @@ static void init(CodeGen *g) {
         target_specific_cpu_args = stage2_cpu_features_get_llvm_cpu(g->zig_target->cpu_features);
         target_specific_features = stage2_cpu_features_get_llvm_features(g->zig_target->cpu_features);
     }
-    //fprintf(stderr, "name=%s target_specific_cpu_args=%s\n", buf_ptr(g->root_out_name), target_specific_cpu_args);
-    //fprintf(stderr, "name=%s target_specific_features=%s\n", buf_ptr(g->root_out_name), target_specific_features);
+    if (g->verbose_llvm_cpu_features) {
+        fprintf(stderr, "name=%s target_specific_cpu_args=%s\n", buf_ptr(g->root_out_name), target_specific_cpu_args);
+        fprintf(stderr, "name=%s target_specific_features=%s\n", buf_ptr(g->root_out_name), target_specific_features);
+    }
     
     g->target_machine = ZigLLVMCreateTargetMachine(target_ref, buf_ptr(&g->llvm_triple_str),
             target_specific_cpu_args, target_specific_features, opt_level, reloc_mode,

src/main.cpp

@@ -93,6 +93,7 @@ static int print_full_usage(const char *arg0, FILE *file, int return_code) {
         "  --verbose-llvm-ir            enable compiler debug output for LLVM IR\n"
         "  --verbose-cimport            enable compiler debug output for C imports\n"
         "  --verbose-cc                 enable compiler debug output for C compilation\n"
+        "  --verbose-llvm-cpu-features  enable compiler debug output for LLVM CPU features\n"
         "  -dirafter [dir]              add directory to AFTER include search path\n"
         "  -isystem [dir]               add directory to SYSTEM include search path\n"
         "  -I[dir]                      add directory to include search path\n"
@@ -398,6 +399,7 @@ int main(int argc, char **argv) {
     bool verbose_llvm_ir = false;
     bool verbose_cimport = false;
     bool verbose_cc = false;
+    bool verbose_llvm_cpu_features = false;
     bool link_eh_frame_hdr = false;
     ErrColor color = ErrColorAuto;
     CacheOpt enable_cache = CacheOptAuto;
@@ -614,6 +616,8 @@ int main(int argc, char **argv) {
                 verbose_cimport = true;
             } else if (strcmp(arg, "--verbose-cc") == 0) {
                 verbose_cc = true;
+            } else if (strcmp(arg, "--verbose-llvm-cpu-features") == 0) {
+                verbose_llvm_cpu_features = true;
             } else if (strcmp(arg, "-rdynamic") == 0) {
                 rdynamic = true;
             } else if (strcmp(arg, "--each-lib-rpath") == 0) {
@@ -1184,6 +1188,7 @@ int main(int argc, char **argv) {
             g->verbose_llvm_ir = verbose_llvm_ir;
             g->verbose_cimport = verbose_cimport;
             g->verbose_cc = verbose_cc;
+            g->verbose_llvm_cpu_features = verbose_llvm_cpu_features;
             g->output_dir = output_dir;
             g->disable_gen_h = disable_gen_h;
             g->bundle_compiler_rt = bundle_compiler_rt;