hit a comptime limitation with computing dense sets

21 files changed, 1728 insertions, 3115 deletions

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 32a9e549de..a36818fb29 100644
--- a/lib/std/build.zig
+++ b/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(",");
                             }
diff --git a/lib/std/target.zig b/lib/std/target.zig
index 2566a9be37..f5ef5802d6 100644
--- a/lib/std/target.zig
+++ b/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 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 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;
+                }
+
+                /// 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 const bit_count = 22 * 8;
+                /// 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 empty() Set {
-                    return .{ .bytes = [1]u8{0} ** 22 };
+                /// 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;
                 }
 
-                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;
+                /// 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 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;
+                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 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);
+                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), 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.addFeature(@enumToInt(feature));
+                            x.addSparseFeature(@enumToInt(feature));
                         }
                         return x;
                     }
diff --git a/lib/std/target/aarch64.zig b/lib/std/target/aarch64.zig
index 980465bb20..3ddec82298 100644
--- a/lib/std/target/aarch64.zig
+++ b/lib/std/target/aarch64.zig
@@ -153,15 +153,14 @@ pub const Feature = enum {
 pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
+    @setEvalBranchQuota(10000);
     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.a35)] = .{
-        .index = @enumToInt(Feature.a35),
-        .name = @tagName(Feature.a35),
         .llvm_name = "a35",
         .description = "Cortex-A35 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -170,11 +169,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a53)] = .{
-        .index = @enumToInt(Feature.a53),
-        .name = @tagName(Feature.a53),
         .llvm_name = "a53",
         .description = "Cortex-A53 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .balance_fp_ops,
             .crc,
             .crypto,
@@ -188,11 +185,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a55)] = .{
-        .index = @enumToInt(Feature.a55),
-        .name = @tagName(Feature.a55),
         .llvm_name = "a55",
         .description = "Cortex-A55 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crypto,
             .dotprod,
             .fp_armv8,
@@ -205,11 +200,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a57)] = .{
-        .index = @enumToInt(Feature.a57),
-        .name = @tagName(Feature.a57),
         .llvm_name = "a57",
         .description = "Cortex-A57 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .balance_fp_ops,
             .crc,
             .crypto,
@@ -224,11 +217,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a72)] = .{
-        .index = @enumToInt(Feature.a72),
-        .name = @tagName(Feature.a72),
         .llvm_name = "a72",
         .description = "Cortex-A72 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -238,11 +229,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a73)] = .{
-        .index = @enumToInt(Feature.a73),
-        .name = @tagName(Feature.a73),
         .llvm_name = "a73",
         .description = "Cortex-A73 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -252,11 +241,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a75)] = .{
-        .index = @enumToInt(Feature.a75),
-        .name = @tagName(Feature.a75),
         .llvm_name = "a75",
         .description = "Cortex-A75 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crypto,
             .dotprod,
             .fp_armv8,
@@ -269,11 +256,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.a76)] = .{
-        .index = @enumToInt(Feature.a76),
-        .name = @tagName(Feature.a76),
         .llvm_name = "a76",
         .description = "Cortex-A76 ARM processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crypto,
             .dotprod,
             .fp_armv8,
@@ -285,194 +270,142 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.aes)] = .{
-        .index = @enumToInt(Feature.aes),
-        .name = @tagName(Feature.aes),
         .llvm_name = "aes",
         .description = "Enable AES support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.aggressive_fma)] = .{
-        .index = @enumToInt(Feature.aggressive_fma),
-        .name = @tagName(Feature.aggressive_fma),
         .llvm_name = "aggressive-fma",
         .description = "Enable Aggressive FMA for floating-point.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.alternate_sextload_cvt_f32_pattern)] = .{
-        .index = @enumToInt(Feature.alternate_sextload_cvt_f32_pattern),
-        .name = @tagName(Feature.alternate_sextload_cvt_f32_pattern),
         .llvm_name = "alternate-sextload-cvt-f32-pattern",
         .description = "Use alternative pattern for sextload convert to f32",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.altnzcv)] = .{
-        .index = @enumToInt(Feature.altnzcv),
-        .name = @tagName(Feature.altnzcv),
         .llvm_name = "altnzcv",
         .description = "Enable alternative NZCV format for floating point comparisons",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.am)] = .{
-        .index = @enumToInt(Feature.am),
-        .name = @tagName(Feature.am),
         .llvm_name = "am",
         .description = "Enable v8.4-A Activity Monitors extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.arith_bcc_fusion)] = .{
-        .index = @enumToInt(Feature.arith_bcc_fusion),
-        .name = @tagName(Feature.arith_bcc_fusion),
         .llvm_name = "arith-bcc-fusion",
         .description = "CPU fuses arithmetic+bcc operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.arith_cbz_fusion)] = .{
-        .index = @enumToInt(Feature.arith_cbz_fusion),
-        .name = @tagName(Feature.arith_cbz_fusion),
         .llvm_name = "arith-cbz-fusion",
         .description = "CPU fuses arithmetic + cbz/cbnz operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.balance_fp_ops)] = .{
-        .index = @enumToInt(Feature.balance_fp_ops),
-        .name = @tagName(Feature.balance_fp_ops),
         .llvm_name = "balance-fp-ops",
         .description = "balance mix of odd and even D-registers for fp multiply(-accumulate) ops",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.bti)] = .{
-        .index = @enumToInt(Feature.bti),
-        .name = @tagName(Feature.bti),
         .llvm_name = "bti",
         .description = "Enable Branch Target Identification",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x10)] = .{
-        .index = @enumToInt(Feature.call_saved_x10),
-        .name = @tagName(Feature.call_saved_x10),
         .llvm_name = "call-saved-x10",
         .description = "Make X10 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x11)] = .{
-        .index = @enumToInt(Feature.call_saved_x11),
-        .name = @tagName(Feature.call_saved_x11),
         .llvm_name = "call-saved-x11",
         .description = "Make X11 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x12)] = .{
-        .index = @enumToInt(Feature.call_saved_x12),
-        .name = @tagName(Feature.call_saved_x12),
         .llvm_name = "call-saved-x12",
         .description = "Make X12 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x13)] = .{
-        .index = @enumToInt(Feature.call_saved_x13),
-        .name = @tagName(Feature.call_saved_x13),
         .llvm_name = "call-saved-x13",
         .description = "Make X13 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x14)] = .{
-        .index = @enumToInt(Feature.call_saved_x14),
-        .name = @tagName(Feature.call_saved_x14),
         .llvm_name = "call-saved-x14",
         .description = "Make X14 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x15)] = .{
-        .index = @enumToInt(Feature.call_saved_x15),
-        .name = @tagName(Feature.call_saved_x15),
         .llvm_name = "call-saved-x15",
         .description = "Make X15 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x18)] = .{
-        .index = @enumToInt(Feature.call_saved_x18),
-        .name = @tagName(Feature.call_saved_x18),
         .llvm_name = "call-saved-x18",
         .description = "Make X18 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x8)] = .{
-        .index = @enumToInt(Feature.call_saved_x8),
-        .name = @tagName(Feature.call_saved_x8),
         .llvm_name = "call-saved-x8",
         .description = "Make X8 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.call_saved_x9)] = .{
-        .index = @enumToInt(Feature.call_saved_x9),
-        .name = @tagName(Feature.call_saved_x9),
         .llvm_name = "call-saved-x9",
         .description = "Make X9 callee saved.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ccdp)] = .{
-        .index = @enumToInt(Feature.ccdp),
-        .name = @tagName(Feature.ccdp),
         .llvm_name = "ccdp",
         .description = "Enable v8.5 Cache Clean to Point of Deep Persistence",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ccidx)] = .{
-        .index = @enumToInt(Feature.ccidx),
-        .name = @tagName(Feature.ccidx),
         .llvm_name = "ccidx",
         .description = "Enable v8.3-A Extend of the CCSIDR number of sets",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ccpp)] = .{
-        .index = @enumToInt(Feature.ccpp),
-        .name = @tagName(Feature.ccpp),
         .llvm_name = "ccpp",
         .description = "Enable v8.2 data Cache Clean to Point of Persistence",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.complxnum)] = .{
-        .index = @enumToInt(Feature.complxnum),
-        .name = @tagName(Feature.complxnum),
         .llvm_name = "complxnum",
         .description = "Enable v8.3-A Floating-point complex number support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.crc)] = .{
-        .index = @enumToInt(Feature.crc),
-        .name = @tagName(Feature.crc),
         .llvm_name = "crc",
         .description = "Enable ARMv8 CRC-32 checksum instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.crypto)] = .{
-        .index = @enumToInt(Feature.crypto),
-        .name = @tagName(Feature.crypto),
         .llvm_name = "crypto",
         .description = "Enable cryptographic instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aes,
             .neon,
             .sha2,
         }),
     };
     result[@enumToInt(Feature.custom_cheap_as_move)] = .{
-        .index = @enumToInt(Feature.custom_cheap_as_move),
-        .name = @tagName(Feature.custom_cheap_as_move),
         .llvm_name = "custom-cheap-as-move",
         .description = "Use custom handling of cheap instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cyclone)] = .{
-        .index = @enumToInt(Feature.cyclone),
-        .name = @tagName(Feature.cyclone),
         .llvm_name = "cyclone",
         .description = "Cyclone",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .alternate_sextload_cvt_f32_pattern,
             .arith_bcc_fusion,
             .arith_cbz_fusion,
@@ -489,41 +422,31 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.disable_latency_sched_heuristic)] = .{
-        .index = @enumToInt(Feature.disable_latency_sched_heuristic),
-        .name = @tagName(Feature.disable_latency_sched_heuristic),
         .llvm_name = "disable-latency-sched-heuristic",
         .description = "Disable latency scheduling heuristic",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dit)] = .{
-        .index = @enumToInt(Feature.dit),
-        .name = @tagName(Feature.dit),
         .llvm_name = "dit",
         .description = "Enable v8.4-A Data Independent Timing instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dotprod)] = .{
-        .index = @enumToInt(Feature.dotprod),
-        .name = @tagName(Feature.dotprod),
         .llvm_name = "dotprod",
         .description = "Enable dot product support",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.exynos_cheap_as_move)] = .{
-        .index = @enumToInt(Feature.exynos_cheap_as_move),
-        .name = @tagName(Feature.exynos_cheap_as_move),
         .llvm_name = "exynos-cheap-as-move",
         .description = "Use Exynos specific handling of cheap instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .custom_cheap_as_move,
         }),
     };
     result[@enumToInt(Feature.exynosm1)] = .{
-        .index = @enumToInt(Feature.exynosm1),
-        .name = @tagName(Feature.exynosm1),
         .llvm_name = "exynosm1",
         .description = "Samsung Exynos-M1 processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .exynos_cheap_as_move,
@@ -538,11 +461,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.exynosm2)] = .{
-        .index = @enumToInt(Feature.exynosm2),
-        .name = @tagName(Feature.exynosm2),
         .llvm_name = "exynosm2",
         .description = "Samsung Exynos-M2 processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .exynos_cheap_as_move,
@@ -556,11 +477,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.exynosm3)] = .{
-        .index = @enumToInt(Feature.exynosm3),
-        .name = @tagName(Feature.exynosm3),
         .llvm_name = "exynosm3",
         .description = "Samsung Exynos-M3 processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .exynos_cheap_as_move,
@@ -577,11 +496,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.exynosm4)] = .{
-        .index = @enumToInt(Feature.exynosm4),
-        .name = @tagName(Feature.exynosm4),
         .llvm_name = "exynosm4",
         .description = "Samsung Exynos-M4 processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .arith_bcc_fusion,
             .arith_cbz_fusion,
             .crypto,
@@ -602,11 +519,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.falkor)] = .{
-        .index = @enumToInt(Feature.falkor),
-        .name = @tagName(Feature.falkor),
         .llvm_name = "falkor",
         .description = "Qualcomm Falkor processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .custom_cheap_as_move,
@@ -622,108 +537,80 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.fmi)] = .{
-        .index = @enumToInt(Feature.fmi),
-        .name = @tagName(Feature.fmi),
         .llvm_name = "fmi",
         .description = "Enable v8.4-A Flag Manipulation Instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.force_32bit_jump_tables)] = .{
-        .index = @enumToInt(Feature.force_32bit_jump_tables),
-        .name = @tagName(Feature.force_32bit_jump_tables),
         .llvm_name = "force-32bit-jump-tables",
         .description = "Force jump table entries to be 32-bits wide except at MinSize",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp_armv8)] = .{
-        .index = @enumToInt(Feature.fp_armv8),
-        .name = @tagName(Feature.fp_armv8),
         .llvm_name = "fp-armv8",
         .description = "Enable ARMv8 FP",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp16fml)] = .{
-        .index = @enumToInt(Feature.fp16fml),
-        .name = @tagName(Feature.fp16fml),
         .llvm_name = "fp16fml",
         .description = "Enable FP16 FML instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fullfp16,
         }),
     };
     result[@enumToInt(Feature.fptoint)] = .{
-        .index = @enumToInt(Feature.fptoint),
-        .name = @tagName(Feature.fptoint),
         .llvm_name = "fptoint",
         .description = "Enable FRInt[32|64][Z|X] instructions that round a floating-point number to an integer (in FP format) forcing it to fit into a 32- or 64-bit int",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fullfp16)] = .{
-        .index = @enumToInt(Feature.fullfp16),
-        .name = @tagName(Feature.fullfp16),
         .llvm_name = "fullfp16",
         .description = "Full FP16",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8,
         }),
     };
     result[@enumToInt(Feature.fuse_address)] = .{
-        .index = @enumToInt(Feature.fuse_address),
-        .name = @tagName(Feature.fuse_address),
         .llvm_name = "fuse-address",
         .description = "CPU fuses address generation and memory operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fuse_aes)] = .{
-        .index = @enumToInt(Feature.fuse_aes),
-        .name = @tagName(Feature.fuse_aes),
         .llvm_name = "fuse-aes",
         .description = "CPU fuses AES crypto operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fuse_arith_logic)] = .{
-        .index = @enumToInt(Feature.fuse_arith_logic),
-        .name = @tagName(Feature.fuse_arith_logic),
         .llvm_name = "fuse-arith-logic",
         .description = "CPU fuses arithmetic and logic operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fuse_crypto_eor)] = .{
-        .index = @enumToInt(Feature.fuse_crypto_eor),
-        .name = @tagName(Feature.fuse_crypto_eor),
         .llvm_name = "fuse-crypto-eor",
         .description = "CPU fuses AES/PMULL and EOR operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fuse_csel)] = .{
-        .index = @enumToInt(Feature.fuse_csel),
-        .name = @tagName(Feature.fuse_csel),
         .llvm_name = "fuse-csel",
         .description = "CPU fuses conditional select operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fuse_literals)] = .{
-        .index = @enumToInt(Feature.fuse_literals),
-        .name = @tagName(Feature.fuse_literals),
         .llvm_name = "fuse-literals",
         .description = "CPU fuses literal generation operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.jsconv)] = .{
-        .index = @enumToInt(Feature.jsconv),
-        .name = @tagName(Feature.jsconv),
         .llvm_name = "jsconv",
         .description = "Enable v8.3-A JavaScript FP conversion enchancement",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8,
         }),
     };
     result[@enumToInt(Feature.kryo)] = .{
-        .index = @enumToInt(Feature.kryo),
-        .name = @tagName(Feature.kryo),
         .llvm_name = "kryo",
         .description = "Qualcomm Kryo processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .custom_cheap_as_move,
@@ -737,327 +624,237 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.lor)] = .{
-        .index = @enumToInt(Feature.lor),
-        .name = @tagName(Feature.lor),
         .llvm_name = "lor",
         .description = "Enables ARM v8.1 Limited Ordering Regions extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lse)] = .{
-        .index = @enumToInt(Feature.lse),
-        .name = @tagName(Feature.lse),
         .llvm_name = "lse",
         .description = "Enable ARMv8.1 Large System Extension (LSE) atomic instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lsl_fast)] = .{
-        .index = @enumToInt(Feature.lsl_fast),
-        .name = @tagName(Feature.lsl_fast),
         .llvm_name = "lsl-fast",
         .description = "CPU has a fastpath logical shift of up to 3 places",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mpam)] = .{
-        .index = @enumToInt(Feature.mpam),
-        .name = @tagName(Feature.mpam),
         .llvm_name = "mpam",
         .description = "Enable v8.4-A Memory system Partitioning and Monitoring extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mte)] = .{
-        .index = @enumToInt(Feature.mte),
-        .name = @tagName(Feature.mte),
         .llvm_name = "mte",
         .description = "Enable Memory Tagging Extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.neon)] = .{
-        .index = @enumToInt(Feature.neon),
-        .name = @tagName(Feature.neon),
         .llvm_name = "neon",
         .description = "Enable Advanced SIMD instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8,
         }),
     };
     result[@enumToInt(Feature.no_neg_immediates)] = .{
-        .index = @enumToInt(Feature.no_neg_immediates),
-        .name = @tagName(Feature.no_neg_immediates),
         .llvm_name = "no-neg-immediates",
         .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nv)] = .{
-        .index = @enumToInt(Feature.nv),
-        .name = @tagName(Feature.nv),
         .llvm_name = "nv",
         .description = "Enable v8.4-A Nested Virtualization Enchancement",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pa)] = .{
-        .index = @enumToInt(Feature.pa),
-        .name = @tagName(Feature.pa),
         .llvm_name = "pa",
         .description = "Enable v8.3-A Pointer Authentication enchancement",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pan)] = .{
-        .index = @enumToInt(Feature.pan),
-        .name = @tagName(Feature.pan),
         .llvm_name = "pan",
         .description = "Enables ARM v8.1 Privileged Access-Never extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pan_rwv)] = .{
-        .index = @enumToInt(Feature.pan_rwv),
-        .name = @tagName(Feature.pan_rwv),
         .llvm_name = "pan-rwv",
         .description = "Enable v8.2 PAN s1e1R and s1e1W Variants",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .pan,
         }),
     };
     result[@enumToInt(Feature.perfmon)] = .{
-        .index = @enumToInt(Feature.perfmon),
-        .name = @tagName(Feature.perfmon),
         .llvm_name = "perfmon",
         .description = "Enable ARMv8 PMUv3 Performance Monitors extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.predictable_select_expensive)] = .{
-        .index = @enumToInt(Feature.predictable_select_expensive),
-        .name = @tagName(Feature.predictable_select_expensive),
         .llvm_name = "predictable-select-expensive",
         .description = "Prefer likely predicted branches over selects",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.predres)] = .{
-        .index = @enumToInt(Feature.predres),
-        .name = @tagName(Feature.predres),
         .llvm_name = "predres",
         .description = "Enable v8.5a execution and data prediction invalidation instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rand)] = .{
-        .index = @enumToInt(Feature.rand),
-        .name = @tagName(Feature.rand),
         .llvm_name = "rand",
         .description = "Enable Random Number generation instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ras)] = .{
-        .index = @enumToInt(Feature.ras),
-        .name = @tagName(Feature.ras),
         .llvm_name = "ras",
         .description = "Enable ARMv8 Reliability, Availability and Serviceability Extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rasv8_4)] = .{
-        .index = @enumToInt(Feature.rasv8_4),
-        .name = @tagName(Feature.rasv8_4),
         .llvm_name = "rasv8_4",
         .description = "Enable v8.4-A Reliability, Availability and Serviceability extension",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .ras,
         }),
     };
     result[@enumToInt(Feature.rcpc)] = .{
-        .index = @enumToInt(Feature.rcpc),
-        .name = @tagName(Feature.rcpc),
         .llvm_name = "rcpc",
         .description = "Enable support for RCPC extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rcpc_immo)] = .{
-        .index = @enumToInt(Feature.rcpc_immo),
-        .name = @tagName(Feature.rcpc_immo),
         .llvm_name = "rcpc-immo",
         .description = "Enable v8.4-A RCPC instructions with Immediate Offsets",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .rcpc,
         }),
     };
     result[@enumToInt(Feature.rdm)] = .{
-        .index = @enumToInt(Feature.rdm),
-        .name = @tagName(Feature.rdm),
         .llvm_name = "rdm",
         .description = "Enable ARMv8.1 Rounding Double Multiply Add/Subtract instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x1)] = .{
-        .index = @enumToInt(Feature.reserve_x1),
-        .name = @tagName(Feature.reserve_x1),
         .llvm_name = "reserve-x1",
         .description = "Reserve X1, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x10)] = .{
-        .index = @enumToInt(Feature.reserve_x10),
-        .name = @tagName(Feature.reserve_x10),
         .llvm_name = "reserve-x10",
         .description = "Reserve X10, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x11)] = .{
-        .index = @enumToInt(Feature.reserve_x11),
-        .name = @tagName(Feature.reserve_x11),
         .llvm_name = "reserve-x11",
         .description = "Reserve X11, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x12)] = .{
-        .index = @enumToInt(Feature.reserve_x12),
-        .name = @tagName(Feature.reserve_x12),
         .llvm_name = "reserve-x12",
         .description = "Reserve X12, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x13)] = .{
-        .index = @enumToInt(Feature.reserve_x13),
-        .name = @tagName(Feature.reserve_x13),
         .llvm_name = "reserve-x13",
         .description = "Reserve X13, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x14)] = .{
-        .index = @enumToInt(Feature.reserve_x14),
-        .name = @tagName(Feature.reserve_x14),
         .llvm_name = "reserve-x14",
         .description = "Reserve X14, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x15)] = .{
-        .index = @enumToInt(Feature.reserve_x15),
-        .name = @tagName(Feature.reserve_x15),
         .llvm_name = "reserve-x15",
         .description = "Reserve X15, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x18)] = .{
-        .index = @enumToInt(Feature.reserve_x18),
-        .name = @tagName(Feature.reserve_x18),
         .llvm_name = "reserve-x18",
         .description = "Reserve X18, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x2)] = .{
-        .index = @enumToInt(Feature.reserve_x2),
-        .name = @tagName(Feature.reserve_x2),
         .llvm_name = "reserve-x2",
         .description = "Reserve X2, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x20)] = .{
-        .index = @enumToInt(Feature.reserve_x20),
-        .name = @tagName(Feature.reserve_x20),
         .llvm_name = "reserve-x20",
         .description = "Reserve X20, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x21)] = .{
-        .index = @enumToInt(Feature.reserve_x21),
-        .name = @tagName(Feature.reserve_x21),
         .llvm_name = "reserve-x21",
         .description = "Reserve X21, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x22)] = .{
-        .index = @enumToInt(Feature.reserve_x22),
-        .name = @tagName(Feature.reserve_x22),
         .llvm_name = "reserve-x22",
         .description = "Reserve X22, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x23)] = .{
-        .index = @enumToInt(Feature.reserve_x23),
-        .name = @tagName(Feature.reserve_x23),
         .llvm_name = "reserve-x23",
         .description = "Reserve X23, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x24)] = .{
-        .index = @enumToInt(Feature.reserve_x24),
-        .name = @tagName(Feature.reserve_x24),
         .llvm_name = "reserve-x24",
         .description = "Reserve X24, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x25)] = .{
-        .index = @enumToInt(Feature.reserve_x25),
-        .name = @tagName(Feature.reserve_x25),
         .llvm_name = "reserve-x25",
         .description = "Reserve X25, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x26)] = .{
-        .index = @enumToInt(Feature.reserve_x26),
-        .name = @tagName(Feature.reserve_x26),
         .llvm_name = "reserve-x26",
         .description = "Reserve X26, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x27)] = .{
-        .index = @enumToInt(Feature.reserve_x27),
-        .name = @tagName(Feature.reserve_x27),
         .llvm_name = "reserve-x27",
         .description = "Reserve X27, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x28)] = .{
-        .index = @enumToInt(Feature.reserve_x28),
-        .name = @tagName(Feature.reserve_x28),
         .llvm_name = "reserve-x28",
         .description = "Reserve X28, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x3)] = .{
-        .index = @enumToInt(Feature.reserve_x3),
-        .name = @tagName(Feature.reserve_x3),
         .llvm_name = "reserve-x3",
         .description = "Reserve X3, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x4)] = .{
-        .index = @enumToInt(Feature.reserve_x4),
-        .name = @tagName(Feature.reserve_x4),
         .llvm_name = "reserve-x4",
         .description = "Reserve X4, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x5)] = .{
-        .index = @enumToInt(Feature.reserve_x5),
-        .name = @tagName(Feature.reserve_x5),
         .llvm_name = "reserve-x5",
         .description = "Reserve X5, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x6)] = .{
-        .index = @enumToInt(Feature.reserve_x6),
-        .name = @tagName(Feature.reserve_x6),
         .llvm_name = "reserve-x6",
         .description = "Reserve X6, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x7)] = .{
-        .index = @enumToInt(Feature.reserve_x7),
-        .name = @tagName(Feature.reserve_x7),
         .llvm_name = "reserve-x7",
         .description = "Reserve X7, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_x9)] = .{
-        .index = @enumToInt(Feature.reserve_x9),
-        .name = @tagName(Feature.reserve_x9),
         .llvm_name = "reserve-x9",
         .description = "Reserve X9, making it unavailable as a GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.saphira)] = .{
-        .index = @enumToInt(Feature.saphira),
-        .name = @tagName(Feature.saphira),
         .llvm_name = "saphira",
         .description = "Qualcomm Saphira processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crypto,
             .custom_cheap_as_move,
             .fp_armv8,
@@ -1072,157 +869,119 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.sb)] = .{
-        .index = @enumToInt(Feature.sb),
-        .name = @tagName(Feature.sb),
         .llvm_name = "sb",
         .description = "Enable v8.5 Speculation Barrier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sel2)] = .{
-        .index = @enumToInt(Feature.sel2),
-        .name = @tagName(Feature.sel2),
         .llvm_name = "sel2",
         .description = "Enable v8.4-A Secure Exception Level 2 extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sha2)] = .{
-        .index = @enumToInt(Feature.sha2),
-        .name = @tagName(Feature.sha2),
         .llvm_name = "sha2",
         .description = "Enable SHA1 and SHA256 support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.sha3)] = .{
-        .index = @enumToInt(Feature.sha3),
-        .name = @tagName(Feature.sha3),
         .llvm_name = "sha3",
         .description = "Enable SHA512 and SHA3 support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
             .sha2,
         }),
     };
     result[@enumToInt(Feature.slow_misaligned_128store)] = .{
-        .index = @enumToInt(Feature.slow_misaligned_128store),
-        .name = @tagName(Feature.slow_misaligned_128store),
         .llvm_name = "slow-misaligned-128store",
         .description = "Misaligned 128 bit stores are slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_paired_128)] = .{
-        .index = @enumToInt(Feature.slow_paired_128),
-        .name = @tagName(Feature.slow_paired_128),
         .llvm_name = "slow-paired-128",
         .description = "Paired 128 bit loads and stores are slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_strqro_store)] = .{
-        .index = @enumToInt(Feature.slow_strqro_store),
-        .name = @tagName(Feature.slow_strqro_store),
         .llvm_name = "slow-strqro-store",
         .description = "STR of Q register with register offset is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sm4)] = .{
-        .index = @enumToInt(Feature.sm4),
-        .name = @tagName(Feature.sm4),
         .llvm_name = "sm4",
         .description = "Enable SM3 and SM4 support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.spe)] = .{
-        .index = @enumToInt(Feature.spe),
-        .name = @tagName(Feature.spe),
         .llvm_name = "spe",
         .description = "Enable Statistical Profiling extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.specrestrict)] = .{
-        .index = @enumToInt(Feature.specrestrict),
-        .name = @tagName(Feature.specrestrict),
         .llvm_name = "specrestrict",
         .description = "Enable architectural speculation restriction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ssbs)] = .{
-        .index = @enumToInt(Feature.ssbs),
-        .name = @tagName(Feature.ssbs),
         .llvm_name = "ssbs",
         .description = "Enable Speculative Store Bypass Safe bit",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.strict_align)] = .{
-        .index = @enumToInt(Feature.strict_align),
-        .name = @tagName(Feature.strict_align),
         .llvm_name = "strict-align",
         .description = "Disallow all unaligned memory access",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sve)] = .{
-        .index = @enumToInt(Feature.sve),
-        .name = @tagName(Feature.sve),
         .llvm_name = "sve",
         .description = "Enable Scalable Vector Extension (SVE) instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sve2)] = .{
-        .index = @enumToInt(Feature.sve2),
-        .name = @tagName(Feature.sve2),
         .llvm_name = "sve2",
         .description = "Enable Scalable Vector Extension 2 (SVE2) instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sve,
         }),
     };
     result[@enumToInt(Feature.sve2_aes)] = .{
-        .index = @enumToInt(Feature.sve2_aes),
-        .name = @tagName(Feature.sve2_aes),
         .llvm_name = "sve2-aes",
         .description = "Enable AES SVE2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aes,
             .sve2,
         }),
     };
     result[@enumToInt(Feature.sve2_bitperm)] = .{
-        .index = @enumToInt(Feature.sve2_bitperm),
-        .name = @tagName(Feature.sve2_bitperm),
         .llvm_name = "sve2-bitperm",
         .description = "Enable bit permutation SVE2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sve2,
         }),
     };
     result[@enumToInt(Feature.sve2_sha3)] = .{
-        .index = @enumToInt(Feature.sve2_sha3),
-        .name = @tagName(Feature.sve2_sha3),
         .llvm_name = "sve2-sha3",
         .description = "Enable SHA3 SVE2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sha3,
             .sve2,
         }),
     };
     result[@enumToInt(Feature.sve2_sm4)] = .{
-        .index = @enumToInt(Feature.sve2_sm4),
-        .name = @tagName(Feature.sve2_sm4),
         .llvm_name = "sve2-sm4",
         .description = "Enable SM4 SVE2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sm4,
             .sve2,
         }),
     };
     result[@enumToInt(Feature.thunderx)] = .{
-        .index = @enumToInt(Feature.thunderx),
-        .name = @tagName(Feature.thunderx),
         .llvm_name = "thunderx",
         .description = "Cavium ThunderX processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -1233,11 +992,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.thunderx2t99)] = .{
-        .index = @enumToInt(Feature.thunderx2t99),
-        .name = @tagName(Feature.thunderx2t99),
         .llvm_name = "thunderx2t99",
         .description = "Cavium ThunderX2 processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aggressive_fma,
             .arith_bcc_fusion,
             .crc,
@@ -1251,11 +1008,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.thunderxt81)] = .{
-        .index = @enumToInt(Feature.thunderxt81),
-        .name = @tagName(Feature.thunderxt81),
         .llvm_name = "thunderxt81",
         .description = "Cavium ThunderX processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -1266,11 +1021,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.thunderxt83)] = .{
-        .index = @enumToInt(Feature.thunderxt83),
-        .name = @tagName(Feature.thunderxt83),
         .llvm_name = "thunderxt83",
         .description = "Cavium ThunderX processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -1281,11 +1034,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.thunderxt88)] = .{
-        .index = @enumToInt(Feature.thunderxt88),
-        .name = @tagName(Feature.thunderxt88),
         .llvm_name = "thunderxt88",
         .description = "Cavium ThunderX processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .fp_armv8,
@@ -1296,46 +1047,34 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.tlb_rmi)] = .{
-        .index = @enumToInt(Feature.tlb_rmi),
-        .name = @tagName(Feature.tlb_rmi),
         .llvm_name = "tlb-rmi",
         .description = "Enable v8.4-A TLB Range and Maintenance Instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tpidr_el1)] = .{
-        .index = @enumToInt(Feature.tpidr_el1),
-        .name = @tagName(Feature.tpidr_el1),
         .llvm_name = "tpidr-el1",
         .description = "Permit use of TPIDR_EL1 for the TLS base",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tpidr_el2)] = .{
-        .index = @enumToInt(Feature.tpidr_el2),
-        .name = @tagName(Feature.tpidr_el2),
         .llvm_name = "tpidr-el2",
         .description = "Permit use of TPIDR_EL2 for the TLS base",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tpidr_el3)] = .{
-        .index = @enumToInt(Feature.tpidr_el3),
-        .name = @tagName(Feature.tpidr_el3),
         .llvm_name = "tpidr-el3",
         .description = "Permit use of TPIDR_EL3 for the TLS base",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tracev8_4)] = .{
-        .index = @enumToInt(Feature.tracev8_4),
-        .name = @tagName(Feature.tracev8_4),
         .llvm_name = "tracev8.4",
         .description = "Enable v8.4-A Trace extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tsv110)] = .{
-        .index = @enumToInt(Feature.tsv110),
-        .name = @tagName(Feature.tsv110),
         .llvm_name = "tsv110",
         .description = "HiSilicon TS-V110 processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crypto,
             .custom_cheap_as_move,
             .dotprod,
@@ -1351,39 +1090,29 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.uaops)] = .{
-        .index = @enumToInt(Feature.uaops),
-        .name = @tagName(Feature.uaops),
         .llvm_name = "uaops",
         .description = "Enable v8.2 UAO PState",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_aa)] = .{
-        .index = @enumToInt(Feature.use_aa),
-        .name = @tagName(Feature.use_aa),
         .llvm_name = "use-aa",
         .description = "Use alias analysis during codegen",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_postra_scheduler)] = .{
-        .index = @enumToInt(Feature.use_postra_scheduler),
-        .name = @tagName(Feature.use_postra_scheduler),
         .llvm_name = "use-postra-scheduler",
         .description = "Schedule again after register allocation",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_reciprocal_square_root)] = .{
-        .index = @enumToInt(Feature.use_reciprocal_square_root),
-        .name = @tagName(Feature.use_reciprocal_square_root),
         .llvm_name = "use-reciprocal-square-root",
         .description = "Use the reciprocal square root approximation",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v8_1a)] = .{
-        .index = @enumToInt(Feature.v8_1a),
-        .name = @tagName(Feature.v8_1a),
         .llvm_name = "v8.1a",
         .description = "Support ARM v8.1a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .lor,
             .lse,
@@ -1393,11 +1122,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.v8_2a)] = .{
-        .index = @enumToInt(Feature.v8_2a),
-        .name = @tagName(Feature.v8_2a),
         .llvm_name = "v8.2a",
         .description = "Support ARM v8.2a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .ccpp,
             .pan_rwv,
             .ras,
@@ -1406,11 +1133,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.v8_3a)] = .{
-        .index = @enumToInt(Feature.v8_3a),
-        .name = @tagName(Feature.v8_3a),
         .llvm_name = "v8.3a",
         .description = "Support ARM v8.3a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .ccidx,
             .complxnum,
             .jsconv,
@@ -1420,11 +1145,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.v8_4a)] = .{
-        .index = @enumToInt(Feature.v8_4a),
-        .name = @tagName(Feature.v8_4a),
         .llvm_name = "v8.4a",
         .description = "Support ARM v8.4a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .am,
             .dit,
             .dotprod,
@@ -1440,11 +1163,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.v8_5a)] = .{
-        .index = @enumToInt(Feature.v8_5a),
-        .name = @tagName(Feature.v8_5a),
         .llvm_name = "v8.5a",
         .description = "Support ARM v8.5a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .altnzcv,
             .bti,
             .ccdp,
@@ -1457,50 +1178,44 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.vh)] = .{
-        .index = @enumToInt(Feature.vh),
-        .name = @tagName(Feature.vh),
         .llvm_name = "vh",
         .description = "Enables ARM v8.1 Virtual Host extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.zcm)] = .{
-        .index = @enumToInt(Feature.zcm),
-        .name = @tagName(Feature.zcm),
         .llvm_name = "zcm",
         .description = "Has zero-cycle register moves",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.zcz)] = .{
-        .index = @enumToInt(Feature.zcz),
-        .name = @tagName(Feature.zcz),
         .llvm_name = "zcz",
         .description = "Has zero-cycle zeroing instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .zcz_fp,
             .zcz_gp,
         }),
     };
     result[@enumToInt(Feature.zcz_fp)] = .{
-        .index = @enumToInt(Feature.zcz_fp),
-        .name = @tagName(Feature.zcz_fp),
         .llvm_name = "zcz-fp",
         .description = "Has zero-cycle zeroing instructions for FP registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.zcz_fp_workaround)] = .{
-        .index = @enumToInt(Feature.zcz_fp_workaround),
-        .name = @tagName(Feature.zcz_fp_workaround),
         .llvm_name = "zcz-fp-workaround",
         .description = "The zero-cycle floating-point zeroing instruction has a bug",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.zcz_gp)] = .{
-        .index = @enumToInt(Feature.zcz_gp),
-        .name = @tagName(Feature.zcz_gp),
         .llvm_name = "zcz-gp",
         .description = "Has zero-cycle zeroing instructions for generic registers",
-        .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;
 };
 
@@ -1508,126 +1223,126 @@ pub const cpu = struct {
     pub const apple_latest = Cpu{
         .name = "apple_latest",
         .llvm_name = "apple-latest",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cyclone,
         }),
     };
     pub const cortex_a35 = Cpu{
         .name = "cortex_a35",
         .llvm_name = "cortex-a35",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a35,
         }),
     };
     pub const cortex_a53 = Cpu{
         .name = "cortex_a53",
         .llvm_name = "cortex-a53",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a53,
         }),
     };
     pub const cortex_a55 = Cpu{
         .name = "cortex_a55",
         .llvm_name = "cortex-a55",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a55,
         }),
     };
     pub const cortex_a57 = Cpu{
         .name = "cortex_a57",
         .llvm_name = "cortex-a57",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a57,
         }),
     };
     pub const cortex_a72 = Cpu{
         .name = "cortex_a72",
         .llvm_name = "cortex-a72",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a72,
         }),
     };
     pub const cortex_a73 = Cpu{
         .name = "cortex_a73",
         .llvm_name = "cortex-a73",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a73,
         }),
     };
     pub const cortex_a75 = Cpu{
         .name = "cortex_a75",
         .llvm_name = "cortex-a75",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a75,
         }),
     };
     pub const cortex_a76 = Cpu{
         .name = "cortex_a76",
         .llvm_name = "cortex-a76",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a76,
         }),
     };
     pub const cortex_a76ae = Cpu{
         .name = "cortex_a76ae",
         .llvm_name = "cortex-a76ae",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a76,
         }),
     };
     pub const cyclone = Cpu{
         .name = "cyclone",
         .llvm_name = "cyclone",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cyclone,
         }),
     };
     pub const exynos_m1 = Cpu{
         .name = "exynos_m1",
         .llvm_name = "exynos-m1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .exynosm1,
         }),
     };
     pub const exynos_m2 = Cpu{
         .name = "exynos_m2",
         .llvm_name = "exynos-m2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .exynosm2,
         }),
     };
     pub const exynos_m3 = Cpu{
         .name = "exynos_m3",
         .llvm_name = "exynos-m3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .exynosm3,
         }),
     };
     pub const exynos_m4 = Cpu{
         .name = "exynos_m4",
         .llvm_name = "exynos-m4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .exynosm4,
         }),
     };
     pub const exynos_m5 = Cpu{
         .name = "exynos_m5",
         .llvm_name = "exynos-m5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .exynosm4,
         }),
     };
     pub const falkor = Cpu{
         .name = "falkor",
         .llvm_name = "falkor",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .falkor,
         }),
     };
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .fp_armv8,
             .fuse_aes,
             .neon,
@@ -1638,56 +1353,56 @@ pub const cpu = struct {
     pub const kryo = Cpu{
         .name = "kryo",
         .llvm_name = "kryo",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .kryo,
         }),
     };
     pub const saphira = Cpu{
         .name = "saphira",
         .llvm_name = "saphira",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .saphira,
         }),
     };
     pub const thunderx = Cpu{
         .name = "thunderx",
         .llvm_name = "thunderx",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .thunderx,
         }),
     };
     pub const thunderx2t99 = Cpu{
         .name = "thunderx2t99",
         .llvm_name = "thunderx2t99",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .thunderx2t99,
         }),
     };
     pub const thunderxt81 = Cpu{
         .name = "thunderxt81",
         .llvm_name = "thunderxt81",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .thunderxt81,
         }),
     };
     pub const thunderxt83 = Cpu{
         .name = "thunderxt83",
         .llvm_name = "thunderxt83",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .thunderxt83,
         }),
     };
     pub const thunderxt88 = Cpu{
         .name = "thunderxt88",
         .llvm_name = "thunderxt88",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .thunderxt88,
         }),
     };
     pub const tsv110 = Cpu{
         .name = "tsv110",
         .llvm_name = "tsv110",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .tsv110,
         }),
     };
diff --git a/lib/std/target/amdgpu.zig b/lib/std/target/amdgpu.zig
index b1953ca83e..54bd073c2c 100644
--- a/lib/std/target/amdgpu.zig
+++ b/lib/std/target/amdgpu.zig
@@ -114,281 +114,206 @@ pub const Feature = enum {
 pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
+    @setEvalBranchQuota(10000);
     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.@"16_bit_insts")] = .{
-        .index = @enumToInt(Feature.@"16_bit_insts"),
-        .name = @tagName(Feature.@"16_bit_insts"),
         .llvm_name = "16-bit-insts",
         .description = "Has i16/f16 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.DumpCode)] = .{
-        .index = @enumToInt(Feature.DumpCode),
-        .name = @tagName(Feature.DumpCode),
         .llvm_name = "DumpCode",
         .description = "Dump MachineInstrs in the CodeEmitter",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.add_no_carry_insts)] = .{
-        .index = @enumToInt(Feature.add_no_carry_insts),
-        .name = @tagName(Feature.add_no_carry_insts),
         .llvm_name = "add-no-carry-insts",
         .description = "Have VALU add/sub instructions without carry out",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.aperture_regs)] = .{
-        .index = @enumToInt(Feature.aperture_regs),
-        .name = @tagName(Feature.aperture_regs),
         .llvm_name = "aperture-regs",
         .description = "Has Memory Aperture Base and Size Registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.atomic_fadd_insts)] = .{
-        .index = @enumToInt(Feature.atomic_fadd_insts),
-        .name = @tagName(Feature.atomic_fadd_insts),
         .llvm_name = "atomic-fadd-insts",
         .description = "Has buffer_atomic_add_f32, buffer_atomic_pk_add_f16, global_atomic_add_f32, global_atomic_pk_add_f16 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.auto_waitcnt_before_barrier)] = .{
-        .index = @enumToInt(Feature.auto_waitcnt_before_barrier),
-        .name = @tagName(Feature.auto_waitcnt_before_barrier),
         .llvm_name = "auto-waitcnt-before-barrier",
         .description = "Hardware automatically inserts waitcnt before barrier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ci_insts)] = .{
-        .index = @enumToInt(Feature.ci_insts),
-        .name = @tagName(Feature.ci_insts),
         .llvm_name = "ci-insts",
         .description = "Additional instructions for CI+",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.code_object_v3)] = .{
-        .index = @enumToInt(Feature.code_object_v3),
-        .name = @tagName(Feature.code_object_v3),
         .llvm_name = "code-object-v3",
         .description = "Generate code object version 3",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cumode)] = .{
-        .index = @enumToInt(Feature.cumode),
-        .name = @tagName(Feature.cumode),
         .llvm_name = "cumode",
         .description = "Enable CU wavefront execution mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dl_insts)] = .{
-        .index = @enumToInt(Feature.dl_insts),
-        .name = @tagName(Feature.dl_insts),
         .llvm_name = "dl-insts",
         .description = "Has v_fmac_f32 and v_xnor_b32 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dot1_insts)] = .{
-        .index = @enumToInt(Feature.dot1_insts),
-        .name = @tagName(Feature.dot1_insts),
         .llvm_name = "dot1-insts",
         .description = "Has v_dot4_i32_i8 and v_dot8_i32_i4 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dot2_insts)] = .{
-        .index = @enumToInt(Feature.dot2_insts),
-        .name = @tagName(Feature.dot2_insts),
         .llvm_name = "dot2-insts",
         .description = "Has v_dot2_f32_f16, v_dot2_i32_i16, v_dot2_u32_u16, v_dot4_u32_u8, v_dot8_u32_u4 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dot3_insts)] = .{
-        .index = @enumToInt(Feature.dot3_insts),
-        .name = @tagName(Feature.dot3_insts),
         .llvm_name = "dot3-insts",
         .description = "Has v_dot8c_i32_i4 instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dot4_insts)] = .{
-        .index = @enumToInt(Feature.dot4_insts),
-        .name = @tagName(Feature.dot4_insts),
         .llvm_name = "dot4-insts",
         .description = "Has v_dot2c_i32_i16 instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dot5_insts)] = .{
-        .index = @enumToInt(Feature.dot5_insts),
-        .name = @tagName(Feature.dot5_insts),
         .llvm_name = "dot5-insts",
         .description = "Has v_dot2c_f32_f16 instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dot6_insts)] = .{
-        .index = @enumToInt(Feature.dot6_insts),
-        .name = @tagName(Feature.dot6_insts),
         .llvm_name = "dot6-insts",
         .description = "Has v_dot4c_i32_i8 instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dpp)] = .{
-        .index = @enumToInt(Feature.dpp),
-        .name = @tagName(Feature.dpp),
         .llvm_name = "dpp",
         .description = "Support DPP (Data Parallel Primitives) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dpp8)] = .{
-        .index = @enumToInt(Feature.dpp8),
-        .name = @tagName(Feature.dpp8),
         .llvm_name = "dpp8",
         .description = "Support DPP8 (Data Parallel Primitives) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dumpcode)] = .{
-        .index = @enumToInt(Feature.dumpcode),
-        .name = @tagName(Feature.dumpcode),
         .llvm_name = "dumpcode",
         .description = "Dump MachineInstrs in the CodeEmitter",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.enable_ds128)] = .{
-        .index = @enumToInt(Feature.enable_ds128),
-        .name = @tagName(Feature.enable_ds128),
         .llvm_name = "enable-ds128",
         .description = "Use ds_read|write_b128",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.enable_prt_strict_null)] = .{
-        .index = @enumToInt(Feature.enable_prt_strict_null),
-        .name = @tagName(Feature.enable_prt_strict_null),
         .llvm_name = "enable-prt-strict-null",
         .description = "Enable zeroing of result registers for sparse texture fetches",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_fmaf)] = .{
-        .index = @enumToInt(Feature.fast_fmaf),
-        .name = @tagName(Feature.fast_fmaf),
         .llvm_name = "fast-fmaf",
         .description = "Assuming f32 fma is at least as fast as mul + add",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.flat_address_space)] = .{
-        .index = @enumToInt(Feature.flat_address_space),
-        .name = @tagName(Feature.flat_address_space),
         .llvm_name = "flat-address-space",
         .description = "Support flat address space",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.flat_for_global)] = .{
-        .index = @enumToInt(Feature.flat_for_global),
-        .name = @tagName(Feature.flat_for_global),
         .llvm_name = "flat-for-global",
         .description = "Force to generate flat instruction for global",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.flat_global_insts)] = .{
-        .index = @enumToInt(Feature.flat_global_insts),
-        .name = @tagName(Feature.flat_global_insts),
         .llvm_name = "flat-global-insts",
         .description = "Have global_* flat memory instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.flat_inst_offsets)] = .{
-        .index = @enumToInt(Feature.flat_inst_offsets),
-        .name = @tagName(Feature.flat_inst_offsets),
         .llvm_name = "flat-inst-offsets",
         .description = "Flat instructions have immediate offset addressing mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.flat_scratch_insts)] = .{
-        .index = @enumToInt(Feature.flat_scratch_insts),
-        .name = @tagName(Feature.flat_scratch_insts),
         .llvm_name = "flat-scratch-insts",
         .description = "Have scratch_* flat memory instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.flat_segment_offset_bug)] = .{
-        .index = @enumToInt(Feature.flat_segment_offset_bug),
-        .name = @tagName(Feature.flat_segment_offset_bug),
         .llvm_name = "flat-segment-offset-bug",
         .description = "GFX10 bug, inst_offset ignored in flat segment",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fma_mix_insts)] = .{
-        .index = @enumToInt(Feature.fma_mix_insts),
-        .name = @tagName(Feature.fma_mix_insts),
         .llvm_name = "fma-mix-insts",
         .description = "Has v_fma_mix_f32, v_fma_mixlo_f16, v_fma_mixhi_f16 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fmaf)] = .{
-        .index = @enumToInt(Feature.fmaf),
-        .name = @tagName(Feature.fmaf),
         .llvm_name = "fmaf",
         .description = "Enable single precision FMA (not as fast as mul+add, but fused)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp_exceptions)] = .{
-        .index = @enumToInt(Feature.fp_exceptions),
-        .name = @tagName(Feature.fp_exceptions),
         .llvm_name = "fp-exceptions",
         .description = "Enable floating point exceptions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp16_denormals)] = .{
-        .index = @enumToInt(Feature.fp16_denormals),
-        .name = @tagName(Feature.fp16_denormals),
         .llvm_name = "fp16-denormals",
         .description = "Enable half precision denormal handling",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64_fp16_denormals,
         }),
     };
     result[@enumToInt(Feature.fp32_denormals)] = .{
-        .index = @enumToInt(Feature.fp32_denormals),
-        .name = @tagName(Feature.fp32_denormals),
         .llvm_name = "fp32-denormals",
         .description = "Enable single precision denormal handling",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp64)] = .{
-        .index = @enumToInt(Feature.fp64),
-        .name = @tagName(Feature.fp64),
         .llvm_name = "fp64",
         .description = "Enable double precision operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp64_denormals)] = .{
-        .index = @enumToInt(Feature.fp64_denormals),
-        .name = @tagName(Feature.fp64_denormals),
         .llvm_name = "fp64-denormals",
         .description = "Enable double and half precision denormal handling",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64,
             .fp64_fp16_denormals,
         }),
     };
     result[@enumToInt(Feature.fp64_fp16_denormals)] = .{
-        .index = @enumToInt(Feature.fp64_fp16_denormals),
-        .name = @tagName(Feature.fp64_fp16_denormals),
         .llvm_name = "fp64-fp16-denormals",
         .description = "Enable double and half precision denormal handling",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64,
         }),
     };
     result[@enumToInt(Feature.gcn3_encoding)] = .{
-        .index = @enumToInt(Feature.gcn3_encoding),
-        .name = @tagName(Feature.gcn3_encoding),
         .llvm_name = "gcn3-encoding",
         .description = "Encoding format for VI",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.gfx10)] = .{
-        .index = @enumToInt(Feature.gfx10),
-        .name = @tagName(Feature.gfx10),
         .llvm_name = "gfx10",
         .description = "GFX10 GPU generation",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"16_bit_insts",
             .add_no_carry_insts,
             .aperture_regs,
@@ -426,32 +351,24 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.gfx10_insts)] = .{
-        .index = @enumToInt(Feature.gfx10_insts),
-        .name = @tagName(Feature.gfx10_insts),
         .llvm_name = "gfx10-insts",
         .description = "Additional instructions for GFX10+",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.gfx7_gfx8_gfx9_insts)] = .{
-        .index = @enumToInt(Feature.gfx7_gfx8_gfx9_insts),
-        .name = @tagName(Feature.gfx7_gfx8_gfx9_insts),
         .llvm_name = "gfx7-gfx8-gfx9-insts",
         .description = "Instructions shared in GFX7, GFX8, GFX9",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.gfx8_insts)] = .{
-        .index = @enumToInt(Feature.gfx8_insts),
-        .name = @tagName(Feature.gfx8_insts),
         .llvm_name = "gfx8-insts",
         .description = "Additional instructions for GFX8+",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.gfx9)] = .{
-        .index = @enumToInt(Feature.gfx9),
-        .name = @tagName(Feature.gfx9),
         .llvm_name = "gfx9",
         .description = "GFX9 GPU generation",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"16_bit_insts",
             .add_no_carry_insts,
             .aperture_regs,
@@ -485,298 +402,214 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.gfx9_insts)] = .{
-        .index = @enumToInt(Feature.gfx9_insts),
-        .name = @tagName(Feature.gfx9_insts),
         .llvm_name = "gfx9-insts",
         .description = "Additional instructions for GFX9+",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.half_rate_64_ops)] = .{
-        .index = @enumToInt(Feature.half_rate_64_ops),
-        .name = @tagName(Feature.half_rate_64_ops),
         .llvm_name = "half-rate-64-ops",
         .description = "Most fp64 instructions are half rate instead of quarter",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.inst_fwd_prefetch_bug)] = .{
-        .index = @enumToInt(Feature.inst_fwd_prefetch_bug),
-        .name = @tagName(Feature.inst_fwd_prefetch_bug),
         .llvm_name = "inst-fwd-prefetch-bug",
         .description = "S_INST_PREFETCH instruction causes shader to hang",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.int_clamp_insts)] = .{
-        .index = @enumToInt(Feature.int_clamp_insts),
-        .name = @tagName(Feature.int_clamp_insts),
         .llvm_name = "int-clamp-insts",
         .description = "Support clamp for integer destination",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.inv_2pi_inline_imm)] = .{
-        .index = @enumToInt(Feature.inv_2pi_inline_imm),
-        .name = @tagName(Feature.inv_2pi_inline_imm),
         .llvm_name = "inv-2pi-inline-imm",
         .description = "Has 1 / (2 * pi) as inline immediate",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lds_branch_vmem_war_hazard)] = .{
-        .index = @enumToInt(Feature.lds_branch_vmem_war_hazard),
-        .name = @tagName(Feature.lds_branch_vmem_war_hazard),
         .llvm_name = "lds-branch-vmem-war-hazard",
         .description = "Switching between LDS and VMEM-tex not waiting VM_VSRC=0",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lds_misaligned_bug)] = .{
-        .index = @enumToInt(Feature.lds_misaligned_bug),
-        .name = @tagName(Feature.lds_misaligned_bug),
         .llvm_name = "lds-misaligned-bug",
         .description = "Some GFX10 bug with misaligned multi-dword LDS access in WGP mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ldsbankcount16)] = .{
-        .index = @enumToInt(Feature.ldsbankcount16),
-        .name = @tagName(Feature.ldsbankcount16),
         .llvm_name = "ldsbankcount16",
         .description = "The number of LDS banks per compute unit.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ldsbankcount32)] = .{
-        .index = @enumToInt(Feature.ldsbankcount32),
-        .name = @tagName(Feature.ldsbankcount32),
         .llvm_name = "ldsbankcount32",
         .description = "The number of LDS banks per compute unit.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.load_store_opt)] = .{
-        .index = @enumToInt(Feature.load_store_opt),
-        .name = @tagName(Feature.load_store_opt),
         .llvm_name = "load-store-opt",
         .description = "Enable SI load/store optimizer pass",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.localmemorysize0)] = .{
-        .index = @enumToInt(Feature.localmemorysize0),
-        .name = @tagName(Feature.localmemorysize0),
         .llvm_name = "localmemorysize0",
         .description = "The size of local memory in bytes",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.localmemorysize32768)] = .{
-        .index = @enumToInt(Feature.localmemorysize32768),
-        .name = @tagName(Feature.localmemorysize32768),
         .llvm_name = "localmemorysize32768",
         .description = "The size of local memory in bytes",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.localmemorysize65536)] = .{
-        .index = @enumToInt(Feature.localmemorysize65536),
-        .name = @tagName(Feature.localmemorysize65536),
         .llvm_name = "localmemorysize65536",
         .description = "The size of local memory in bytes",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mad_mix_insts)] = .{
-        .index = @enumToInt(Feature.mad_mix_insts),
-        .name = @tagName(Feature.mad_mix_insts),
         .llvm_name = "mad-mix-insts",
         .description = "Has v_mad_mix_f32, v_mad_mixlo_f16, v_mad_mixhi_f16 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mai_insts)] = .{
-        .index = @enumToInt(Feature.mai_insts),
-        .name = @tagName(Feature.mai_insts),
         .llvm_name = "mai-insts",
         .description = "Has mAI instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.max_private_element_size_16)] = .{
-        .index = @enumToInt(Feature.max_private_element_size_16),
-        .name = @tagName(Feature.max_private_element_size_16),
         .llvm_name = "max-private-element-size-16",
         .description = "Maximum private access size may be 16",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.max_private_element_size_4)] = .{
-        .index = @enumToInt(Feature.max_private_element_size_4),
-        .name = @tagName(Feature.max_private_element_size_4),
         .llvm_name = "max-private-element-size-4",
         .description = "Maximum private access size may be 4",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.max_private_element_size_8)] = .{
-        .index = @enumToInt(Feature.max_private_element_size_8),
-        .name = @tagName(Feature.max_private_element_size_8),
         .llvm_name = "max-private-element-size-8",
         .description = "Maximum private access size may be 8",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mimg_r128)] = .{
-        .index = @enumToInt(Feature.mimg_r128),
-        .name = @tagName(Feature.mimg_r128),
         .llvm_name = "mimg-r128",
         .description = "Support 128-bit texture resources",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.movrel)] = .{
-        .index = @enumToInt(Feature.movrel),
-        .name = @tagName(Feature.movrel),
         .llvm_name = "movrel",
         .description = "Has v_movrel*_b32 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_data_dep_hazard)] = .{
-        .index = @enumToInt(Feature.no_data_dep_hazard),
-        .name = @tagName(Feature.no_data_dep_hazard),
         .llvm_name = "no-data-dep-hazard",
         .description = "Does not need SW waitstates",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_sdst_cmpx)] = .{
-        .index = @enumToInt(Feature.no_sdst_cmpx),
-        .name = @tagName(Feature.no_sdst_cmpx),
         .llvm_name = "no-sdst-cmpx",
         .description = "V_CMPX does not write VCC/SGPR in addition to EXEC",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_sram_ecc_support)] = .{
-        .index = @enumToInt(Feature.no_sram_ecc_support),
-        .name = @tagName(Feature.no_sram_ecc_support),
         .llvm_name = "no-sram-ecc-support",
         .description = "Hardware does not support SRAM ECC",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_xnack_support)] = .{
-        .index = @enumToInt(Feature.no_xnack_support),
-        .name = @tagName(Feature.no_xnack_support),
         .llvm_name = "no-xnack-support",
         .description = "Hardware does not support XNACK",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nsa_encoding)] = .{
-        .index = @enumToInt(Feature.nsa_encoding),
-        .name = @tagName(Feature.nsa_encoding),
         .llvm_name = "nsa-encoding",
         .description = "Support NSA encoding for image instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nsa_to_vmem_bug)] = .{
-        .index = @enumToInt(Feature.nsa_to_vmem_bug),
-        .name = @tagName(Feature.nsa_to_vmem_bug),
         .llvm_name = "nsa-to-vmem-bug",
         .description = "MIMG-NSA followed by VMEM fail if EXEC_LO or EXEC_HI equals zero",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.offset_3f_bug)] = .{
-        .index = @enumToInt(Feature.offset_3f_bug),
-        .name = @tagName(Feature.offset_3f_bug),
         .llvm_name = "offset-3f-bug",
         .description = "Branch offset of 3f hardware bug",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pk_fmac_f16_inst)] = .{
-        .index = @enumToInt(Feature.pk_fmac_f16_inst),
-        .name = @tagName(Feature.pk_fmac_f16_inst),
         .llvm_name = "pk-fmac-f16-inst",
         .description = "Has v_pk_fmac_f16 instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.promote_alloca)] = .{
-        .index = @enumToInt(Feature.promote_alloca),
-        .name = @tagName(Feature.promote_alloca),
         .llvm_name = "promote-alloca",
         .description = "Enable promote alloca pass",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.r128_a16)] = .{
-        .index = @enumToInt(Feature.r128_a16),
-        .name = @tagName(Feature.r128_a16),
         .llvm_name = "r128-a16",
         .description = "Support 16 bit coordindates/gradients/lod/clamp/mip types on gfx9",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.register_banking)] = .{
-        .index = @enumToInt(Feature.register_banking),
-        .name = @tagName(Feature.register_banking),
         .llvm_name = "register-banking",
         .description = "Has register banking",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.s_memrealtime)] = .{
-        .index = @enumToInt(Feature.s_memrealtime),
-        .name = @tagName(Feature.s_memrealtime),
         .llvm_name = "s-memrealtime",
         .description = "Has s_memrealtime instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.scalar_atomics)] = .{
-        .index = @enumToInt(Feature.scalar_atomics),
-        .name = @tagName(Feature.scalar_atomics),
         .llvm_name = "scalar-atomics",
         .description = "Has atomic scalar memory instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.scalar_flat_scratch_insts)] = .{
-        .index = @enumToInt(Feature.scalar_flat_scratch_insts),
-        .name = @tagName(Feature.scalar_flat_scratch_insts),
         .llvm_name = "scalar-flat-scratch-insts",
         .description = "Have s_scratch_* flat memory instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.scalar_stores)] = .{
-        .index = @enumToInt(Feature.scalar_stores),
-        .name = @tagName(Feature.scalar_stores),
         .llvm_name = "scalar-stores",
         .description = "Has store scalar memory instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sdwa)] = .{
-        .index = @enumToInt(Feature.sdwa),
-        .name = @tagName(Feature.sdwa),
         .llvm_name = "sdwa",
         .description = "Support SDWA (Sub-DWORD Addressing) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sdwa_mav)] = .{
-        .index = @enumToInt(Feature.sdwa_mav),
-        .name = @tagName(Feature.sdwa_mav),
         .llvm_name = "sdwa-mav",
         .description = "Support v_mac_f32/f16 with SDWA (Sub-DWORD Addressing) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sdwa_omod)] = .{
-        .index = @enumToInt(Feature.sdwa_omod),
-        .name = @tagName(Feature.sdwa_omod),
         .llvm_name = "sdwa-omod",
         .description = "Support OMod with SDWA (Sub-DWORD Addressing) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sdwa_out_mods_vopc)] = .{
-        .index = @enumToInt(Feature.sdwa_out_mods_vopc),
-        .name = @tagName(Feature.sdwa_out_mods_vopc),
         .llvm_name = "sdwa-out-mods-vopc",
         .description = "Support clamp for VOPC with SDWA (Sub-DWORD Addressing) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sdwa_scalar)] = .{
-        .index = @enumToInt(Feature.sdwa_scalar),
-        .name = @tagName(Feature.sdwa_scalar),
         .llvm_name = "sdwa-scalar",
         .description = "Support scalar register with SDWA (Sub-DWORD Addressing) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sdwa_sdst)] = .{
-        .index = @enumToInt(Feature.sdwa_sdst),
-        .name = @tagName(Feature.sdwa_sdst),
         .llvm_name = "sdwa-sdst",
         .description = "Support scalar dst for VOPC with SDWA (Sub-DWORD Addressing) extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sea_islands)] = .{
-        .index = @enumToInt(Feature.sea_islands),
-        .name = @tagName(Feature.sea_islands),
         .llvm_name = "sea-islands",
         .description = "SEA_ISLANDS GPU generation",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .ci_insts,
             .flat_address_space,
             .fp64,
@@ -790,32 +623,24 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.sgpr_init_bug)] = .{
-        .index = @enumToInt(Feature.sgpr_init_bug),
-        .name = @tagName(Feature.sgpr_init_bug),
         .llvm_name = "sgpr-init-bug",
         .description = "VI SGPR initialization bug requiring a fixed SGPR allocation size",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.si_scheduler)] = .{
-        .index = @enumToInt(Feature.si_scheduler),
-        .name = @tagName(Feature.si_scheduler),
         .llvm_name = "si-scheduler",
         .description = "Enable SI Machine Scheduler",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.smem_to_vector_write_hazard)] = .{
-        .index = @enumToInt(Feature.smem_to_vector_write_hazard),
-        .name = @tagName(Feature.smem_to_vector_write_hazard),
         .llvm_name = "smem-to-vector-write-hazard",
         .description = "s_load_dword followed by v_cmp page faults",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.southern_islands)] = .{
-        .index = @enumToInt(Feature.southern_islands),
-        .name = @tagName(Feature.southern_islands),
         .llvm_name = "southern-islands",
         .description = "SOUTHERN_ISLANDS GPU generation",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64,
             .ldsbankcount32,
             .localmemorysize32768,
@@ -828,88 +653,64 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.sram_ecc)] = .{
-        .index = @enumToInt(Feature.sram_ecc),
-        .name = @tagName(Feature.sram_ecc),
         .llvm_name = "sram-ecc",
         .description = "Enable SRAM ECC",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.trap_handler)] = .{
-        .index = @enumToInt(Feature.trap_handler),
-        .name = @tagName(Feature.trap_handler),
         .llvm_name = "trap-handler",
         .description = "Trap handler support",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.trig_reduced_range)] = .{
-        .index = @enumToInt(Feature.trig_reduced_range),
-        .name = @tagName(Feature.trig_reduced_range),
         .llvm_name = "trig-reduced-range",
         .description = "Requires use of fract on arguments to trig instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.unaligned_buffer_access)] = .{
-        .index = @enumToInt(Feature.unaligned_buffer_access),
-        .name = @tagName(Feature.unaligned_buffer_access),
         .llvm_name = "unaligned-buffer-access",
         .description = "Support unaligned global loads and stores",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.unaligned_scratch_access)] = .{
-        .index = @enumToInt(Feature.unaligned_scratch_access),
-        .name = @tagName(Feature.unaligned_scratch_access),
         .llvm_name = "unaligned-scratch-access",
         .description = "Support unaligned scratch loads and stores",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.unpacked_d16_vmem)] = .{
-        .index = @enumToInt(Feature.unpacked_d16_vmem),
-        .name = @tagName(Feature.unpacked_d16_vmem),
         .llvm_name = "unpacked-d16-vmem",
         .description = "Has unpacked d16 vmem instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.unsafe_ds_offset_folding)] = .{
-        .index = @enumToInt(Feature.unsafe_ds_offset_folding),
-        .name = @tagName(Feature.unsafe_ds_offset_folding),
         .llvm_name = "unsafe-ds-offset-folding",
         .description = "Force using DS instruction immediate offsets on SI",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vcmpx_exec_war_hazard)] = .{
-        .index = @enumToInt(Feature.vcmpx_exec_war_hazard),
-        .name = @tagName(Feature.vcmpx_exec_war_hazard),
         .llvm_name = "vcmpx-exec-war-hazard",
         .description = "V_CMPX WAR hazard on EXEC (V_CMPX issue ONLY)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vcmpx_permlane_hazard)] = .{
-        .index = @enumToInt(Feature.vcmpx_permlane_hazard),
-        .name = @tagName(Feature.vcmpx_permlane_hazard),
         .llvm_name = "vcmpx-permlane-hazard",
         .description = "TODO: describe me",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vgpr_index_mode)] = .{
-        .index = @enumToInt(Feature.vgpr_index_mode),
-        .name = @tagName(Feature.vgpr_index_mode),
         .llvm_name = "vgpr-index-mode",
         .description = "Has VGPR mode register indexing",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vmem_to_scalar_write_hazard)] = .{
-        .index = @enumToInt(Feature.vmem_to_scalar_write_hazard),
-        .name = @tagName(Feature.vmem_to_scalar_write_hazard),
         .llvm_name = "vmem-to-scalar-write-hazard",
         .description = "VMEM instruction followed by scalar writing to EXEC mask, M0 or SGPR leads to incorrect execution.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.volcanic_islands)] = .{
-        .index = @enumToInt(Feature.volcanic_islands),
-        .name = @tagName(Feature.volcanic_islands),
         .llvm_name = "volcanic-islands",
         .description = "VOLCANIC_ISLANDS GPU generation",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"16_bit_insts",
             .ci_insts,
             .dpp,
@@ -935,54 +736,46 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.vop3_literal)] = .{
-        .index = @enumToInt(Feature.vop3_literal),
-        .name = @tagName(Feature.vop3_literal),
         .llvm_name = "vop3-literal",
         .description = "Can use one literal in VOP3",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vop3p)] = .{
-        .index = @enumToInt(Feature.vop3p),
-        .name = @tagName(Feature.vop3p),
         .llvm_name = "vop3p",
         .description = "Has VOP3P packed instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vscnt)] = .{
-        .index = @enumToInt(Feature.vscnt),
-        .name = @tagName(Feature.vscnt),
         .llvm_name = "vscnt",
         .description = "Has separate store vscnt counter",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.wavefrontsize16)] = .{
-        .index = @enumToInt(Feature.wavefrontsize16),
-        .name = @tagName(Feature.wavefrontsize16),
         .llvm_name = "wavefrontsize16",
         .description = "The number of threads per wavefront",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.wavefrontsize32)] = .{
-        .index = @enumToInt(Feature.wavefrontsize32),
-        .name = @tagName(Feature.wavefrontsize32),
         .llvm_name = "wavefrontsize32",
         .description = "The number of threads per wavefront",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.wavefrontsize64)] = .{
-        .index = @enumToInt(Feature.wavefrontsize64),
-        .name = @tagName(Feature.wavefrontsize64),
         .llvm_name = "wavefrontsize64",
         .description = "The number of threads per wavefront",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xnack)] = .{
-        .index = @enumToInt(Feature.xnack),
-        .name = @tagName(Feature.xnack),
         .llvm_name = "xnack",
         .description = "Enable XNACK support",
-        .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;
 };
 
@@ -990,7 +783,7 @@ pub const cpu = struct {
     pub const bonaire = Cpu{
         .name = "bonaire",
         .llvm_name = "bonaire",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1000,7 +793,7 @@ pub const cpu = struct {
     pub const carrizo = Cpu{
         .name = "carrizo",
         .llvm_name = "carrizo",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .half_rate_64_ops,
@@ -1013,7 +806,7 @@ pub const cpu = struct {
     pub const fiji = Cpu{
         .name = "fiji",
         .llvm_name = "fiji",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1024,14 +817,14 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .wavefrontsize64,
         }),
     };
     pub const generic_hsa = Cpu{
         .name = "generic_hsa",
         .llvm_name = "generic-hsa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .flat_address_space,
             .wavefrontsize64,
         }),
@@ -1039,7 +832,7 @@ pub const cpu = struct {
     pub const gfx1010 = Cpu{
         .name = "gfx1010",
         .llvm_name = "gfx1010",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .dl_insts,
             .flat_segment_offset_bug,
@@ -1065,7 +858,7 @@ pub const cpu = struct {
     pub const gfx1011 = Cpu{
         .name = "gfx1011",
         .llvm_name = "gfx1011",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .dl_insts,
             .dot1_insts,
@@ -1094,7 +887,7 @@ pub const cpu = struct {
     pub const gfx1012 = Cpu{
         .name = "gfx1012",
         .llvm_name = "gfx1012",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .dl_insts,
             .dot1_insts,
@@ -1124,7 +917,7 @@ pub const cpu = struct {
     pub const gfx600 = Cpu{
         .name = "gfx600",
         .llvm_name = "gfx600",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .half_rate_64_ops,
@@ -1136,7 +929,7 @@ pub const cpu = struct {
     pub const gfx601 = Cpu{
         .name = "gfx601",
         .llvm_name = "gfx601",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1146,7 +939,7 @@ pub const cpu = struct {
     pub const gfx700 = Cpu{
         .name = "gfx700",
         .llvm_name = "gfx700",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1156,7 +949,7 @@ pub const cpu = struct {
     pub const gfx701 = Cpu{
         .name = "gfx701",
         .llvm_name = "gfx701",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .half_rate_64_ops,
@@ -1168,7 +961,7 @@ pub const cpu = struct {
     pub const gfx702 = Cpu{
         .name = "gfx702",
         .llvm_name = "gfx702",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .ldsbankcount16,
@@ -1179,7 +972,7 @@ pub const cpu = struct {
     pub const gfx703 = Cpu{
         .name = "gfx703",
         .llvm_name = "gfx703",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount16,
             .no_xnack_support,
@@ -1189,7 +982,7 @@ pub const cpu = struct {
     pub const gfx704 = Cpu{
         .name = "gfx704",
         .llvm_name = "gfx704",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1199,7 +992,7 @@ pub const cpu = struct {
     pub const gfx801 = Cpu{
         .name = "gfx801",
         .llvm_name = "gfx801",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .half_rate_64_ops,
@@ -1212,7 +1005,7 @@ pub const cpu = struct {
     pub const gfx802 = Cpu{
         .name = "gfx802",
         .llvm_name = "gfx802",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1224,7 +1017,7 @@ pub const cpu = struct {
     pub const gfx803 = Cpu{
         .name = "gfx803",
         .llvm_name = "gfx803",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1235,7 +1028,7 @@ pub const cpu = struct {
     pub const gfx810 = Cpu{
         .name = "gfx810",
         .llvm_name = "gfx810",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount16,
             .volcanic_islands,
@@ -1245,7 +1038,7 @@ pub const cpu = struct {
     pub const gfx900 = Cpu{
         .name = "gfx900",
         .llvm_name = "gfx900",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .gfx9,
             .ldsbankcount32,
@@ -1257,7 +1050,7 @@ pub const cpu = struct {
     pub const gfx902 = Cpu{
         .name = "gfx902",
         .llvm_name = "gfx902",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .gfx9,
             .ldsbankcount32,
@@ -1269,7 +1062,7 @@ pub const cpu = struct {
     pub const gfx904 = Cpu{
         .name = "gfx904",
         .llvm_name = "gfx904",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fma_mix_insts,
             .gfx9,
@@ -1281,7 +1074,7 @@ pub const cpu = struct {
     pub const gfx906 = Cpu{
         .name = "gfx906",
         .llvm_name = "gfx906",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .dl_insts,
             .dot1_insts,
@@ -1296,7 +1089,7 @@ pub const cpu = struct {
     pub const gfx908 = Cpu{
         .name = "gfx908",
         .llvm_name = "gfx908",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .atomic_fadd_insts,
             .code_object_v3,
             .dl_insts,
@@ -1318,7 +1111,7 @@ pub const cpu = struct {
     pub const gfx909 = Cpu{
         .name = "gfx909",
         .llvm_name = "gfx909",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .gfx9,
             .ldsbankcount32,
@@ -1329,7 +1122,7 @@ pub const cpu = struct {
     pub const hainan = Cpu{
         .name = "hainan",
         .llvm_name = "hainan",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1339,7 +1132,7 @@ pub const cpu = struct {
     pub const hawaii = Cpu{
         .name = "hawaii",
         .llvm_name = "hawaii",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .half_rate_64_ops,
@@ -1351,7 +1144,7 @@ pub const cpu = struct {
     pub const iceland = Cpu{
         .name = "iceland",
         .llvm_name = "iceland",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1363,7 +1156,7 @@ pub const cpu = struct {
     pub const kabini = Cpu{
         .name = "kabini",
         .llvm_name = "kabini",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount16,
             .no_xnack_support,
@@ -1373,7 +1166,7 @@ pub const cpu = struct {
     pub const kaveri = Cpu{
         .name = "kaveri",
         .llvm_name = "kaveri",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1383,7 +1176,7 @@ pub const cpu = struct {
     pub const mullins = Cpu{
         .name = "mullins",
         .llvm_name = "mullins",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount16,
             .no_xnack_support,
@@ -1393,7 +1186,7 @@ pub const cpu = struct {
     pub const oland = Cpu{
         .name = "oland",
         .llvm_name = "oland",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1403,7 +1196,7 @@ pub const cpu = struct {
     pub const pitcairn = Cpu{
         .name = "pitcairn",
         .llvm_name = "pitcairn",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1413,7 +1206,7 @@ pub const cpu = struct {
     pub const polaris10 = Cpu{
         .name = "polaris10",
         .llvm_name = "polaris10",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1424,7 +1217,7 @@ pub const cpu = struct {
     pub const polaris11 = Cpu{
         .name = "polaris11",
         .llvm_name = "polaris11",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1435,7 +1228,7 @@ pub const cpu = struct {
     pub const stoney = Cpu{
         .name = "stoney",
         .llvm_name = "stoney",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount16,
             .volcanic_islands,
@@ -1445,7 +1238,7 @@ pub const cpu = struct {
     pub const tahiti = Cpu{
         .name = "tahiti",
         .llvm_name = "tahiti",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .fast_fmaf,
             .half_rate_64_ops,
@@ -1457,7 +1250,7 @@ pub const cpu = struct {
     pub const tonga = Cpu{
         .name = "tonga",
         .llvm_name = "tonga",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
@@ -1469,7 +1262,7 @@ pub const cpu = struct {
     pub const verde = Cpu{
         .name = "verde",
         .llvm_name = "verde",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .code_object_v3,
             .ldsbankcount32,
             .no_xnack_support,
diff --git a/lib/std/target/arm.zig b/lib/std/target/arm.zig
index 744d418d03..bcc04ae884 100644
--- a/lib/std/target/arm.zig
+++ b/lib/std/target/arm.zig
@@ -181,245 +181,182 @@ pub const Feature = enum {
 pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
+    @setEvalBranchQuota(10000);
     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.@"32bit")] = .{
-        .index = @enumToInt(Feature.@"32bit"),
-        .name = @tagName(Feature.@"32bit"),
         .llvm_name = "32bit",
         .description = "Prefer 32-bit Thumb instrs",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.@"8msecext")] = .{
-        .index = @enumToInt(Feature.@"8msecext"),
-        .name = @tagName(Feature.@"8msecext"),
         .llvm_name = "8msecext",
         .description = "Enable support for ARMv8-M Security Extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a12)] = .{
-        .index = @enumToInt(Feature.a12),
-        .name = @tagName(Feature.a12),
         .llvm_name = "a12",
         .description = "Cortex-A12 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a15)] = .{
-        .index = @enumToInt(Feature.a15),
-        .name = @tagName(Feature.a15),
         .llvm_name = "a15",
         .description = "Cortex-A15 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a17)] = .{
-        .index = @enumToInt(Feature.a17),
-        .name = @tagName(Feature.a17),
         .llvm_name = "a17",
         .description = "Cortex-A17 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a32)] = .{
-        .index = @enumToInt(Feature.a32),
-        .name = @tagName(Feature.a32),
         .llvm_name = "a32",
         .description = "Cortex-A32 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a35)] = .{
-        .index = @enumToInt(Feature.a35),
-        .name = @tagName(Feature.a35),
         .llvm_name = "a35",
         .description = "Cortex-A35 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a5)] = .{
-        .index = @enumToInt(Feature.a5),
-        .name = @tagName(Feature.a5),
         .llvm_name = "a5",
         .description = "Cortex-A5 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a53)] = .{
-        .index = @enumToInt(Feature.a53),
-        .name = @tagName(Feature.a53),
         .llvm_name = "a53",
         .description = "Cortex-A53 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a55)] = .{
-        .index = @enumToInt(Feature.a55),
-        .name = @tagName(Feature.a55),
         .llvm_name = "a55",
         .description = "Cortex-A55 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a57)] = .{
-        .index = @enumToInt(Feature.a57),
-        .name = @tagName(Feature.a57),
         .llvm_name = "a57",
         .description = "Cortex-A57 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a7)] = .{
-        .index = @enumToInt(Feature.a7),
-        .name = @tagName(Feature.a7),
         .llvm_name = "a7",
         .description = "Cortex-A7 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a72)] = .{
-        .index = @enumToInt(Feature.a72),
-        .name = @tagName(Feature.a72),
         .llvm_name = "a72",
         .description = "Cortex-A72 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a73)] = .{
-        .index = @enumToInt(Feature.a73),
-        .name = @tagName(Feature.a73),
         .llvm_name = "a73",
         .description = "Cortex-A73 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a75)] = .{
-        .index = @enumToInt(Feature.a75),
-        .name = @tagName(Feature.a75),
         .llvm_name = "a75",
         .description = "Cortex-A75 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a76)] = .{
-        .index = @enumToInt(Feature.a76),
-        .name = @tagName(Feature.a76),
         .llvm_name = "a76",
         .description = "Cortex-A76 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a8)] = .{
-        .index = @enumToInt(Feature.a8),
-        .name = @tagName(Feature.a8),
         .llvm_name = "a8",
         .description = "Cortex-A8 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.a9)] = .{
-        .index = @enumToInt(Feature.a9),
-        .name = @tagName(Feature.a9),
         .llvm_name = "a9",
         .description = "Cortex-A9 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.aclass)] = .{
-        .index = @enumToInt(Feature.aclass),
-        .name = @tagName(Feature.aclass),
         .llvm_name = "aclass",
         .description = "Is application profile ('A' series)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.acquire_release)] = .{
-        .index = @enumToInt(Feature.acquire_release),
-        .name = @tagName(Feature.acquire_release),
         .llvm_name = "acquire-release",
         .description = "Has v8 acquire/release (lda/ldaex  etc) instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.aes)] = .{
-        .index = @enumToInt(Feature.aes),
-        .name = @tagName(Feature.aes),
         .llvm_name = "aes",
         .description = "Enable AES support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.armv2)] = .{
-        .index = @enumToInt(Feature.armv2),
-        .name = @tagName(Feature.armv2),
         .llvm_name = "armv2",
         .description = "ARMv2 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.armv2a)] = .{
-        .index = @enumToInt(Feature.armv2a),
-        .name = @tagName(Feature.armv2a),
         .llvm_name = "armv2a",
         .description = "ARMv2a architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.armv3)] = .{
-        .index = @enumToInt(Feature.armv3),
-        .name = @tagName(Feature.armv3),
         .llvm_name = "armv3",
         .description = "ARMv3 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.armv3m)] = .{
-        .index = @enumToInt(Feature.armv3m),
-        .name = @tagName(Feature.armv3m),
         .llvm_name = "armv3m",
         .description = "ARMv3m architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.armv4)] = .{
-        .index = @enumToInt(Feature.armv4),
-        .name = @tagName(Feature.armv4),
         .llvm_name = "armv4",
         .description = "ARMv4 architecture",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.armv4t)] = .{
-        .index = @enumToInt(Feature.armv4t),
-        .name = @tagName(Feature.armv4t),
         .llvm_name = "armv4t",
         .description = "ARMv4t architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v4t,
         }),
     };
     result[@enumToInt(Feature.armv5t)] = .{
-        .index = @enumToInt(Feature.armv5t),
-        .name = @tagName(Feature.armv5t),
         .llvm_name = "armv5t",
         .description = "ARMv5t architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v5t,
         }),
     };
     result[@enumToInt(Feature.armv5te)] = .{
-        .index = @enumToInt(Feature.armv5te),
-        .name = @tagName(Feature.armv5te),
         .llvm_name = "armv5te",
         .description = "ARMv5te architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v5te,
         }),
     };
     result[@enumToInt(Feature.armv5tej)] = .{
-        .index = @enumToInt(Feature.armv5tej),
-        .name = @tagName(Feature.armv5tej),
         .llvm_name = "armv5tej",
         .description = "ARMv5tej architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v5te,
         }),
     };
     result[@enumToInt(Feature.armv6)] = .{
-        .index = @enumToInt(Feature.armv6),
-        .name = @tagName(Feature.armv6),
         .llvm_name = "armv6",
         .description = "ARMv6 architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dsp,
             .v6,
         }),
     };
     result[@enumToInt(Feature.armv6_m)] = .{
-        .index = @enumToInt(Feature.armv6_m),
-        .name = @tagName(Feature.armv6_m),
         .llvm_name = "armv6-m",
         .description = "ARMv6m architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .db,
             .mclass,
             .noarm,
@@ -429,39 +366,31 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv6j)] = .{
-        .index = @enumToInt(Feature.armv6j),
-        .name = @tagName(Feature.armv6j),
         .llvm_name = "armv6j",
         .description = "ARMv7a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .armv6,
         }),
     };
     result[@enumToInt(Feature.armv6k)] = .{
-        .index = @enumToInt(Feature.armv6k),
-        .name = @tagName(Feature.armv6k),
         .llvm_name = "armv6k",
         .description = "ARMv6k architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v6k,
         }),
     };
     result[@enumToInt(Feature.armv6kz)] = .{
-        .index = @enumToInt(Feature.armv6kz),
-        .name = @tagName(Feature.armv6kz),
         .llvm_name = "armv6kz",
         .description = "ARMv6kz architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .trustzone,
             .v6k,
         }),
     };
     result[@enumToInt(Feature.armv6s_m)] = .{
-        .index = @enumToInt(Feature.armv6s_m),
-        .name = @tagName(Feature.armv6s_m),
         .llvm_name = "armv6s-m",
         .description = "ARMv6sm architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .db,
             .mclass,
             .noarm,
@@ -471,21 +400,17 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv6t2)] = .{
-        .index = @enumToInt(Feature.armv6t2),
-        .name = @tagName(Feature.armv6t2),
         .llvm_name = "armv6t2",
         .description = "ARMv6t2 architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dsp,
             .v6t2,
         }),
     };
     result[@enumToInt(Feature.armv7_a)] = .{
-        .index = @enumToInt(Feature.armv7_a),
-        .name = @tagName(Feature.armv7_a),
         .llvm_name = "armv7-a",
         .description = "ARMv7a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .db,
             .dsp,
@@ -494,11 +419,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv7_m)] = .{
-        .index = @enumToInt(Feature.armv7_m),
-        .name = @tagName(Feature.armv7_m),
         .llvm_name = "armv7-m",
         .description = "ARMv7m architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .db,
             .hwdiv,
             .mclass,
@@ -509,11 +432,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv7_r)] = .{
-        .index = @enumToInt(Feature.armv7_r),
-        .name = @tagName(Feature.armv7_r),
         .llvm_name = "armv7-r",
         .description = "ARMv7r architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .db,
             .dsp,
             .hwdiv,
@@ -522,11 +443,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv7e_m)] = .{
-        .index = @enumToInt(Feature.armv7e_m),
-        .name = @tagName(Feature.armv7e_m),
         .llvm_name = "armv7e-m",
         .description = "ARMv7em architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .db,
             .dsp,
             .hwdiv,
@@ -538,29 +457,23 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv7k)] = .{
-        .index = @enumToInt(Feature.armv7k),
-        .name = @tagName(Feature.armv7k),
         .llvm_name = "armv7k",
         .description = "ARMv7a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .armv7_a,
         }),
     };
     result[@enumToInt(Feature.armv7s)] = .{
-        .index = @enumToInt(Feature.armv7s),
-        .name = @tagName(Feature.armv7s),
         .llvm_name = "armv7s",
         .description = "ARMv7a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .armv7_a,
         }),
     };
     result[@enumToInt(Feature.armv7ve)] = .{
-        .index = @enumToInt(Feature.armv7ve),
-        .name = @tagName(Feature.armv7ve),
         .llvm_name = "armv7ve",
         .description = "ARMv7ve architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .db,
             .dsp,
@@ -572,11 +485,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_a)] = .{
-        .index = @enumToInt(Feature.armv8_a),
-        .name = @tagName(Feature.armv8_a),
         .llvm_name = "armv8-a",
         .description = "ARMv8a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .crc,
             .crypto,
@@ -591,11 +502,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_m_base)] = .{
-        .index = @enumToInt(Feature.armv8_m_base),
-        .name = @tagName(Feature.armv8_m_base),
         .llvm_name = "armv8-m.base",
         .description = "ARMv8mBaseline architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"8msecext",
             .acquire_release,
             .db,
@@ -609,11 +518,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_m_main)] = .{
-        .index = @enumToInt(Feature.armv8_m_main),
-        .name = @tagName(Feature.armv8_m_main),
         .llvm_name = "armv8-m.main",
         .description = "ARMv8mMainline architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"8msecext",
             .acquire_release,
             .db,
@@ -625,11 +532,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_r)] = .{
-        .index = @enumToInt(Feature.armv8_r),
-        .name = @tagName(Feature.armv8_r),
         .llvm_name = "armv8-r",
         .description = "ARMv8r architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .db,
             .dfb,
@@ -643,11 +548,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_1_a)] = .{
-        .index = @enumToInt(Feature.armv8_1_a),
-        .name = @tagName(Feature.armv8_1_a),
         .llvm_name = "armv8.1-a",
         .description = "ARMv81a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .crc,
             .crypto,
@@ -662,11 +565,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_1_m_main)] = .{
-        .index = @enumToInt(Feature.armv8_1_m_main),
-        .name = @tagName(Feature.armv8_1_m_main),
         .llvm_name = "armv8.1-m.main",
         .description = "ARMv81mMainline architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"8msecext",
             .acquire_release,
             .db,
@@ -680,11 +581,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_2_a)] = .{
-        .index = @enumToInt(Feature.armv8_2_a),
-        .name = @tagName(Feature.armv8_2_a),
         .llvm_name = "armv8.2-a",
         .description = "ARMv82a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .crc,
             .crypto,
@@ -700,11 +599,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_3_a)] = .{
-        .index = @enumToInt(Feature.armv8_3_a),
-        .name = @tagName(Feature.armv8_3_a),
         .llvm_name = "armv8.3-a",
         .description = "ARMv83a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .crc,
             .crypto,
@@ -720,11 +617,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_4_a)] = .{
-        .index = @enumToInt(Feature.armv8_4_a),
-        .name = @tagName(Feature.armv8_4_a),
         .llvm_name = "armv8.4-a",
         .description = "ARMv84a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .crc,
             .crypto,
@@ -741,11 +636,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.armv8_5_a)] = .{
-        .index = @enumToInt(Feature.armv8_5_a),
-        .name = @tagName(Feature.armv8_5_a),
         .llvm_name = "armv8.5-a",
         .description = "ARMv85a architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aclass,
             .crc,
             .crypto,
@@ -762,115 +655,85 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.avoid_movs_shop)] = .{
-        .index = @enumToInt(Feature.avoid_movs_shop),
-        .name = @tagName(Feature.avoid_movs_shop),
         .llvm_name = "avoid-movs-shop",
         .description = "Avoid movs instructions with shifter operand",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.avoid_partial_cpsr)] = .{
-        .index = @enumToInt(Feature.avoid_partial_cpsr),
-        .name = @tagName(Feature.avoid_partial_cpsr),
         .llvm_name = "avoid-partial-cpsr",
         .description = "Avoid CPSR partial update for OOO execution",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cheap_predicable_cpsr)] = .{
-        .index = @enumToInt(Feature.cheap_predicable_cpsr),
-        .name = @tagName(Feature.cheap_predicable_cpsr),
         .llvm_name = "cheap-predicable-cpsr",
         .description = "Disable +1 predication cost for instructions updating CPSR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.crc)] = .{
-        .index = @enumToInt(Feature.crc),
-        .name = @tagName(Feature.crc),
         .llvm_name = "crc",
         .description = "Enable support for CRC instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.crypto)] = .{
-        .index = @enumToInt(Feature.crypto),
-        .name = @tagName(Feature.crypto),
         .llvm_name = "crypto",
         .description = "Enable support for Cryptography extensions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aes,
             .neon,
             .sha2,
         }),
     };
     result[@enumToInt(Feature.d32)] = .{
-        .index = @enumToInt(Feature.d32),
-        .name = @tagName(Feature.d32),
         .llvm_name = "d32",
         .description = "Extend FP to 32 double registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.db)] = .{
-        .index = @enumToInt(Feature.db),
-        .name = @tagName(Feature.db),
         .llvm_name = "db",
         .description = "Has data barrier (dmb/dsb) instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dfb)] = .{
-        .index = @enumToInt(Feature.dfb),
-        .name = @tagName(Feature.dfb),
         .llvm_name = "dfb",
         .description = "Has full data barrier (dfb) instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.disable_postra_scheduler)] = .{
-        .index = @enumToInt(Feature.disable_postra_scheduler),
-        .name = @tagName(Feature.disable_postra_scheduler),
         .llvm_name = "disable-postra-scheduler",
         .description = "Don't schedule again after register allocation",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dont_widen_vmovs)] = .{
-        .index = @enumToInt(Feature.dont_widen_vmovs),
-        .name = @tagName(Feature.dont_widen_vmovs),
         .llvm_name = "dont-widen-vmovs",
         .description = "Don't widen VMOVS to VMOVD",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.dotprod)] = .{
-        .index = @enumToInt(Feature.dotprod),
-        .name = @tagName(Feature.dotprod),
         .llvm_name = "dotprod",
         .description = "Enable support for dot product instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.dsp)] = .{
-        .index = @enumToInt(Feature.dsp),
-        .name = @tagName(Feature.dsp),
         .llvm_name = "dsp",
         .description = "Supports DSP instructions in ARM and/or Thumb2",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.execute_only)] = .{
-        .index = @enumToInt(Feature.execute_only),
-        .name = @tagName(Feature.execute_only),
         .llvm_name = "execute-only",
         .description = "Enable the generation of execute only code.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.expand_fp_mlx)] = .{
-        .index = @enumToInt(Feature.expand_fp_mlx),
-        .name = @tagName(Feature.expand_fp_mlx),
         .llvm_name = "expand-fp-mlx",
         .description = "Expand VFP/NEON MLA/MLS instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.exynos)] = .{
-        .index = @enumToInt(Feature.exynos),
-        .name = @tagName(Feature.exynos),
         .llvm_name = "exynos",
         .description = "Samsung Exynos processors",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .crc,
             .crypto,
             .expand_fp_mlx,
@@ -891,229 +754,173 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.fp_armv8)] = .{
-        .index = @enumToInt(Feature.fp_armv8),
-        .name = @tagName(Feature.fp_armv8),
         .llvm_name = "fp-armv8",
         .description = "Enable ARMv8 FP",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8d16,
             .fp_armv8sp,
             .vfp4,
         }),
     };
     result[@enumToInt(Feature.fp_armv8d16)] = .{
-        .index = @enumToInt(Feature.fp_armv8d16),
-        .name = @tagName(Feature.fp_armv8d16),
         .llvm_name = "fp-armv8d16",
         .description = "Enable ARMv8 FP with only 16 d-registers",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8d16sp,
             .fp64,
             .vfp4d16,
         }),
     };
     result[@enumToInt(Feature.fp_armv8d16sp)] = .{
-        .index = @enumToInt(Feature.fp_armv8d16sp),
-        .name = @tagName(Feature.fp_armv8d16sp),
         .llvm_name = "fp-armv8d16sp",
         .description = "Enable ARMv8 FP with only 16 d-registers and no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vfp4d16sp,
         }),
     };
     result[@enumToInt(Feature.fp_armv8sp)] = .{
-        .index = @enumToInt(Feature.fp_armv8sp),
-        .name = @tagName(Feature.fp_armv8sp),
         .llvm_name = "fp-armv8sp",
         .description = "Enable ARMv8 FP with no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .d32,
             .fp_armv8d16sp,
             .vfp4sp,
         }),
     };
     result[@enumToInt(Feature.fp16)] = .{
-        .index = @enumToInt(Feature.fp16),
-        .name = @tagName(Feature.fp16),
         .llvm_name = "fp16",
         .description = "Enable half-precision floating point",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fp16fml)] = .{
-        .index = @enumToInt(Feature.fp16fml),
-        .name = @tagName(Feature.fp16fml),
         .llvm_name = "fp16fml",
         .description = "Enable full half-precision floating point fml instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fullfp16,
         }),
     };
     result[@enumToInt(Feature.fp64)] = .{
-        .index = @enumToInt(Feature.fp64),
-        .name = @tagName(Feature.fp64),
         .llvm_name = "fp64",
         .description = "Floating point unit supports double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpregs64,
         }),
     };
     result[@enumToInt(Feature.fpao)] = .{
-        .index = @enumToInt(Feature.fpao),
-        .name = @tagName(Feature.fpao),
         .llvm_name = "fpao",
         .description = "Enable fast computation of positive address offsets",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fpregs)] = .{
-        .index = @enumToInt(Feature.fpregs),
-        .name = @tagName(Feature.fpregs),
         .llvm_name = "fpregs",
         .description = "Enable FP registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fpregs16)] = .{
-        .index = @enumToInt(Feature.fpregs16),
-        .name = @tagName(Feature.fpregs16),
         .llvm_name = "fpregs16",
         .description = "Enable 16-bit FP registers",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpregs,
         }),
     };
     result[@enumToInt(Feature.fpregs64)] = .{
-        .index = @enumToInt(Feature.fpregs64),
-        .name = @tagName(Feature.fpregs64),
         .llvm_name = "fpregs64",
         .description = "Enable 64-bit FP registers",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpregs,
         }),
     };
     result[@enumToInt(Feature.fullfp16)] = .{
-        .index = @enumToInt(Feature.fullfp16),
-        .name = @tagName(Feature.fullfp16),
         .llvm_name = "fullfp16",
         .description = "Enable full half-precision floating point",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8d16sp,
             .fpregs16,
         }),
     };
     result[@enumToInt(Feature.fuse_aes)] = .{
-        .index = @enumToInt(Feature.fuse_aes),
-        .name = @tagName(Feature.fuse_aes),
         .llvm_name = "fuse-aes",
         .description = "CPU fuses AES crypto operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fuse_literals)] = .{
-        .index = @enumToInt(Feature.fuse_literals),
-        .name = @tagName(Feature.fuse_literals),
         .llvm_name = "fuse-literals",
         .description = "CPU fuses literal generation operations",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hwdiv)] = .{
-        .index = @enumToInt(Feature.hwdiv),
-        .name = @tagName(Feature.hwdiv),
         .llvm_name = "hwdiv",
         .description = "Enable divide instructions in Thumb",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.hwdiv_arm)] = .{
-        .index = @enumToInt(Feature.hwdiv_arm),
-        .name = @tagName(Feature.hwdiv_arm),
         .llvm_name = "hwdiv-arm",
         .description = "Enable divide instructions in ARM mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.iwmmxt)] = .{
-        .index = @enumToInt(Feature.iwmmxt),
-        .name = @tagName(Feature.iwmmxt),
         .llvm_name = "iwmmxt",
         .description = "ARMv5te architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .armv5te,
         }),
     };
     result[@enumToInt(Feature.iwmmxt2)] = .{
-        .index = @enumToInt(Feature.iwmmxt2),
-        .name = @tagName(Feature.iwmmxt2),
         .llvm_name = "iwmmxt2",
         .description = "ARMv5te architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .armv5te,
         }),
     };
     result[@enumToInt(Feature.krait)] = .{
-        .index = @enumToInt(Feature.krait),
-        .name = @tagName(Feature.krait),
         .llvm_name = "krait",
         .description = "Qualcomm Krait processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.kryo)] = .{
-        .index = @enumToInt(Feature.kryo),
-        .name = @tagName(Feature.kryo),
         .llvm_name = "kryo",
         .description = "Qualcomm Kryo processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lob)] = .{
-        .index = @enumToInt(Feature.lob),
-        .name = @tagName(Feature.lob),
         .llvm_name = "lob",
         .description = "Enable Low Overhead Branch extensions",
-        .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 = "Generate calls via indirect call instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.loop_align)] = .{
-        .index = @enumToInt(Feature.loop_align),
-        .name = @tagName(Feature.loop_align),
         .llvm_name = "loop-align",
         .description = "Prefer 32-bit alignment for loops",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.m3)] = .{
-        .index = @enumToInt(Feature.m3),
-        .name = @tagName(Feature.m3),
         .llvm_name = "m3",
         .description = "Cortex-M3 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mclass)] = .{
-        .index = @enumToInt(Feature.mclass),
-        .name = @tagName(Feature.mclass),
         .llvm_name = "mclass",
         .description = "Is microcontroller profile ('M' series)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mp)] = .{
-        .index = @enumToInt(Feature.mp),
-        .name = @tagName(Feature.mp),
         .llvm_name = "mp",
         .description = "Supports Multiprocessing extension",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.muxed_units)] = .{
-        .index = @enumToInt(Feature.muxed_units),
-        .name = @tagName(Feature.muxed_units),
         .llvm_name = "muxed-units",
         .description = "Has muxed AGU and NEON/FPU",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mve)] = .{
-        .index = @enumToInt(Feature.mve),
-        .name = @tagName(Feature.mve),
         .llvm_name = "mve",
         .description = "Support M-Class Vector Extension with integer ops",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dsp,
             .fpregs16,
             .fpregs64,
@@ -1121,544 +928,410 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.mve_fp)] = .{
-        .index = @enumToInt(Feature.mve_fp),
-        .name = @tagName(Feature.mve_fp),
         .llvm_name = "mve.fp",
         .description = "Support M-Class Vector Extension with integer and floating ops",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp_armv8d16sp,
             .fullfp16,
             .mve,
         }),
     };
     result[@enumToInt(Feature.nacl_trap)] = .{
-        .index = @enumToInt(Feature.nacl_trap),
-        .name = @tagName(Feature.nacl_trap),
         .llvm_name = "nacl-trap",
         .description = "NaCl trap",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.neon)] = .{
-        .index = @enumToInt(Feature.neon),
-        .name = @tagName(Feature.neon),
         .llvm_name = "neon",
         .description = "Enable NEON instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vfp3,
         }),
     };
     result[@enumToInt(Feature.neon_fpmovs)] = .{
-        .index = @enumToInt(Feature.neon_fpmovs),
-        .name = @tagName(Feature.neon_fpmovs),
         .llvm_name = "neon-fpmovs",
         .description = "Convert VMOVSR, VMOVRS, VMOVS to NEON",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.neonfp)] = .{
-        .index = @enumToInt(Feature.neonfp),
-        .name = @tagName(Feature.neonfp),
         .llvm_name = "neonfp",
         .description = "Use NEON for single precision FP",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_branch_predictor)] = .{
-        .index = @enumToInt(Feature.no_branch_predictor),
-        .name = @tagName(Feature.no_branch_predictor),
         .llvm_name = "no-branch-predictor",
         .description = "Has no branch predictor",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_movt)] = .{
-        .index = @enumToInt(Feature.no_movt),
-        .name = @tagName(Feature.no_movt),
         .llvm_name = "no-movt",
         .description = "Don't use movt/movw pairs for 32-bit imms",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.no_neg_immediates)] = .{
-        .index = @enumToInt(Feature.no_neg_immediates),
-        .name = @tagName(Feature.no_neg_immediates),
         .llvm_name = "no-neg-immediates",
         .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.noarm)] = .{
-        .index = @enumToInt(Feature.noarm),
-        .name = @tagName(Feature.noarm),
         .llvm_name = "noarm",
         .description = "Does not support ARM mode execution",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nonpipelined_vfp)] = .{
-        .index = @enumToInt(Feature.nonpipelined_vfp),
-        .name = @tagName(Feature.nonpipelined_vfp),
         .llvm_name = "nonpipelined-vfp",
         .description = "VFP instructions are not pipelined",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.perfmon)] = .{
-        .index = @enumToInt(Feature.perfmon),
-        .name = @tagName(Feature.perfmon),
         .llvm_name = "perfmon",
         .description = "Enable support for Performance Monitor extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.prefer_ishst)] = .{
-        .index = @enumToInt(Feature.prefer_ishst),
-        .name = @tagName(Feature.prefer_ishst),
         .llvm_name = "prefer-ishst",
         .description = "Prefer ISHST barriers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.prefer_vmovsr)] = .{
-        .index = @enumToInt(Feature.prefer_vmovsr),
-        .name = @tagName(Feature.prefer_vmovsr),
         .llvm_name = "prefer-vmovsr",
         .description = "Prefer VMOVSR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.prof_unpr)] = .{
-        .index = @enumToInt(Feature.prof_unpr),
-        .name = @tagName(Feature.prof_unpr),
         .llvm_name = "prof-unpr",
         .description = "Is profitable to unpredicate",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.r4)] = .{
-        .index = @enumToInt(Feature.r4),
-        .name = @tagName(Feature.r4),
         .llvm_name = "r4",
         .description = "Cortex-R4 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.r5)] = .{
-        .index = @enumToInt(Feature.r5),
-        .name = @tagName(Feature.r5),
         .llvm_name = "r5",
         .description = "Cortex-R5 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.r52)] = .{
-        .index = @enumToInt(Feature.r52),
-        .name = @tagName(Feature.r52),
         .llvm_name = "r52",
         .description = "Cortex-R52 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.r7)] = .{
-        .index = @enumToInt(Feature.r7),
-        .name = @tagName(Feature.r7),
         .llvm_name = "r7",
         .description = "Cortex-R7 ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ras)] = .{
-        .index = @enumToInt(Feature.ras),
-        .name = @tagName(Feature.ras),
         .llvm_name = "ras",
         .description = "Enable Reliability, Availability and Serviceability extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rclass)] = .{
-        .index = @enumToInt(Feature.rclass),
-        .name = @tagName(Feature.rclass),
         .llvm_name = "rclass",
         .description = "Is realtime profile ('R' series)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.read_tp_hard)] = .{
-        .index = @enumToInt(Feature.read_tp_hard),
-        .name = @tagName(Feature.read_tp_hard),
         .llvm_name = "read-tp-hard",
         .description = "Reading thread pointer from register",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.reserve_r9)] = .{
-        .index = @enumToInt(Feature.reserve_r9),
-        .name = @tagName(Feature.reserve_r9),
         .llvm_name = "reserve-r9",
         .description = "Reserve R9, making it unavailable as GPR",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ret_addr_stack)] = .{
-        .index = @enumToInt(Feature.ret_addr_stack),
-        .name = @tagName(Feature.ret_addr_stack),
         .llvm_name = "ret-addr-stack",
         .description = "Has return address stack",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sb)] = .{
-        .index = @enumToInt(Feature.sb),
-        .name = @tagName(Feature.sb),
         .llvm_name = "sb",
         .description = "Enable v8.5a Speculation Barrier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sha2)] = .{
-        .index = @enumToInt(Feature.sha2),
-        .name = @tagName(Feature.sha2),
         .llvm_name = "sha2",
         .description = "Enable SHA1 and SHA256 support",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .neon,
         }),
     };
     result[@enumToInt(Feature.slow_fp_brcc)] = .{
-        .index = @enumToInt(Feature.slow_fp_brcc),
-        .name = @tagName(Feature.slow_fp_brcc),
         .llvm_name = "slow-fp-brcc",
         .description = "FP compare + branch is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_load_D_subreg)] = .{
-        .index = @enumToInt(Feature.slow_load_D_subreg),
-        .name = @tagName(Feature.slow_load_D_subreg),
         .llvm_name = "slow-load-D-subreg",
         .description = "Loading into D subregs is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_odd_reg)] = .{
-        .index = @enumToInt(Feature.slow_odd_reg),
-        .name = @tagName(Feature.slow_odd_reg),
         .llvm_name = "slow-odd-reg",
         .description = "VLDM/VSTM starting with an odd register is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_vdup32)] = .{
-        .index = @enumToInt(Feature.slow_vdup32),
-        .name = @tagName(Feature.slow_vdup32),
         .llvm_name = "slow-vdup32",
         .description = "Has slow VDUP32 - prefer VMOV",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_vgetlni32)] = .{
-        .index = @enumToInt(Feature.slow_vgetlni32),
-        .name = @tagName(Feature.slow_vgetlni32),
         .llvm_name = "slow-vgetlni32",
         .description = "Has slow VGETLNi32 - prefer VMOV",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slowfpvmlx)] = .{
-        .index = @enumToInt(Feature.slowfpvmlx),
-        .name = @tagName(Feature.slowfpvmlx),
         .llvm_name = "slowfpvmlx",
         .description = "Disable VFP / NEON MAC instructions",
-        .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 floating point features.",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.splat_vfp_neon)] = .{
-        .index = @enumToInt(Feature.splat_vfp_neon),
-        .name = @tagName(Feature.splat_vfp_neon),
         .llvm_name = "splat-vfp-neon",
         .description = "Splat register from VFP to NEON",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dont_widen_vmovs,
         }),
     };
     result[@enumToInt(Feature.strict_align)] = .{
-        .index = @enumToInt(Feature.strict_align),
-        .name = @tagName(Feature.strict_align),
         .llvm_name = "strict-align",
         .description = "Disallow all unaligned memory access",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.swift)] = .{
-        .index = @enumToInt(Feature.swift),
-        .name = @tagName(Feature.swift),
         .llvm_name = "swift",
         .description = "Swift ARM processors",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.thumb_mode)] = .{
-        .index = @enumToInt(Feature.thumb_mode),
-        .name = @tagName(Feature.thumb_mode),
         .llvm_name = "thumb-mode",
         .description = "Thumb mode",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.thumb2)] = .{
-        .index = @enumToInt(Feature.thumb2),
-        .name = @tagName(Feature.thumb2),
         .llvm_name = "thumb2",
         .description = "Enable Thumb2 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.trustzone)] = .{
-        .index = @enumToInt(Feature.trustzone),
-        .name = @tagName(Feature.trustzone),
         .llvm_name = "trustzone",
         .description = "Enable support for TrustZone security extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_aa)] = .{
-        .index = @enumToInt(Feature.use_aa),
-        .name = @tagName(Feature.use_aa),
         .llvm_name = "use-aa",
         .description = "Use alias analysis during codegen",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.use_misched)] = .{
-        .index = @enumToInt(Feature.use_misched),
-        .name = @tagName(Feature.use_misched),
         .llvm_name = "use-misched",
         .description = "Use the MachineScheduler",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v4t)] = .{
-        .index = @enumToInt(Feature.v4t),
-        .name = @tagName(Feature.v4t),
         .llvm_name = "v4t",
         .description = "Support ARM v4T instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v5t)] = .{
-        .index = @enumToInt(Feature.v5t),
-        .name = @tagName(Feature.v5t),
         .llvm_name = "v5t",
         .description = "Support ARM v5T instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v4t,
         }),
     };
     result[@enumToInt(Feature.v5te)] = .{
-        .index = @enumToInt(Feature.v5te),
-        .name = @tagName(Feature.v5te),
         .llvm_name = "v5te",
         .description = "Support ARM v5TE, v5TEj, and v5TExp instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v5t,
         }),
     };
     result[@enumToInt(Feature.v6)] = .{
-        .index = @enumToInt(Feature.v6),
-        .name = @tagName(Feature.v6),
         .llvm_name = "v6",
         .description = "Support ARM v6 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v5te,
         }),
     };
     result[@enumToInt(Feature.v6k)] = .{
-        .index = @enumToInt(Feature.v6k),
-        .name = @tagName(Feature.v6k),
         .llvm_name = "v6k",
         .description = "Support ARM v6k instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v6,
         }),
     };
     result[@enumToInt(Feature.v6m)] = .{
-        .index = @enumToInt(Feature.v6m),
-        .name = @tagName(Feature.v6m),
         .llvm_name = "v6m",
         .description = "Support ARM v6M instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v6,
         }),
     };
     result[@enumToInt(Feature.v6t2)] = .{
-        .index = @enumToInt(Feature.v6t2),
-        .name = @tagName(Feature.v6t2),
         .llvm_name = "v6t2",
         .description = "Support ARM v6t2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .thumb2,
             .v6k,
             .v8m,
         }),
     };
     result[@enumToInt(Feature.v7)] = .{
-        .index = @enumToInt(Feature.v7),
-        .name = @tagName(Feature.v7),
         .llvm_name = "v7",
         .description = "Support ARM v7 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .perfmon,
             .v6t2,
             .v7clrex,
         }),
     };
     result[@enumToInt(Feature.v7clrex)] = .{
-        .index = @enumToInt(Feature.v7clrex),
-        .name = @tagName(Feature.v7clrex),
         .llvm_name = "v7clrex",
         .description = "Has v7 clrex instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.v8)] = .{
-        .index = @enumToInt(Feature.v8),
-        .name = @tagName(Feature.v8),
         .llvm_name = "v8",
         .description = "Support ARM v8 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .acquire_release,
             .v7,
         }),
     };
     result[@enumToInt(Feature.v8_1a)] = .{
-        .index = @enumToInt(Feature.v8_1a),
-        .name = @tagName(Feature.v8_1a),
         .llvm_name = "v8.1a",
         .description = "Support ARM v8.1a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v8,
         }),
     };
     result[@enumToInt(Feature.v8_1m_main)] = .{
-        .index = @enumToInt(Feature.v8_1m_main),
-        .name = @tagName(Feature.v8_1m_main),
         .llvm_name = "v8.1m.main",
         .description = "Support ARM v8-1M Mainline instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v8m_main,
         }),
     };
     result[@enumToInt(Feature.v8_2a)] = .{
-        .index = @enumToInt(Feature.v8_2a),
-        .name = @tagName(Feature.v8_2a),
         .llvm_name = "v8.2a",
         .description = "Support ARM v8.2a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v8_1a,
         }),
     };
     result[@enumToInt(Feature.v8_3a)] = .{
-        .index = @enumToInt(Feature.v8_3a),
-        .name = @tagName(Feature.v8_3a),
         .llvm_name = "v8.3a",
         .description = "Support ARM v8.3a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v8_2a,
         }),
     };
     result[@enumToInt(Feature.v8_4a)] = .{
-        .index = @enumToInt(Feature.v8_4a),
-        .name = @tagName(Feature.v8_4a),
         .llvm_name = "v8.4a",
         .description = "Support ARM v8.4a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .dotprod,
             .v8_3a,
         }),
     };
     result[@enumToInt(Feature.v8_5a)] = .{
-        .index = @enumToInt(Feature.v8_5a),
-        .name = @tagName(Feature.v8_5a),
         .llvm_name = "v8.5a",
         .description = "Support ARM v8.5a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sb,
             .v8_4a,
         }),
     };
     result[@enumToInt(Feature.v8m)] = .{
-        .index = @enumToInt(Feature.v8m),
-        .name = @tagName(Feature.v8m),
         .llvm_name = "v8m",
         .description = "Support ARM v8M Baseline instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v6m,
         }),
     };
     result[@enumToInt(Feature.v8m_main)] = .{
-        .index = @enumToInt(Feature.v8m_main),
-        .name = @tagName(Feature.v8m_main),
         .llvm_name = "v8m.main",
         .description = "Support ARM v8M Mainline instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .v7,
         }),
     };
     result[@enumToInt(Feature.vfp2)] = .{
-        .index = @enumToInt(Feature.vfp2),
-        .name = @tagName(Feature.vfp2),
         .llvm_name = "vfp2",
         .description = "Enable VFP2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vfp2d16,
             .vfp2sp,
         }),
     };
     result[@enumToInt(Feature.vfp2d16)] = .{
-        .index = @enumToInt(Feature.vfp2d16),
-        .name = @tagName(Feature.vfp2d16),
         .llvm_name = "vfp2d16",
         .description = "Enable VFP2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64,
             .vfp2d16sp,
         }),
     };
     result[@enumToInt(Feature.vfp2d16sp)] = .{
-        .index = @enumToInt(Feature.vfp2d16sp),
-        .name = @tagName(Feature.vfp2d16sp),
         .llvm_name = "vfp2d16sp",
         .description = "Enable VFP2 instructions with no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fpregs,
         }),
     };
     result[@enumToInt(Feature.vfp2sp)] = .{
-        .index = @enumToInt(Feature.vfp2sp),
-        .name = @tagName(Feature.vfp2sp),
         .llvm_name = "vfp2sp",
         .description = "Enable VFP2 instructions with no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vfp2d16sp,
         }),
     };
     result[@enumToInt(Feature.vfp3)] = .{
-        .index = @enumToInt(Feature.vfp3),
-        .name = @tagName(Feature.vfp3),
         .llvm_name = "vfp3",
         .description = "Enable VFP3 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vfp3d16,
             .vfp3sp,
         }),
     };
     result[@enumToInt(Feature.vfp3d16)] = .{
-        .index = @enumToInt(Feature.vfp3d16),
-        .name = @tagName(Feature.vfp3d16),
         .llvm_name = "vfp3d16",
         .description = "Enable VFP3 instructions with only 16 d-registers",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp64,
             .vfp2,
             .vfp3d16sp,
         }),
     };
     result[@enumToInt(Feature.vfp3d16sp)] = .{
-        .index = @enumToInt(Feature.vfp3d16sp),
-        .name = @tagName(Feature.vfp3d16sp),
         .llvm_name = "vfp3d16sp",
         .description = "Enable VFP3 instructions with only 16 d-registers and no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .vfp2sp,
         }),
     };
     result[@enumToInt(Feature.vfp3sp)] = .{
-        .index = @enumToInt(Feature.vfp3sp),
-        .name = @tagName(Feature.vfp3sp),
         .llvm_name = "vfp3sp",
         .description = "Enable VFP3 instructions with no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .d32,
             .vfp3d16sp,
         }),
     };
     result[@enumToInt(Feature.vfp4)] = .{
-        .index = @enumToInt(Feature.vfp4),
-        .name = @tagName(Feature.vfp4),
         .llvm_name = "vfp4",
         .description = "Enable VFP4 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp16,
             .vfp3,
             .vfp4d16,
@@ -1666,11 +1339,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.vfp4d16)] = .{
-        .index = @enumToInt(Feature.vfp4d16),
-        .name = @tagName(Feature.vfp4d16),
         .llvm_name = "vfp4d16",
         .description = "Enable VFP4 instructions with only 16 d-registers",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp16,
             .fp64,
             .vfp3d16,
@@ -1678,21 +1349,17 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.vfp4d16sp)] = .{
-        .index = @enumToInt(Feature.vfp4d16sp),
-        .name = @tagName(Feature.vfp4d16sp),
         .llvm_name = "vfp4d16sp",
         .description = "Enable VFP4 instructions with only 16 d-registers and no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fp16,
             .vfp3d16sp,
         }),
     };
     result[@enumToInt(Feature.vfp4sp)] = .{
-        .index = @enumToInt(Feature.vfp4sp),
-        .name = @tagName(Feature.vfp4sp),
         .llvm_name = "vfp4sp",
         .description = "Enable VFP4 instructions with no double precision",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .d32,
             .fp16,
             .vfp3sp,
@@ -1700,59 +1367,51 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.virtualization)] = .{
-        .index = @enumToInt(Feature.virtualization),
-        .name = @tagName(Feature.virtualization),
         .llvm_name = "virtualization",
         .description = "Supports Virtualization extension",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .hwdiv,
             .hwdiv_arm,
         }),
     };
     result[@enumToInt(Feature.vldn_align)] = .{
-        .index = @enumToInt(Feature.vldn_align),
-        .name = @tagName(Feature.vldn_align),
         .llvm_name = "vldn-align",
         .description = "Check for VLDn unaligned access",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vmlx_forwarding)] = .{
-        .index = @enumToInt(Feature.vmlx_forwarding),
-        .name = @tagName(Feature.vmlx_forwarding),
         .llvm_name = "vmlx-forwarding",
         .description = "Has multiplier accumulator forwarding",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vmlx_hazards)] = .{
-        .index = @enumToInt(Feature.vmlx_hazards),
-        .name = @tagName(Feature.vmlx_hazards),
         .llvm_name = "vmlx-hazards",
         .description = "Has VMLx hazards",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.wide_stride_vfp)] = .{
-        .index = @enumToInt(Feature.wide_stride_vfp),
-        .name = @tagName(Feature.wide_stride_vfp),
         .llvm_name = "wide-stride-vfp",
         .description = "Use a wide stride when allocating VFP registers",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xscale)] = .{
-        .index = @enumToInt(Feature.xscale),
-        .name = @tagName(Feature.xscale),
         .llvm_name = "xscale",
         .description = "ARMv5te architecture",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .armv5te,
         }),
     };
     result[@enumToInt(Feature.zcz)] = .{
-        .index = @enumToInt(Feature.zcz),
-        .name = @tagName(Feature.zcz),
         .llvm_name = "zcz",
         .description = "Has zero-cycle zeroing 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;
 };
 
@@ -1760,49 +1419,49 @@ pub const cpu = struct {
     pub const arm1020e = Cpu{
         .name = "arm1020e",
         .llvm_name = "arm1020e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm1020t = Cpu{
         .name = "arm1020t",
         .llvm_name = "arm1020t",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5t,
         }),
     };
     pub const arm1022e = Cpu{
         .name = "arm1022e",
         .llvm_name = "arm1022e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm10e = Cpu{
         .name = "arm10e",
         .llvm_name = "arm10e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm10tdmi = Cpu{
         .name = "arm10tdmi",
         .llvm_name = "arm10tdmi",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5t,
         }),
     };
     pub const arm1136j_s = Cpu{
         .name = "arm1136j_s",
         .llvm_name = "arm1136j-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6,
         }),
     };
     pub const arm1136jf_s = Cpu{
         .name = "arm1136jf_s",
         .llvm_name = "arm1136jf-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6,
             .slowfpvmlx,
             .vfp2,
@@ -1811,14 +1470,14 @@ pub const cpu = struct {
     pub const arm1156t2_s = Cpu{
         .name = "arm1156t2_s",
         .llvm_name = "arm1156t2-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6t2,
         }),
     };
     pub const arm1156t2f_s = Cpu{
         .name = "arm1156t2f_s",
         .llvm_name = "arm1156t2f-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6t2,
             .slowfpvmlx,
             .vfp2,
@@ -1827,21 +1486,21 @@ pub const cpu = struct {
     pub const arm1176j_s = Cpu{
         .name = "arm1176j_s",
         .llvm_name = "arm1176j-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6kz,
         }),
     };
     pub const arm1176jz_s = Cpu{
         .name = "arm1176jz_s",
         .llvm_name = "arm1176jz-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6kz,
         }),
     };
     pub const arm1176jzf_s = Cpu{
         .name = "arm1176jzf_s",
         .llvm_name = "arm1176jzf-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6kz,
             .slowfpvmlx,
             .vfp2,
@@ -1850,126 +1509,126 @@ pub const cpu = struct {
     pub const arm710t = Cpu{
         .name = "arm710t",
         .llvm_name = "arm710t",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm720t = Cpu{
         .name = "arm720t",
         .llvm_name = "arm720t",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm7tdmi = Cpu{
         .name = "arm7tdmi",
         .llvm_name = "arm7tdmi",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm7tdmi_s = Cpu{
         .name = "arm7tdmi_s",
         .llvm_name = "arm7tdmi-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm8 = Cpu{
         .name = "arm8",
         .llvm_name = "arm8",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4,
         }),
     };
     pub const arm810 = Cpu{
         .name = "arm810",
         .llvm_name = "arm810",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4,
         }),
     };
     pub const arm9 = Cpu{
         .name = "arm9",
         .llvm_name = "arm9",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm920 = Cpu{
         .name = "arm920",
         .llvm_name = "arm920",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm920t = Cpu{
         .name = "arm920t",
         .llvm_name = "arm920t",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm922t = Cpu{
         .name = "arm922t",
         .llvm_name = "arm922t",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm926ej_s = Cpu{
         .name = "arm926ej_s",
         .llvm_name = "arm926ej-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm940t = Cpu{
         .name = "arm940t",
         .llvm_name = "arm940t",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const arm946e_s = Cpu{
         .name = "arm946e_s",
         .llvm_name = "arm946e-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm966e_s = Cpu{
         .name = "arm966e_s",
         .llvm_name = "arm966e-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm968e_s = Cpu{
         .name = "arm968e_s",
         .llvm_name = "arm968e-s",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm9e = Cpu{
         .name = "arm9e",
         .llvm_name = "arm9e",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const arm9tdmi = Cpu{
         .name = "arm9tdmi",
         .llvm_name = "arm9tdmi",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const cortex_a12 = Cpu{
         .name = "cortex_a12",
         .llvm_name = "cortex-a12",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a12,
             .armv7_a,
             .avoid_partial_cpsr,
@@ -1984,7 +1643,7 @@ pub const cpu = struct {
     pub const cortex_a15 = Cpu{
         .name = "cortex_a15",
         .llvm_name = "cortex-a15",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a15,
             .armv7_a,
             .avoid_partial_cpsr,
@@ -2002,7 +1661,7 @@ pub const cpu = struct {
     pub const cortex_a17 = Cpu{
         .name = "cortex_a17",
         .llvm_name = "cortex-a17",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a17,
             .armv7_a,
             .avoid_partial_cpsr,
@@ -2017,7 +1676,7 @@ pub const cpu = struct {
     pub const cortex_a32 = Cpu{
         .name = "cortex_a32",
         .llvm_name = "cortex-a32",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_a,
             .crc,
             .crypto,
@@ -2028,7 +1687,7 @@ pub const cpu = struct {
     pub const cortex_a35 = Cpu{
         .name = "cortex_a35",
         .llvm_name = "cortex-a35",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a35,
             .armv8_a,
             .crc,
@@ -2040,7 +1699,7 @@ pub const cpu = struct {
     pub const cortex_a5 = Cpu{
         .name = "cortex_a5",
         .llvm_name = "cortex-a5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a5,
             .armv7_a,
             .mp,
@@ -2055,7 +1714,7 @@ pub const cpu = struct {
     pub const cortex_a53 = Cpu{
         .name = "cortex_a53",
         .llvm_name = "cortex-a53",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a53,
             .armv8_a,
             .crc,
@@ -2068,7 +1727,7 @@ pub const cpu = struct {
     pub const cortex_a55 = Cpu{
         .name = "cortex_a55",
         .llvm_name = "cortex-a55",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a55,
             .armv8_2_a,
             .dotprod,
@@ -2079,7 +1738,7 @@ pub const cpu = struct {
     pub const cortex_a57 = Cpu{
         .name = "cortex_a57",
         .llvm_name = "cortex-a57",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a57,
             .armv8_a,
             .avoid_partial_cpsr,
@@ -2094,7 +1753,7 @@ pub const cpu = struct {
     pub const cortex_a7 = Cpu{
         .name = "cortex_a7",
         .llvm_name = "cortex-a7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a7,
             .armv7_a,
             .mp,
@@ -2111,7 +1770,7 @@ pub const cpu = struct {
     pub const cortex_a72 = Cpu{
         .name = "cortex_a72",
         .llvm_name = "cortex-a72",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a72,
             .armv8_a,
             .crc,
@@ -2123,7 +1782,7 @@ pub const cpu = struct {
     pub const cortex_a73 = Cpu{
         .name = "cortex_a73",
         .llvm_name = "cortex-a73",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a73,
             .armv8_a,
             .crc,
@@ -2135,7 +1794,7 @@ pub const cpu = struct {
     pub const cortex_a75 = Cpu{
         .name = "cortex_a75",
         .llvm_name = "cortex-a75",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a75,
             .armv8_2_a,
             .dotprod,
@@ -2146,7 +1805,7 @@ pub const cpu = struct {
     pub const cortex_a76 = Cpu{
         .name = "cortex_a76",
         .llvm_name = "cortex-a76",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a76,
             .armv8_2_a,
             .crc,
@@ -2160,7 +1819,7 @@ pub const cpu = struct {
     pub const cortex_a76ae = Cpu{
         .name = "cortex_a76ae",
         .llvm_name = "cortex-a76ae",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a76,
             .armv8_2_a,
             .crc,
@@ -2174,7 +1833,7 @@ pub const cpu = struct {
     pub const cortex_a8 = Cpu{
         .name = "cortex_a8",
         .llvm_name = "cortex-a8",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a8,
             .armv7_a,
             .nonpipelined_vfp,
@@ -2189,7 +1848,7 @@ pub const cpu = struct {
     pub const cortex_a9 = Cpu{
         .name = "cortex_a9",
         .llvm_name = "cortex-a9",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .a9,
             .armv7_a,
             .avoid_partial_cpsr,
@@ -2209,28 +1868,28 @@ pub const cpu = struct {
     pub const cortex_m0 = Cpu{
         .name = "cortex_m0",
         .llvm_name = "cortex-m0",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6_m,
         }),
     };
     pub const cortex_m0plus = Cpu{
         .name = "cortex_m0plus",
         .llvm_name = "cortex-m0plus",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6_m,
         }),
     };
     pub const cortex_m1 = Cpu{
         .name = "cortex_m1",
         .llvm_name = "cortex-m1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6_m,
         }),
     };
     pub const cortex_m23 = Cpu{
         .name = "cortex_m23",
         .llvm_name = "cortex-m23",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_m_base,
             .no_movt,
         }),
@@ -2238,7 +1897,7 @@ pub const cpu = struct {
     pub const cortex_m3 = Cpu{
         .name = "cortex_m3",
         .llvm_name = "cortex-m3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_m,
             .loop_align,
             .m3,
@@ -2250,7 +1909,7 @@ pub const cpu = struct {
     pub const cortex_m33 = Cpu{
         .name = "cortex_m33",
         .llvm_name = "cortex-m33",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_m_main,
             .dsp,
             .fp_armv8d16sp,
@@ -2264,7 +1923,7 @@ pub const cpu = struct {
     pub const cortex_m35p = Cpu{
         .name = "cortex_m35p",
         .llvm_name = "cortex-m35p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_m_main,
             .dsp,
             .fp_armv8d16sp,
@@ -2278,7 +1937,7 @@ pub const cpu = struct {
     pub const cortex_m4 = Cpu{
         .name = "cortex_m4",
         .llvm_name = "cortex-m4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7e_m,
             .loop_align,
             .no_branch_predictor,
@@ -2291,7 +1950,7 @@ pub const cpu = struct {
     pub const cortex_m7 = Cpu{
         .name = "cortex_m7",
         .llvm_name = "cortex-m7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7e_m,
             .fp_armv8d16,
         }),
@@ -2299,7 +1958,7 @@ pub const cpu = struct {
     pub const cortex_r4 = Cpu{
         .name = "cortex_r4",
         .llvm_name = "cortex-r4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_r,
             .avoid_partial_cpsr,
             .r4,
@@ -2309,7 +1968,7 @@ pub const cpu = struct {
     pub const cortex_r4f = Cpu{
         .name = "cortex_r4f",
         .llvm_name = "cortex-r4f",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_r,
             .avoid_partial_cpsr,
             .r4,
@@ -2322,7 +1981,7 @@ pub const cpu = struct {
     pub const cortex_r5 = Cpu{
         .name = "cortex_r5",
         .llvm_name = "cortex-r5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_r,
             .avoid_partial_cpsr,
             .hwdiv_arm,
@@ -2336,7 +1995,7 @@ pub const cpu = struct {
     pub const cortex_r52 = Cpu{
         .name = "cortex_r52",
         .llvm_name = "cortex-r52",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_r,
             .fpao,
             .r52,
@@ -2347,7 +2006,7 @@ pub const cpu = struct {
     pub const cortex_r7 = Cpu{
         .name = "cortex_r7",
         .llvm_name = "cortex-r7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_r,
             .avoid_partial_cpsr,
             .fp16,
@@ -2363,7 +2022,7 @@ pub const cpu = struct {
     pub const cortex_r8 = Cpu{
         .name = "cortex_r8",
         .llvm_name = "cortex-r8",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_r,
             .avoid_partial_cpsr,
             .fp16,
@@ -2378,7 +2037,7 @@ pub const cpu = struct {
     pub const cyclone = Cpu{
         .name = "cyclone",
         .llvm_name = "cyclone",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_a,
             .avoid_movs_shop,
             .avoid_partial_cpsr,
@@ -2399,14 +2058,14 @@ pub const cpu = struct {
     pub const ep9312 = Cpu{
         .name = "ep9312",
         .llvm_name = "ep9312",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4t,
         }),
     };
     pub const exynos_m1 = Cpu{
         .name = "exynos_m1",
         .llvm_name = "exynos-m1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_a,
             .exynos,
         }),
@@ -2414,7 +2073,7 @@ pub const cpu = struct {
     pub const exynos_m2 = Cpu{
         .name = "exynos_m2",
         .llvm_name = "exynos-m2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_a,
             .exynos,
         }),
@@ -2422,7 +2081,7 @@ pub const cpu = struct {
     pub const exynos_m3 = Cpu{
         .name = "exynos_m3",
         .llvm_name = "exynos-m3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_a,
             .exynos,
         }),
@@ -2430,7 +2089,7 @@ pub const cpu = struct {
     pub const exynos_m4 = Cpu{
         .name = "exynos_m4",
         .llvm_name = "exynos-m4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_2_a,
             .dotprod,
             .exynos,
@@ -2440,7 +2099,7 @@ pub const cpu = struct {
     pub const exynos_m5 = Cpu{
         .name = "exynos_m5",
         .llvm_name = "exynos-m5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_2_a,
             .dotprod,
             .exynos,
@@ -2450,19 +2109,19 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const iwmmxt = Cpu{
         .name = "iwmmxt",
         .llvm_name = "iwmmxt",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
     pub const krait = Cpu{
         .name = "krait",
         .llvm_name = "krait",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_a,
             .avoid_partial_cpsr,
             .fp16,
@@ -2479,7 +2138,7 @@ pub const cpu = struct {
     pub const kryo = Cpu{
         .name = "kryo",
         .llvm_name = "kryo",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv8_a,
             .crc,
             .crypto,
@@ -2491,7 +2150,7 @@ pub const cpu = struct {
     pub const mpcore = Cpu{
         .name = "mpcore",
         .llvm_name = "mpcore",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6k,
             .slowfpvmlx,
             .vfp2,
@@ -2500,21 +2159,21 @@ pub const cpu = struct {
     pub const mpcorenovfp = Cpu{
         .name = "mpcorenovfp",
         .llvm_name = "mpcorenovfp",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6k,
         }),
     };
     pub const sc000 = Cpu{
         .name = "sc000",
         .llvm_name = "sc000",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv6_m,
         }),
     };
     pub const sc300 = Cpu{
         .name = "sc300",
         .llvm_name = "sc300",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_m,
             .m3,
             .no_branch_predictor,
@@ -2525,35 +2184,35 @@ pub const cpu = struct {
     pub const strongarm = Cpu{
         .name = "strongarm",
         .llvm_name = "strongarm",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4,
         }),
     };
     pub const strongarm110 = Cpu{
         .name = "strongarm110",
         .llvm_name = "strongarm110",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4,
         }),
     };
     pub const strongarm1100 = Cpu{
         .name = "strongarm1100",
         .llvm_name = "strongarm1100",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4,
         }),
     };
     pub const strongarm1110 = Cpu{
         .name = "strongarm1110",
         .llvm_name = "strongarm1110",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv4,
         }),
     };
     pub const swift = Cpu{
         .name = "swift",
         .llvm_name = "swift",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv7_a,
             .avoid_movs_shop,
             .avoid_partial_cpsr,
@@ -2580,7 +2239,7 @@ pub const cpu = struct {
     pub const xscale = Cpu{
         .name = "xscale",
         .llvm_name = "xscale",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .armv5te,
         }),
     };
diff --git a/lib/std/target/avr.zig b/lib/std/target/avr.zig
index ac739edc08..687a8122fe 100644
--- a/lib/std/target/avr.zig
+++ b/lib/std/target/avr.zig
@@ -41,38 +41,30 @@ 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.addsubiw)] = .{
-        .index = @enumToInt(Feature.addsubiw),
-        .name = @tagName(Feature.addsubiw),
         .llvm_name = "addsubiw",
         .description = "Enable 16-bit register-immediate addition and subtraction instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.avr0)] = .{
-        .index = @enumToInt(Feature.avr0),
-        .name = @tagName(Feature.avr0),
         .llvm_name = "avr0",
         .description = "The device is a part of the avr0 family",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.avr1)] = .{
-        .index = @enumToInt(Feature.avr1),
-        .name = @tagName(Feature.avr1),
         .llvm_name = "avr1",
         .description = "The device is a part of the avr1 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr0,
             .lpm,
         }),
     };
     result[@enumToInt(Feature.avr2)] = .{
-        .index = @enumToInt(Feature.avr2),
-        .name = @tagName(Feature.avr2),
         .llvm_name = "avr2",
         .description = "The device is a part of the avr2 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .addsubiw,
             .avr1,
             .ijmpcall,
@@ -80,11 +72,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.avr25)] = .{
-        .index = @enumToInt(Feature.avr25),
-        .name = @tagName(Feature.avr25),
         .llvm_name = "avr25",
         .description = "The device is a part of the avr25 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr2,
             .@"break",
             .lpmx,
@@ -93,31 +83,25 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.avr3)] = .{
-        .index = @enumToInt(Feature.avr3),
-        .name = @tagName(Feature.avr3),
         .llvm_name = "avr3",
         .description = "The device is a part of the avr3 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr2,
             .jmpcall,
         }),
     };
     result[@enumToInt(Feature.avr31)] = .{
-        .index = @enumToInt(Feature.avr31),
-        .name = @tagName(Feature.avr31),
         .llvm_name = "avr31",
         .description = "The device is a part of the avr31 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr3,
             .elpm,
         }),
     };
     result[@enumToInt(Feature.avr35)] = .{
-        .index = @enumToInt(Feature.avr35),
-        .name = @tagName(Feature.avr35),
         .llvm_name = "avr35",
         .description = "The device is a part of the avr35 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr3,
             .@"break",
             .lpmx,
@@ -126,11 +110,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.avr4)] = .{
-        .index = @enumToInt(Feature.avr4),
-        .name = @tagName(Feature.avr4),
         .llvm_name = "avr4",
         .description = "The device is a part of the avr4 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr2,
             .@"break",
             .lpmx,
@@ -140,11 +122,9 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.avr5)] = .{
-        .index = @enumToInt(Feature.avr5),
-        .name = @tagName(Feature.avr5),
         .llvm_name = "avr5",
         .description = "The device is a part of the avr5 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr3,
             .@"break",
             .lpmx,
@@ -154,31 +134,25 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.avr51)] = .{
-        .index = @enumToInt(Feature.avr51),
-        .name = @tagName(Feature.avr51),
         .llvm_name = "avr51",
         .description = "The device is a part of the avr51 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr5,
             .elpm,
             .elpmx,
         }),
     };
     result[@enumToInt(Feature.avr6)] = .{
-        .index = @enumToInt(Feature.avr6),
-        .name = @tagName(Feature.avr6),
         .llvm_name = "avr6",
         .description = "The device is a part of the avr6 family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr51,
         }),
     };
     result[@enumToInt(Feature.avrtiny)] = .{
-        .index = @enumToInt(Feature.avrtiny),
-        .name = @tagName(Feature.avrtiny),
         .llvm_name = "avrtiny",
         .description = "The device is a part of the avrtiny family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr0,
             .@"break",
             .sram,
@@ -186,102 +160,74 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.@"break")] = .{
-        .index = @enumToInt(Feature.@"break"),
-        .name = @tagName(Feature.@"break"),
         .llvm_name = "break",
         .description = "The device supports the `BREAK` debugging instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.des)] = .{
-        .index = @enumToInt(Feature.des),
-        .name = @tagName(Feature.des),
         .llvm_name = "des",
         .description = "The device supports the `DES k` encryption instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.eijmpcall)] = .{
-        .index = @enumToInt(Feature.eijmpcall),
-        .name = @tagName(Feature.eijmpcall),
         .llvm_name = "eijmpcall",
         .description = "The device supports the `EIJMP`/`EICALL` instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.elpm)] = .{
-        .index = @enumToInt(Feature.elpm),
-        .name = @tagName(Feature.elpm),
         .llvm_name = "elpm",
         .description = "The device supports the ELPM instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.elpmx)] = .{
-        .index = @enumToInt(Feature.elpmx),
-        .name = @tagName(Feature.elpmx),
         .llvm_name = "elpmx",
         .description = "The device supports the `ELPM Rd, Z[+]` instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ijmpcall)] = .{
-        .index = @enumToInt(Feature.ijmpcall),
-        .name = @tagName(Feature.ijmpcall),
         .llvm_name = "ijmpcall",
         .description = "The device supports `IJMP`/`ICALL`instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.jmpcall)] = .{
-        .index = @enumToInt(Feature.jmpcall),
-        .name = @tagName(Feature.jmpcall),
         .llvm_name = "jmpcall",
         .description = "The device supports the `JMP` and `CALL` instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lpm)] = .{
-        .index = @enumToInt(Feature.lpm),
-        .name = @tagName(Feature.lpm),
         .llvm_name = "lpm",
         .description = "The device supports the `LPM` instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lpmx)] = .{
-        .index = @enumToInt(Feature.lpmx),
-        .name = @tagName(Feature.lpmx),
         .llvm_name = "lpmx",
         .description = "The device supports the `LPM Rd, Z[+]` instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.movw)] = .{
-        .index = @enumToInt(Feature.movw),
-        .name = @tagName(Feature.movw),
         .llvm_name = "movw",
         .description = "The device supports the 16-bit MOVW instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mul)] = .{
-        .index = @enumToInt(Feature.mul),
-        .name = @tagName(Feature.mul),
         .llvm_name = "mul",
         .description = "The device supports the multiplication instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rmw)] = .{
-        .index = @enumToInt(Feature.rmw),
-        .name = @tagName(Feature.rmw),
         .llvm_name = "rmw",
         .description = "The device supports the read-write-modify instructions: XCH, LAS, LAC, LAT",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.smallstack)] = .{
-        .index = @enumToInt(Feature.smallstack),
-        .name = @tagName(Feature.smallstack),
         .llvm_name = "smallstack",
         .description = "The device has an 8-bit stack pointer",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.special)] = .{
-        .index = @enumToInt(Feature.special),
-        .name = @tagName(Feature.special),
         .llvm_name = "special",
         .description = "Enable use of the entire instruction set - used for debugging",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .addsubiw,
             .@"break",
             .des,
@@ -301,39 +247,29 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.spm)] = .{
-        .index = @enumToInt(Feature.spm),
-        .name = @tagName(Feature.spm),
         .llvm_name = "spm",
         .description = "The device supports the `SPM` instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.spmx)] = .{
-        .index = @enumToInt(Feature.spmx),
-        .name = @tagName(Feature.spmx),
         .llvm_name = "spmx",
         .description = "The device supports the `SPM Z+` instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sram)] = .{
-        .index = @enumToInt(Feature.sram),
-        .name = @tagName(Feature.sram),
         .llvm_name = "sram",
         .description = "The device has random access memory",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.tinyencoding)] = .{
-        .index = @enumToInt(Feature.tinyencoding),
-        .name = @tagName(Feature.tinyencoding),
         .llvm_name = "tinyencoding",
         .description = "The device has Tiny core specific instruction encodings",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xmega)] = .{
-        .index = @enumToInt(Feature.xmega),
-        .name = @tagName(Feature.xmega),
         .llvm_name = "xmega",
         .description = "The device is a part of the xmega family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avr51,
             .des,
             .eijmpcall,
@@ -341,15 +277,19 @@ pub const all_features = blk: {
         }),
     };
     result[@enumToInt(Feature.xmegau)] = .{
-        .index = @enumToInt(Feature.xmegau),
-        .name = @tagName(Feature.xmegau),
         .llvm_name = "xmegau",
         .description = "The device is a part of the xmegau family",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .rmw,
             .xmega,
         }),
     };
+    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;
 };
 
@@ -357,28 +297,28 @@ pub const cpu = struct {
     pub const at43usb320 = Cpu{
         .name = "at43usb320",
         .llvm_name = "at43usb320",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr31,
         }),
     };
     pub const at43usb355 = Cpu{
         .name = "at43usb355",
         .llvm_name = "at43usb355",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr3,
         }),
     };
     pub const at76c711 = Cpu{
         .name = "at76c711",
         .llvm_name = "at76c711",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr3,
         }),
     };
     pub const at86rf401 = Cpu{
         .name = "at86rf401",
         .llvm_name = "at86rf401",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
             .lpmx,
             .movw,
@@ -387,217 +327,217 @@ pub const cpu = struct {
     pub const at90c8534 = Cpu{
         .name = "at90c8534",
         .llvm_name = "at90c8534",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90can128 = Cpu{
         .name = "at90can128",
         .llvm_name = "at90can128",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const at90can32 = Cpu{
         .name = "at90can32",
         .llvm_name = "at90can32",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90can64 = Cpu{
         .name = "at90can64",
         .llvm_name = "at90can64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90pwm1 = Cpu{
         .name = "at90pwm1",
         .llvm_name = "at90pwm1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const at90pwm161 = Cpu{
         .name = "at90pwm161",
         .llvm_name = "at90pwm161",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90pwm2 = Cpu{
         .name = "at90pwm2",
         .llvm_name = "at90pwm2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const at90pwm216 = Cpu{
         .name = "at90pwm216",
         .llvm_name = "at90pwm216",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90pwm2b = Cpu{
         .name = "at90pwm2b",
         .llvm_name = "at90pwm2b",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const at90pwm3 = Cpu{
         .name = "at90pwm3",
         .llvm_name = "at90pwm3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const at90pwm316 = Cpu{
         .name = "at90pwm316",
         .llvm_name = "at90pwm316",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90pwm3b = Cpu{
         .name = "at90pwm3b",
         .llvm_name = "at90pwm3b",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const at90pwm81 = Cpu{
         .name = "at90pwm81",
         .llvm_name = "at90pwm81",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const at90s1200 = Cpu{
         .name = "at90s1200",
         .llvm_name = "at90s1200",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr0,
         }),
     };
     pub const at90s2313 = Cpu{
         .name = "at90s2313",
         .llvm_name = "at90s2313",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s2323 = Cpu{
         .name = "at90s2323",
         .llvm_name = "at90s2323",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s2333 = Cpu{
         .name = "at90s2333",
         .llvm_name = "at90s2333",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s2343 = Cpu{
         .name = "at90s2343",
         .llvm_name = "at90s2343",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s4414 = Cpu{
         .name = "at90s4414",
         .llvm_name = "at90s4414",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s4433 = Cpu{
         .name = "at90s4433",
         .llvm_name = "at90s4433",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s4434 = Cpu{
         .name = "at90s4434",
         .llvm_name = "at90s4434",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s8515 = Cpu{
         .name = "at90s8515",
         .llvm_name = "at90s8515",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90s8535 = Cpu{
         .name = "at90s8535",
         .llvm_name = "at90s8535",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const at90scr100 = Cpu{
         .name = "at90scr100",
         .llvm_name = "at90scr100",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90usb1286 = Cpu{
         .name = "at90usb1286",
         .llvm_name = "at90usb1286",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const at90usb1287 = Cpu{
         .name = "at90usb1287",
         .llvm_name = "at90usb1287",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const at90usb162 = Cpu{
         .name = "at90usb162",
         .llvm_name = "at90usb162",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const at90usb646 = Cpu{
         .name = "at90usb646",
         .llvm_name = "at90usb646",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90usb647 = Cpu{
         .name = "at90usb647",
         .llvm_name = "at90usb647",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const at90usb82 = Cpu{
         .name = "at90usb82",
         .llvm_name = "at90usb82",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const at94k = Cpu{
         .name = "at94k",
         .llvm_name = "at94k",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr3,
             .lpmx,
             .movw,
@@ -607,133 +547,133 @@ pub const cpu = struct {
     pub const ata5272 = Cpu{
         .name = "ata5272",
         .llvm_name = "ata5272",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const ata5505 = Cpu{
         .name = "ata5505",
         .llvm_name = "ata5505",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const ata5790 = Cpu{
         .name = "ata5790",
         .llvm_name = "ata5790",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const ata5795 = Cpu{
         .name = "ata5795",
         .llvm_name = "ata5795",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const ata6285 = Cpu{
         .name = "ata6285",
         .llvm_name = "ata6285",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const ata6286 = Cpu{
         .name = "ata6286",
         .llvm_name = "ata6286",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const ata6289 = Cpu{
         .name = "ata6289",
         .llvm_name = "ata6289",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega103 = Cpu{
         .name = "atmega103",
         .llvm_name = "atmega103",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr31,
         }),
     };
     pub const atmega128 = Cpu{
         .name = "atmega128",
         .llvm_name = "atmega128",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega1280 = Cpu{
         .name = "atmega1280",
         .llvm_name = "atmega1280",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega1281 = Cpu{
         .name = "atmega1281",
         .llvm_name = "atmega1281",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega1284 = Cpu{
         .name = "atmega1284",
         .llvm_name = "atmega1284",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega1284p = Cpu{
         .name = "atmega1284p",
         .llvm_name = "atmega1284p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega1284rfr2 = Cpu{
         .name = "atmega1284rfr2",
         .llvm_name = "atmega1284rfr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega128a = Cpu{
         .name = "atmega128a",
         .llvm_name = "atmega128a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega128rfa1 = Cpu{
         .name = "atmega128rfa1",
         .llvm_name = "atmega128rfa1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega128rfr2 = Cpu{
         .name = "atmega128rfr2",
         .llvm_name = "atmega128rfr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const atmega16 = Cpu{
         .name = "atmega16",
         .llvm_name = "atmega16",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega161 = Cpu{
         .name = "atmega161",
         .llvm_name = "atmega161",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr3,
             .lpmx,
             .movw,
@@ -744,14 +684,14 @@ pub const cpu = struct {
     pub const atmega162 = Cpu{
         .name = "atmega162",
         .llvm_name = "atmega162",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega163 = Cpu{
         .name = "atmega163",
         .llvm_name = "atmega163",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr3,
             .lpmx,
             .movw,
@@ -762,623 +702,623 @@ pub const cpu = struct {
     pub const atmega164a = Cpu{
         .name = "atmega164a",
         .llvm_name = "atmega164a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega164p = Cpu{
         .name = "atmega164p",
         .llvm_name = "atmega164p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega164pa = Cpu{
         .name = "atmega164pa",
         .llvm_name = "atmega164pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega165 = Cpu{
         .name = "atmega165",
         .llvm_name = "atmega165",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega165a = Cpu{
         .name = "atmega165a",
         .llvm_name = "atmega165a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega165p = Cpu{
         .name = "atmega165p",
         .llvm_name = "atmega165p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega165pa = Cpu{
         .name = "atmega165pa",
         .llvm_name = "atmega165pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega168 = Cpu{
         .name = "atmega168",
         .llvm_name = "atmega168",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega168a = Cpu{
         .name = "atmega168a",
         .llvm_name = "atmega168a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega168p = Cpu{
         .name = "atmega168p",
         .llvm_name = "atmega168p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega168pa = Cpu{
         .name = "atmega168pa",
         .llvm_name = "atmega168pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega169 = Cpu{
         .name = "atmega169",
         .llvm_name = "atmega169",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega169a = Cpu{
         .name = "atmega169a",
         .llvm_name = "atmega169a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega169p = Cpu{
         .name = "atmega169p",
         .llvm_name = "atmega169p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega169pa = Cpu{
         .name = "atmega169pa",
         .llvm_name = "atmega169pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16a = Cpu{
         .name = "atmega16a",
         .llvm_name = "atmega16a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16hva = Cpu{
         .name = "atmega16hva",
         .llvm_name = "atmega16hva",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16hva2 = Cpu{
         .name = "atmega16hva2",
         .llvm_name = "atmega16hva2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16hvb = Cpu{
         .name = "atmega16hvb",
         .llvm_name = "atmega16hvb",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16hvbrevb = Cpu{
         .name = "atmega16hvbrevb",
         .llvm_name = "atmega16hvbrevb",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16m1 = Cpu{
         .name = "atmega16m1",
         .llvm_name = "atmega16m1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega16u2 = Cpu{
         .name = "atmega16u2",
         .llvm_name = "atmega16u2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const atmega16u4 = Cpu{
         .name = "atmega16u4",
         .llvm_name = "atmega16u4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega2560 = Cpu{
         .name = "atmega2560",
         .llvm_name = "atmega2560",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr6,
         }),
     };
     pub const atmega2561 = Cpu{
         .name = "atmega2561",
         .llvm_name = "atmega2561",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr6,
         }),
     };
     pub const atmega2564rfr2 = Cpu{
         .name = "atmega2564rfr2",
         .llvm_name = "atmega2564rfr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr6,
         }),
     };
     pub const atmega256rfr2 = Cpu{
         .name = "atmega256rfr2",
         .llvm_name = "atmega256rfr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr6,
         }),
     };
     pub const atmega32 = Cpu{
         .name = "atmega32",
         .llvm_name = "atmega32",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega323 = Cpu{
         .name = "atmega323",
         .llvm_name = "atmega323",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega324a = Cpu{
         .name = "atmega324a",
         .llvm_name = "atmega324a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega324p = Cpu{
         .name = "atmega324p",
         .llvm_name = "atmega324p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega324pa = Cpu{
         .name = "atmega324pa",
         .llvm_name = "atmega324pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega325 = Cpu{
         .name = "atmega325",
         .llvm_name = "atmega325",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3250 = Cpu{
         .name = "atmega3250",
         .llvm_name = "atmega3250",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3250a = Cpu{
         .name = "atmega3250a",
         .llvm_name = "atmega3250a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3250p = Cpu{
         .name = "atmega3250p",
         .llvm_name = "atmega3250p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3250pa = Cpu{
         .name = "atmega3250pa",
         .llvm_name = "atmega3250pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega325a = Cpu{
         .name = "atmega325a",
         .llvm_name = "atmega325a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega325p = Cpu{
         .name = "atmega325p",
         .llvm_name = "atmega325p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega325pa = Cpu{
         .name = "atmega325pa",
         .llvm_name = "atmega325pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega328 = Cpu{
         .name = "atmega328",
         .llvm_name = "atmega328",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega328p = Cpu{
         .name = "atmega328p",
         .llvm_name = "atmega328p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega329 = Cpu{
         .name = "atmega329",
         .llvm_name = "atmega329",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3290 = Cpu{
         .name = "atmega3290",
         .llvm_name = "atmega3290",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3290a = Cpu{
         .name = "atmega3290a",
         .llvm_name = "atmega3290a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3290p = Cpu{
         .name = "atmega3290p",
         .llvm_name = "atmega3290p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega3290pa = Cpu{
         .name = "atmega3290pa",
         .llvm_name = "atmega3290pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega329a = Cpu{
         .name = "atmega329a",
         .llvm_name = "atmega329a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega329p = Cpu{
         .name = "atmega329p",
         .llvm_name = "atmega329p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega329pa = Cpu{
         .name = "atmega329pa",
         .llvm_name = "atmega329pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32a = Cpu{
         .name = "atmega32a",
         .llvm_name = "atmega32a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32c1 = Cpu{
         .name = "atmega32c1",
         .llvm_name = "atmega32c1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32hvb = Cpu{
         .name = "atmega32hvb",
         .llvm_name = "atmega32hvb",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32hvbrevb = Cpu{
         .name = "atmega32hvbrevb",
         .llvm_name = "atmega32hvbrevb",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32m1 = Cpu{
         .name = "atmega32m1",
         .llvm_name = "atmega32m1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32u2 = Cpu{
         .name = "atmega32u2",
         .llvm_name = "atmega32u2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const atmega32u4 = Cpu{
         .name = "atmega32u4",
         .llvm_name = "atmega32u4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega32u6 = Cpu{
         .name = "atmega32u6",
         .llvm_name = "atmega32u6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega406 = Cpu{
         .name = "atmega406",
         .llvm_name = "atmega406",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega48 = Cpu{
         .name = "atmega48",
         .llvm_name = "atmega48",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega48a = Cpu{
         .name = "atmega48a",
         .llvm_name = "atmega48a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega48p = Cpu{
         .name = "atmega48p",
         .llvm_name = "atmega48p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega48pa = Cpu{
         .name = "atmega48pa",
         .llvm_name = "atmega48pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega64 = Cpu{
         .name = "atmega64",
         .llvm_name = "atmega64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega640 = Cpu{
         .name = "atmega640",
         .llvm_name = "atmega640",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega644 = Cpu{
         .name = "atmega644",
         .llvm_name = "atmega644",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega644a = Cpu{
         .name = "atmega644a",
         .llvm_name = "atmega644a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega644p = Cpu{
         .name = "atmega644p",
         .llvm_name = "atmega644p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega644pa = Cpu{
         .name = "atmega644pa",
         .llvm_name = "atmega644pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega644rfr2 = Cpu{
         .name = "atmega644rfr2",
         .llvm_name = "atmega644rfr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega645 = Cpu{
         .name = "atmega645",
         .llvm_name = "atmega645",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega6450 = Cpu{
         .name = "atmega6450",
         .llvm_name = "atmega6450",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega6450a = Cpu{
         .name = "atmega6450a",
         .llvm_name = "atmega6450a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega6450p = Cpu{
         .name = "atmega6450p",
         .llvm_name = "atmega6450p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega645a = Cpu{
         .name = "atmega645a",
         .llvm_name = "atmega645a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega645p = Cpu{
         .name = "atmega645p",
         .llvm_name = "atmega645p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega649 = Cpu{
         .name = "atmega649",
         .llvm_name = "atmega649",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega6490 = Cpu{
         .name = "atmega6490",
         .llvm_name = "atmega6490",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega6490a = Cpu{
         .name = "atmega6490a",
         .llvm_name = "atmega6490a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega6490p = Cpu{
         .name = "atmega6490p",
         .llvm_name = "atmega6490p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega649a = Cpu{
         .name = "atmega649a",
         .llvm_name = "atmega649a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega649p = Cpu{
         .name = "atmega649p",
         .llvm_name = "atmega649p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega64a = Cpu{
         .name = "atmega64a",
         .llvm_name = "atmega64a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega64c1 = Cpu{
         .name = "atmega64c1",
         .llvm_name = "atmega64c1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega64hve = Cpu{
         .name = "atmega64hve",
         .llvm_name = "atmega64hve",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega64m1 = Cpu{
         .name = "atmega64m1",
         .llvm_name = "atmega64m1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega64rfr2 = Cpu{
         .name = "atmega64rfr2",
         .llvm_name = "atmega64rfr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const atmega8 = Cpu{
         .name = "atmega8",
         .llvm_name = "atmega8",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega8515 = Cpu{
         .name = "atmega8515",
         .llvm_name = "atmega8515",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
             .lpmx,
             .movw,
@@ -1389,7 +1329,7 @@ pub const cpu = struct {
     pub const atmega8535 = Cpu{
         .name = "atmega8535",
         .llvm_name = "atmega8535",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
             .lpmx,
             .movw,
@@ -1400,175 +1340,175 @@ pub const cpu = struct {
     pub const atmega88 = Cpu{
         .name = "atmega88",
         .llvm_name = "atmega88",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega88a = Cpu{
         .name = "atmega88a",
         .llvm_name = "atmega88a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega88p = Cpu{
         .name = "atmega88p",
         .llvm_name = "atmega88p",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega88pa = Cpu{
         .name = "atmega88pa",
         .llvm_name = "atmega88pa",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega8a = Cpu{
         .name = "atmega8a",
         .llvm_name = "atmega8a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega8hva = Cpu{
         .name = "atmega8hva",
         .llvm_name = "atmega8hva",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const atmega8u2 = Cpu{
         .name = "atmega8u2",
         .llvm_name = "atmega8u2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const attiny10 = Cpu{
         .name = "attiny10",
         .llvm_name = "attiny10",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny102 = Cpu{
         .name = "attiny102",
         .llvm_name = "attiny102",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny104 = Cpu{
         .name = "attiny104",
         .llvm_name = "attiny104",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny11 = Cpu{
         .name = "attiny11",
         .llvm_name = "attiny11",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr1,
         }),
     };
     pub const attiny12 = Cpu{
         .name = "attiny12",
         .llvm_name = "attiny12",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr1,
         }),
     };
     pub const attiny13 = Cpu{
         .name = "attiny13",
         .llvm_name = "attiny13",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny13a = Cpu{
         .name = "attiny13a",
         .llvm_name = "attiny13a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny15 = Cpu{
         .name = "attiny15",
         .llvm_name = "attiny15",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr1,
         }),
     };
     pub const attiny1634 = Cpu{
         .name = "attiny1634",
         .llvm_name = "attiny1634",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const attiny167 = Cpu{
         .name = "attiny167",
         .llvm_name = "attiny167",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const attiny20 = Cpu{
         .name = "attiny20",
         .llvm_name = "attiny20",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny22 = Cpu{
         .name = "attiny22",
         .llvm_name = "attiny22",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const attiny2313 = Cpu{
         .name = "attiny2313",
         .llvm_name = "attiny2313",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny2313a = Cpu{
         .name = "attiny2313a",
         .llvm_name = "attiny2313a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny24 = Cpu{
         .name = "attiny24",
         .llvm_name = "attiny24",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny24a = Cpu{
         .name = "attiny24a",
         .llvm_name = "attiny24a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny25 = Cpu{
         .name = "attiny25",
         .llvm_name = "attiny25",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny26 = Cpu{
         .name = "attiny26",
         .llvm_name = "attiny26",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
             .lpmx,
         }),
@@ -1576,602 +1516,602 @@ pub const cpu = struct {
     pub const attiny261 = Cpu{
         .name = "attiny261",
         .llvm_name = "attiny261",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny261a = Cpu{
         .name = "attiny261a",
         .llvm_name = "attiny261a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny28 = Cpu{
         .name = "attiny28",
         .llvm_name = "attiny28",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr1,
         }),
     };
     pub const attiny4 = Cpu{
         .name = "attiny4",
         .llvm_name = "attiny4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny40 = Cpu{
         .name = "attiny40",
         .llvm_name = "attiny40",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny4313 = Cpu{
         .name = "attiny4313",
         .llvm_name = "attiny4313",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny43u = Cpu{
         .name = "attiny43u",
         .llvm_name = "attiny43u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny44 = Cpu{
         .name = "attiny44",
         .llvm_name = "attiny44",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny44a = Cpu{
         .name = "attiny44a",
         .llvm_name = "attiny44a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny45 = Cpu{
         .name = "attiny45",
         .llvm_name = "attiny45",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny461 = Cpu{
         .name = "attiny461",
         .llvm_name = "attiny461",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny461a = Cpu{
         .name = "attiny461a",
         .llvm_name = "attiny461a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny48 = Cpu{
         .name = "attiny48",
         .llvm_name = "attiny48",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny5 = Cpu{
         .name = "attiny5",
         .llvm_name = "attiny5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const attiny828 = Cpu{
         .name = "attiny828",
         .llvm_name = "attiny828",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny84 = Cpu{
         .name = "attiny84",
         .llvm_name = "attiny84",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny84a = Cpu{
         .name = "attiny84a",
         .llvm_name = "attiny84a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny85 = Cpu{
         .name = "attiny85",
         .llvm_name = "attiny85",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny861 = Cpu{
         .name = "attiny861",
         .llvm_name = "attiny861",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny861a = Cpu{
         .name = "attiny861a",
         .llvm_name = "attiny861a",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny87 = Cpu{
         .name = "attiny87",
         .llvm_name = "attiny87",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny88 = Cpu{
         .name = "attiny88",
         .llvm_name = "attiny88",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const attiny9 = Cpu{
         .name = "attiny9",
         .llvm_name = "attiny9",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const atxmega128a1 = Cpu{
         .name = "atxmega128a1",
         .llvm_name = "atxmega128a1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega128a1u = Cpu{
         .name = "atxmega128a1u",
         .llvm_name = "atxmega128a1u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega128a3 = Cpu{
         .name = "atxmega128a3",
         .llvm_name = "atxmega128a3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega128a3u = Cpu{
         .name = "atxmega128a3u",
         .llvm_name = "atxmega128a3u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega128a4u = Cpu{
         .name = "atxmega128a4u",
         .llvm_name = "atxmega128a4u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega128b1 = Cpu{
         .name = "atxmega128b1",
         .llvm_name = "atxmega128b1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega128b3 = Cpu{
         .name = "atxmega128b3",
         .llvm_name = "atxmega128b3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega128c3 = Cpu{
         .name = "atxmega128c3",
         .llvm_name = "atxmega128c3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega128d3 = Cpu{
         .name = "atxmega128d3",
         .llvm_name = "atxmega128d3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega128d4 = Cpu{
         .name = "atxmega128d4",
         .llvm_name = "atxmega128d4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega16a4 = Cpu{
         .name = "atxmega16a4",
         .llvm_name = "atxmega16a4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega16a4u = Cpu{
         .name = "atxmega16a4u",
         .llvm_name = "atxmega16a4u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega16c4 = Cpu{
         .name = "atxmega16c4",
         .llvm_name = "atxmega16c4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega16d4 = Cpu{
         .name = "atxmega16d4",
         .llvm_name = "atxmega16d4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega16e5 = Cpu{
         .name = "atxmega16e5",
         .llvm_name = "atxmega16e5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega192a3 = Cpu{
         .name = "atxmega192a3",
         .llvm_name = "atxmega192a3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega192a3u = Cpu{
         .name = "atxmega192a3u",
         .llvm_name = "atxmega192a3u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega192c3 = Cpu{
         .name = "atxmega192c3",
         .llvm_name = "atxmega192c3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega192d3 = Cpu{
         .name = "atxmega192d3",
         .llvm_name = "atxmega192d3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega256a3 = Cpu{
         .name = "atxmega256a3",
         .llvm_name = "atxmega256a3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega256a3b = Cpu{
         .name = "atxmega256a3b",
         .llvm_name = "atxmega256a3b",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega256a3bu = Cpu{
         .name = "atxmega256a3bu",
         .llvm_name = "atxmega256a3bu",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega256a3u = Cpu{
         .name = "atxmega256a3u",
         .llvm_name = "atxmega256a3u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega256c3 = Cpu{
         .name = "atxmega256c3",
         .llvm_name = "atxmega256c3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega256d3 = Cpu{
         .name = "atxmega256d3",
         .llvm_name = "atxmega256d3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega32a4 = Cpu{
         .name = "atxmega32a4",
         .llvm_name = "atxmega32a4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega32a4u = Cpu{
         .name = "atxmega32a4u",
         .llvm_name = "atxmega32a4u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega32c4 = Cpu{
         .name = "atxmega32c4",
         .llvm_name = "atxmega32c4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega32d4 = Cpu{
         .name = "atxmega32d4",
         .llvm_name = "atxmega32d4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega32e5 = Cpu{
         .name = "atxmega32e5",
         .llvm_name = "atxmega32e5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega32x1 = Cpu{
         .name = "atxmega32x1",
         .llvm_name = "atxmega32x1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega384c3 = Cpu{
         .name = "atxmega384c3",
         .llvm_name = "atxmega384c3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega384d3 = Cpu{
         .name = "atxmega384d3",
         .llvm_name = "atxmega384d3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega64a1 = Cpu{
         .name = "atxmega64a1",
         .llvm_name = "atxmega64a1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega64a1u = Cpu{
         .name = "atxmega64a1u",
         .llvm_name = "atxmega64a1u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega64a3 = Cpu{
         .name = "atxmega64a3",
         .llvm_name = "atxmega64a3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega64a3u = Cpu{
         .name = "atxmega64a3u",
         .llvm_name = "atxmega64a3u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega64a4u = Cpu{
         .name = "atxmega64a4u",
         .llvm_name = "atxmega64a4u",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega64b1 = Cpu{
         .name = "atxmega64b1",
         .llvm_name = "atxmega64b1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega64b3 = Cpu{
         .name = "atxmega64b3",
         .llvm_name = "atxmega64b3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega64c3 = Cpu{
         .name = "atxmega64c3",
         .llvm_name = "atxmega64c3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmegau,
         }),
     };
     pub const atxmega64d3 = Cpu{
         .name = "atxmega64d3",
         .llvm_name = "atxmega64d3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega64d4 = Cpu{
         .name = "atxmega64d4",
         .llvm_name = "atxmega64d4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const atxmega8e5 = Cpu{
         .name = "atxmega8e5",
         .llvm_name = "atxmega8e5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avr1 = Cpu{
         .name = "avr1",
         .llvm_name = "avr1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr1,
         }),
     };
     pub const avr2 = Cpu{
         .name = "avr2",
         .llvm_name = "avr2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr2,
         }),
     };
     pub const avr25 = Cpu{
         .name = "avr25",
         .llvm_name = "avr25",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr25,
         }),
     };
     pub const avr3 = Cpu{
         .name = "avr3",
         .llvm_name = "avr3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr3,
         }),
     };
     pub const avr31 = Cpu{
         .name = "avr31",
         .llvm_name = "avr31",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr31,
         }),
     };
     pub const avr35 = Cpu{
         .name = "avr35",
         .llvm_name = "avr35",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr35,
         }),
     };
     pub const avr4 = Cpu{
         .name = "avr4",
         .llvm_name = "avr4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr4,
         }),
     };
     pub const avr5 = Cpu{
         .name = "avr5",
         .llvm_name = "avr5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
     pub const avr51 = Cpu{
         .name = "avr51",
         .llvm_name = "avr51",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr51,
         }),
     };
     pub const avr6 = Cpu{
         .name = "avr6",
         .llvm_name = "avr6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr6,
         }),
     };
     pub const avrtiny = Cpu{
         .name = "avrtiny",
         .llvm_name = "avrtiny",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avrtiny,
         }),
     };
     pub const avrxmega1 = Cpu{
         .name = "avrxmega1",
         .llvm_name = "avrxmega1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avrxmega2 = Cpu{
         .name = "avrxmega2",
         .llvm_name = "avrxmega2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avrxmega3 = Cpu{
         .name = "avrxmega3",
         .llvm_name = "avrxmega3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avrxmega4 = Cpu{
         .name = "avrxmega4",
         .llvm_name = "avrxmega4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avrxmega5 = Cpu{
         .name = "avrxmega5",
         .llvm_name = "avrxmega5",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avrxmega6 = Cpu{
         .name = "avrxmega6",
         .llvm_name = "avrxmega6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const avrxmega7 = Cpu{
         .name = "avrxmega7",
         .llvm_name = "avrxmega7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .xmega,
         }),
     };
     pub const m3000 = Cpu{
         .name = "m3000",
         .llvm_name = "m3000",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .avr5,
         }),
     };
@@ -2440,6 +2380,6 @@ pub const all_cpus = &[_]*const Cpu{
     &cpu.m3000,
 };
 
-pub const baseline_features = featureSet(&[_]Feature{
+pub const baseline_features = featureSet(&all_features, &[_]Feature{
     .avr0,
 });
diff --git a/lib/std/target/bpf.zig b/lib/std/target/bpf.zig
index 73ed463bc5..350d434a6c 100644
--- a/lib/std/target/bpf.zig
+++ b/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{}),
     };
 };
 
diff --git a/lib/std/target/hexagon.zig b/lib/std/target/hexagon.zig
index bea73eb794..cdb44ec889 100644
--- a/lib/std/target/hexagon.zig
+++ b/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,
diff --git a/lib/std/target/mips.zig b/lib/std/target/mips.zig
index 19ea4d7009..51835f2980 100644
--- a/lib/std/target/mips.zig
+++ b/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,
         }),
     };
diff --git a/lib/std/target/msp430.zig b/lib/std/target/msp430.zig
index 9bc184d4da..ecbc362b1a 100644
--- a/lib/std/target/msp430.zig
+++ b/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,
         }),
     };
diff --git a/lib/std/target/nvptx.zig b/lib/std/target/nvptx.zig
index 3cc4f18a14..58babffd86 100644
--- a/lib/std/target/nvptx.zig
+++ b/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,
         }),
diff --git a/lib/std/target/powerpc.zig b/lib/std/target/powerpc.zig
index 3dfc2d7bea..981c595c93 100644
--- a/lib/std/target/powerpc.zig
+++ b/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,
diff --git a/lib/std/target/riscv.zig b/lib/std/target/riscv.zig
index ee0d6509df..f4ba975d08 100644
--- a/lib/std/target/riscv.zig
+++ b/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,
diff --git a/lib/std/target/sparc.zig b/lib/std/target/sparc.zig
index da7649e831..a9d75f5191 100644
--- a/lib/std/target/sparc.zig
+++ b/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,
         }),
     };
diff --git a/lib/std/target/systemz.zig b/lib/std/target/systemz.zig
index aaee832c28..1326ad23ed 100644
--- a/lib/std/target/systemz.zig
+++ b/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,
diff --git a/lib/std/target/wasm.zig b/lib/std/target/wasm.zig
index 3df17d503b..bd6ae8cc8f 100644
--- a/lib/std/target/wasm.zig
+++ b/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{}),
     };
 };
 
diff --git a/lib/std/target/x86.zig b/lib/std/target/x86.zig
index ce9830f1fa..a576bf4082 100644
--- a/lib/std/target/x86.zig
+++ b/lib/std/target/x86.zig
@@ -128,940 +128,705 @@ pub const Feature = enum {
 pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
 
 pub const all_features = blk: {
+    @setEvalBranchQuota(10000);
     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.@"3dnow")] = .{
-        .index = @enumToInt(Feature.@"3dnow"),
-        .name = @tagName(Feature.@"3dnow"),
         .llvm_name = "3dnow",
         .description = "Enable 3DNow! instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .mmx,
         }),
     };
     result[@enumToInt(Feature.@"3dnowa")] = .{
-        .index = @enumToInt(Feature.@"3dnowa"),
-        .name = @tagName(Feature.@"3dnowa"),
         .llvm_name = "3dnowa",
         .description = "Enable 3DNow! Athlon instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .@"3dnow",
         }),
     };
     result[@enumToInt(Feature.@"64bit")] = .{
-        .index = @enumToInt(Feature.@"64bit"),
-        .name = @tagName(Feature.@"64bit"),
         .llvm_name = "64bit",
         .description = "Support 64-bit instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.adx)] = .{
-        .index = @enumToInt(Feature.adx),
-        .name = @tagName(Feature.adx),
         .llvm_name = "adx",
         .description = "Support ADX instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.aes)] = .{
-        .index = @enumToInt(Feature.aes),
-        .name = @tagName(Feature.aes),
         .llvm_name = "aes",
         .description = "Enable AES instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse2,
         }),
     };
     result[@enumToInt(Feature.avx)] = .{
-        .index = @enumToInt(Feature.avx),
-        .name = @tagName(Feature.avx),
         .llvm_name = "avx",
         .description = "Enable AVX instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse4_2,
         }),
     };
     result[@enumToInt(Feature.avx2)] = .{
-        .index = @enumToInt(Feature.avx2),
-        .name = @tagName(Feature.avx2),
         .llvm_name = "avx2",
         .description = "Enable AVX2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx,
         }),
     };
     result[@enumToInt(Feature.avx512bf16)] = .{
-        .index = @enumToInt(Feature.avx512bf16),
-        .name = @tagName(Feature.avx512bf16),
         .llvm_name = "avx512bf16",
         .description = "Support bfloat16 floating point",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512bw,
         }),
     };
     result[@enumToInt(Feature.avx512bitalg)] = .{
-        .index = @enumToInt(Feature.avx512bitalg),
-        .name = @tagName(Feature.avx512bitalg),
         .llvm_name = "avx512bitalg",
         .description = "Enable AVX-512 Bit Algorithms",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512bw,
         }),
     };
     result[@enumToInt(Feature.avx512bw)] = .{
-        .index = @enumToInt(Feature.avx512bw),
-        .name = @tagName(Feature.avx512bw),
         .llvm_name = "avx512bw",
         .description = "Enable AVX-512 Byte and Word Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512cd)] = .{
-        .index = @enumToInt(Feature.avx512cd),
-        .name = @tagName(Feature.avx512cd),
         .llvm_name = "avx512cd",
         .description = "Enable AVX-512 Conflict Detection Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512dq)] = .{
-        .index = @enumToInt(Feature.avx512dq),
-        .name = @tagName(Feature.avx512dq),
         .llvm_name = "avx512dq",
         .description = "Enable AVX-512 Doubleword and Quadword Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512er)] = .{
-        .index = @enumToInt(Feature.avx512er),
-        .name = @tagName(Feature.avx512er),
         .llvm_name = "avx512er",
         .description = "Enable AVX-512 Exponential and Reciprocal Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512f)] = .{
-        .index = @enumToInt(Feature.avx512f),
-        .name = @tagName(Feature.avx512f),
         .llvm_name = "avx512f",
         .description = "Enable AVX-512 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx2,
             .f16c,
             .fma,
         }),
     };
     result[@enumToInt(Feature.avx512ifma)] = .{
-        .index = @enumToInt(Feature.avx512ifma),
-        .name = @tagName(Feature.avx512ifma),
         .llvm_name = "avx512ifma",
         .description = "Enable AVX-512 Integer Fused Multiple-Add",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512pf)] = .{
-        .index = @enumToInt(Feature.avx512pf),
-        .name = @tagName(Feature.avx512pf),
         .llvm_name = "avx512pf",
         .description = "Enable AVX-512 PreFetch Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512vbmi)] = .{
-        .index = @enumToInt(Feature.avx512vbmi),
-        .name = @tagName(Feature.avx512vbmi),
         .llvm_name = "avx512vbmi",
         .description = "Enable AVX-512 Vector Byte Manipulation Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512bw,
         }),
     };
     result[@enumToInt(Feature.avx512vbmi2)] = .{
-        .index = @enumToInt(Feature.avx512vbmi2),
-        .name = @tagName(Feature.avx512vbmi2),
         .llvm_name = "avx512vbmi2",
         .description = "Enable AVX-512 further Vector Byte Manipulation Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512bw,
         }),
     };
     result[@enumToInt(Feature.avx512vl)] = .{
-        .index = @enumToInt(Feature.avx512vl),
-        .name = @tagName(Feature.avx512vl),
         .llvm_name = "avx512vl",
         .description = "Enable AVX-512 Vector Length eXtensions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512vnni)] = .{
-        .index = @enumToInt(Feature.avx512vnni),
-        .name = @tagName(Feature.avx512vnni),
         .llvm_name = "avx512vnni",
         .description = "Enable AVX-512 Vector Neural Network Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512vp2intersect)] = .{
-        .index = @enumToInt(Feature.avx512vp2intersect),
-        .name = @tagName(Feature.avx512vp2intersect),
         .llvm_name = "avx512vp2intersect",
         .description = "Enable AVX-512 vp2intersect",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.avx512vpopcntdq)] = .{
-        .index = @enumToInt(Feature.avx512vpopcntdq),
-        .name = @tagName(Feature.avx512vpopcntdq),
         .llvm_name = "avx512vpopcntdq",
         .description = "Enable AVX-512 Population Count Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx512f,
         }),
     };
     result[@enumToInt(Feature.bmi)] = .{
-        .index = @enumToInt(Feature.bmi),
-        .name = @tagName(Feature.bmi),
         .llvm_name = "bmi",
         .description = "Support BMI instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.bmi2)] = .{
-        .index = @enumToInt(Feature.bmi2),
-        .name = @tagName(Feature.bmi2),
         .llvm_name = "bmi2",
         .description = "Support BMI2 instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.branchfusion)] = .{
-        .index = @enumToInt(Feature.branchfusion),
-        .name = @tagName(Feature.branchfusion),
         .llvm_name = "branchfusion",
         .description = "CMP/TEST can be fused with conditional branches",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cldemote)] = .{
-        .index = @enumToInt(Feature.cldemote),
-        .name = @tagName(Feature.cldemote),
         .llvm_name = "cldemote",
         .description = "Enable Cache Demote",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.clflushopt)] = .{
-        .index = @enumToInt(Feature.clflushopt),
-        .name = @tagName(Feature.clflushopt),
         .llvm_name = "clflushopt",
         .description = "Flush A Cache Line Optimized",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.clwb)] = .{
-        .index = @enumToInt(Feature.clwb),
-        .name = @tagName(Feature.clwb),
         .llvm_name = "clwb",
         .description = "Cache Line Write Back",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.clzero)] = .{
-        .index = @enumToInt(Feature.clzero),
-        .name = @tagName(Feature.clzero),
         .llvm_name = "clzero",
         .description = "Enable Cache Line Zero",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cmov)] = .{
-        .index = @enumToInt(Feature.cmov),
-        .name = @tagName(Feature.cmov),
         .llvm_name = "cmov",
         .description = "Enable conditional move instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.cx16)] = .{
-        .index = @enumToInt(Feature.cx16),
-        .name = @tagName(Feature.cx16),
         .llvm_name = "cx16",
         .description = "64-bit with cmpxchg16b",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .cx8,
         }),
     };
     result[@enumToInt(Feature.cx8)] = .{
-        .index = @enumToInt(Feature.cx8),
-        .name = @tagName(Feature.cx8),
         .llvm_name = "cx8",
         .description = "Support CMPXCHG8B instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.enqcmd)] = .{
-        .index = @enumToInt(Feature.enqcmd),
-        .name = @tagName(Feature.enqcmd),
         .llvm_name = "enqcmd",
         .description = "Has ENQCMD instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ermsb)] = .{
-        .index = @enumToInt(Feature.ermsb),
-        .name = @tagName(Feature.ermsb),
         .llvm_name = "ermsb",
         .description = "REP MOVS/STOS are fast",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.f16c)] = .{
-        .index = @enumToInt(Feature.f16c),
-        .name = @tagName(Feature.f16c),
         .llvm_name = "f16c",
         .description = "Support 16-bit floating point conversion instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx,
         }),
     };
     result[@enumToInt(Feature.false_deps_lzcnt_tzcnt)] = .{
-        .index = @enumToInt(Feature.false_deps_lzcnt_tzcnt),
-        .name = @tagName(Feature.false_deps_lzcnt_tzcnt),
         .llvm_name = "false-deps-lzcnt-tzcnt",
         .description = "LZCNT/TZCNT have a false dependency on dest register",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.false_deps_popcnt)] = .{
-        .index = @enumToInt(Feature.false_deps_popcnt),
-        .name = @tagName(Feature.false_deps_popcnt),
         .llvm_name = "false-deps-popcnt",
         .description = "POPCNT has a false dependency on dest register",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_11bytenop)] = .{
-        .index = @enumToInt(Feature.fast_11bytenop),
-        .name = @tagName(Feature.fast_11bytenop),
         .llvm_name = "fast-11bytenop",
         .description = "Target can quickly decode up to 11 byte NOPs",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_15bytenop)] = .{
-        .index = @enumToInt(Feature.fast_15bytenop),
-        .name = @tagName(Feature.fast_15bytenop),
         .llvm_name = "fast-15bytenop",
         .description = "Target can quickly decode up to 15 byte NOPs",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_bextr)] = .{
-        .index = @enumToInt(Feature.fast_bextr),
-        .name = @tagName(Feature.fast_bextr),
         .llvm_name = "fast-bextr",
         .description = "Indicates that the BEXTR instruction is implemented as a single uop with good throughput",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_gather)] = .{
-        .index = @enumToInt(Feature.fast_gather),
-        .name = @tagName(Feature.fast_gather),
         .llvm_name = "fast-gather",
         .description = "Indicates if gather is reasonably fast",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_hops)] = .{
-        .index = @enumToInt(Feature.fast_hops),
-        .name = @tagName(Feature.fast_hops),
         .llvm_name = "fast-hops",
         .description = "Prefer horizontal vector math instructions (haddp, phsub, etc.) over normal vector instructions with shuffles",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse3,
         }),
     };
     result[@enumToInt(Feature.fast_lzcnt)] = .{
-        .index = @enumToInt(Feature.fast_lzcnt),
-        .name = @tagName(Feature.fast_lzcnt),
         .llvm_name = "fast-lzcnt",
         .description = "LZCNT instructions are as fast as most simple integer ops",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_partial_ymm_or_zmm_write)] = .{
-        .index = @enumToInt(Feature.fast_partial_ymm_or_zmm_write),
-        .name = @tagName(Feature.fast_partial_ymm_or_zmm_write),
         .llvm_name = "fast-partial-ymm-or-zmm-write",
         .description = "Partial writes to YMM/ZMM registers are fast",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_scalar_fsqrt)] = .{
-        .index = @enumToInt(Feature.fast_scalar_fsqrt),
-        .name = @tagName(Feature.fast_scalar_fsqrt),
         .llvm_name = "fast-scalar-fsqrt",
         .description = "Scalar SQRT is fast (disable Newton-Raphson)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_scalar_shift_masks)] = .{
-        .index = @enumToInt(Feature.fast_scalar_shift_masks),
-        .name = @tagName(Feature.fast_scalar_shift_masks),
         .llvm_name = "fast-scalar-shift-masks",
         .description = "Prefer a left/right scalar logical shift pair over a shift+and pair",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_shld_rotate)] = .{
-        .index = @enumToInt(Feature.fast_shld_rotate),
-        .name = @tagName(Feature.fast_shld_rotate),
         .llvm_name = "fast-shld-rotate",
         .description = "SHLD can be used as a faster rotate",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_variable_shuffle)] = .{
-        .index = @enumToInt(Feature.fast_variable_shuffle),
-        .name = @tagName(Feature.fast_variable_shuffle),
         .llvm_name = "fast-variable-shuffle",
         .description = "Shuffles with variable masks are fast",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_vector_fsqrt)] = .{
-        .index = @enumToInt(Feature.fast_vector_fsqrt),
-        .name = @tagName(Feature.fast_vector_fsqrt),
         .llvm_name = "fast-vector-fsqrt",
         .description = "Vector SQRT is fast (disable Newton-Raphson)",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fast_vector_shift_masks)] = .{
-        .index = @enumToInt(Feature.fast_vector_shift_masks),
-        .name = @tagName(Feature.fast_vector_shift_masks),
         .llvm_name = "fast-vector-shift-masks",
         .description = "Prefer a left/right vector logical shift pair over a shift+and pair",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fma)] = .{
-        .index = @enumToInt(Feature.fma),
-        .name = @tagName(Feature.fma),
         .llvm_name = "fma",
         .description = "Enable three-operand fused multiple-add",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx,
         }),
     };
     result[@enumToInt(Feature.fma4)] = .{
-        .index = @enumToInt(Feature.fma4),
-        .name = @tagName(Feature.fma4),
         .llvm_name = "fma4",
         .description = "Enable four-operand fused multiple-add",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx,
             .sse4a,
         }),
     };
     result[@enumToInt(Feature.fsgsbase)] = .{
-        .index = @enumToInt(Feature.fsgsbase),
-        .name = @tagName(Feature.fsgsbase),
         .llvm_name = "fsgsbase",
         .description = "Support FS/GS Base instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.fxsr)] = .{
-        .index = @enumToInt(Feature.fxsr),
-        .name = @tagName(Feature.fxsr),
         .llvm_name = "fxsr",
         .description = "Support fxsave/fxrestore instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.gfni)] = .{
-        .index = @enumToInt(Feature.gfni),
-        .name = @tagName(Feature.gfni),
         .llvm_name = "gfni",
         .description = "Enable Galois Field Arithmetic Instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse2,
         }),
     };
     result[@enumToInt(Feature.idivl_to_divb)] = .{
-        .index = @enumToInt(Feature.idivl_to_divb),
-        .name = @tagName(Feature.idivl_to_divb),
         .llvm_name = "idivl-to-divb",
         .description = "Use 8-bit divide for positive values less than 256",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.idivq_to_divl)] = .{
-        .index = @enumToInt(Feature.idivq_to_divl),
-        .name = @tagName(Feature.idivq_to_divl),
         .llvm_name = "idivq-to-divl",
         .description = "Use 32-bit divide for positive values less than 2^32",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.invpcid)] = .{
-        .index = @enumToInt(Feature.invpcid),
-        .name = @tagName(Feature.invpcid),
         .llvm_name = "invpcid",
         .description = "Invalidate Process-Context Identifier",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lea_sp)] = .{
-        .index = @enumToInt(Feature.lea_sp),
-        .name = @tagName(Feature.lea_sp),
         .llvm_name = "lea-sp",
         .description = "Use LEA for adjusting the stack pointer",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lea_uses_ag)] = .{
-        .index = @enumToInt(Feature.lea_uses_ag),
-        .name = @tagName(Feature.lea_uses_ag),
         .llvm_name = "lea-uses-ag",
         .description = "LEA instruction needs inputs at AG stage",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lwp)] = .{
-        .index = @enumToInt(Feature.lwp),
-        .name = @tagName(Feature.lwp),
         .llvm_name = "lwp",
         .description = "Enable LWP instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.lzcnt)] = .{
-        .index = @enumToInt(Feature.lzcnt),
-        .name = @tagName(Feature.lzcnt),
         .llvm_name = "lzcnt",
         .description = "Support LZCNT instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.macrofusion)] = .{
-        .index = @enumToInt(Feature.macrofusion),
-        .name = @tagName(Feature.macrofusion),
         .llvm_name = "macrofusion",
         .description = "Various instructions can be fused with conditional branches",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.merge_to_threeway_branch)] = .{
-        .index = @enumToInt(Feature.merge_to_threeway_branch),
-        .name = @tagName(Feature.merge_to_threeway_branch),
         .llvm_name = "merge-to-threeway-branch",
         .description = "Merge branches to a three-way conditional branch",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mmx)] = .{
-        .index = @enumToInt(Feature.mmx),
-        .name = @tagName(Feature.mmx),
         .llvm_name = "mmx",
         .description = "Enable MMX instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.movbe)] = .{
-        .index = @enumToInt(Feature.movbe),
-        .name = @tagName(Feature.movbe),
         .llvm_name = "movbe",
         .description = "Support MOVBE instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.movdir64b)] = .{
-        .index = @enumToInt(Feature.movdir64b),
-        .name = @tagName(Feature.movdir64b),
         .llvm_name = "movdir64b",
         .description = "Support movdir64b instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.movdiri)] = .{
-        .index = @enumToInt(Feature.movdiri),
-        .name = @tagName(Feature.movdiri),
         .llvm_name = "movdiri",
         .description = "Support movdiri instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mpx)] = .{
-        .index = @enumToInt(Feature.mpx),
-        .name = @tagName(Feature.mpx),
         .llvm_name = "mpx",
         .description = "Support MPX instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.mwaitx)] = .{
-        .index = @enumToInt(Feature.mwaitx),
-        .name = @tagName(Feature.mwaitx),
         .llvm_name = "mwaitx",
         .description = "Enable MONITORX/MWAITX timer functionality",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.nopl)] = .{
-        .index = @enumToInt(Feature.nopl),
-        .name = @tagName(Feature.nopl),
         .llvm_name = "nopl",
         .description = "Enable NOPL instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pad_short_functions)] = .{
-        .index = @enumToInt(Feature.pad_short_functions),
-        .name = @tagName(Feature.pad_short_functions),
         .llvm_name = "pad-short-functions",
         .description = "Pad short functions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pclmul)] = .{
-        .index = @enumToInt(Feature.pclmul),
-        .name = @tagName(Feature.pclmul),
         .llvm_name = "pclmul",
         .description = "Enable packed carry-less multiplication instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse2,
         }),
     };
     result[@enumToInt(Feature.pconfig)] = .{
-        .index = @enumToInt(Feature.pconfig),
-        .name = @tagName(Feature.pconfig),
         .llvm_name = "pconfig",
         .description = "platform configuration instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.pku)] = .{
-        .index = @enumToInt(Feature.pku),
-        .name = @tagName(Feature.pku),
         .llvm_name = "pku",
         .description = "Enable protection keys",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.popcnt)] = .{
-        .index = @enumToInt(Feature.popcnt),
-        .name = @tagName(Feature.popcnt),
         .llvm_name = "popcnt",
         .description = "Support POPCNT instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.prefer_256_bit)] = .{
-        .index = @enumToInt(Feature.prefer_256_bit),
-        .name = @tagName(Feature.prefer_256_bit),
         .llvm_name = "prefer-256-bit",
         .description = "Prefer 256-bit AVX instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.prefetchwt1)] = .{
-        .index = @enumToInt(Feature.prefetchwt1),
-        .name = @tagName(Feature.prefetchwt1),
         .llvm_name = "prefetchwt1",
         .description = "Prefetch with Intent to Write and T1 Hint",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.prfchw)] = .{
-        .index = @enumToInt(Feature.prfchw),
-        .name = @tagName(Feature.prfchw),
         .llvm_name = "prfchw",
         .description = "Support PRFCHW instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.ptwrite)] = .{
-        .index = @enumToInt(Feature.ptwrite),
-        .name = @tagName(Feature.ptwrite),
         .llvm_name = "ptwrite",
         .description = "Support ptwrite instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rdpid)] = .{
-        .index = @enumToInt(Feature.rdpid),
-        .name = @tagName(Feature.rdpid),
         .llvm_name = "rdpid",
         .description = "Support RDPID instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rdrnd)] = .{
-        .index = @enumToInt(Feature.rdrnd),
-        .name = @tagName(Feature.rdrnd),
         .llvm_name = "rdrnd",
         .description = "Support RDRAND instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rdseed)] = .{
-        .index = @enumToInt(Feature.rdseed),
-        .name = @tagName(Feature.rdseed),
         .llvm_name = "rdseed",
         .description = "Support RDSEED instruction",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.retpoline)] = .{
-        .index = @enumToInt(Feature.retpoline),
-        .name = @tagName(Feature.retpoline),
         .llvm_name = "retpoline",
         .description = "Remove speculation of indirect branches from the generated code, either by avoiding them entirely or lowering them with a speculation blocking construct",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .retpoline_indirect_branches,
             .retpoline_indirect_calls,
         }),
     };
     result[@enumToInt(Feature.retpoline_external_thunk)] = .{
-        .index = @enumToInt(Feature.retpoline_external_thunk),
-        .name = @tagName(Feature.retpoline_external_thunk),
         .llvm_name = "retpoline-external-thunk",
         .description = "When lowering an indirect call or branch using a `retpoline`, rely on the specified user provided thunk rather than emitting one ourselves. Only has effect when combined with some other retpoline feature",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .retpoline_indirect_calls,
         }),
     };
     result[@enumToInt(Feature.retpoline_indirect_branches)] = .{
-        .index = @enumToInt(Feature.retpoline_indirect_branches),
-        .name = @tagName(Feature.retpoline_indirect_branches),
         .llvm_name = "retpoline-indirect-branches",
         .description = "Remove speculation of indirect branches from the generated code",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.retpoline_indirect_calls)] = .{
-        .index = @enumToInt(Feature.retpoline_indirect_calls),
-        .name = @tagName(Feature.retpoline_indirect_calls),
         .llvm_name = "retpoline-indirect-calls",
         .description = "Remove speculation of indirect calls from the generated code",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.rtm)] = .{
-        .index = @enumToInt(Feature.rtm),
-        .name = @tagName(Feature.rtm),
         .llvm_name = "rtm",
         .description = "Support RTM instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sahf)] = .{
-        .index = @enumToInt(Feature.sahf),
-        .name = @tagName(Feature.sahf),
         .llvm_name = "sahf",
         .description = "Support LAHF and SAHF instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sgx)] = .{
-        .index = @enumToInt(Feature.sgx),
-        .name = @tagName(Feature.sgx),
         .llvm_name = "sgx",
         .description = "Enable Software Guard Extensions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sha)] = .{
-        .index = @enumToInt(Feature.sha),
-        .name = @tagName(Feature.sha),
         .llvm_name = "sha",
         .description = "Enable SHA instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse2,
         }),
     };
     result[@enumToInt(Feature.shstk)] = .{
-        .index = @enumToInt(Feature.shstk),
-        .name = @tagName(Feature.shstk),
         .llvm_name = "shstk",
         .description = "Support CET Shadow-Stack instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_3ops_lea)] = .{
-        .index = @enumToInt(Feature.slow_3ops_lea),
-        .name = @tagName(Feature.slow_3ops_lea),
         .llvm_name = "slow-3ops-lea",
         .description = "LEA instruction with 3 ops or certain registers is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_incdec)] = .{
-        .index = @enumToInt(Feature.slow_incdec),
-        .name = @tagName(Feature.slow_incdec),
         .llvm_name = "slow-incdec",
         .description = "INC and DEC instructions are slower than ADD and SUB",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_lea)] = .{
-        .index = @enumToInt(Feature.slow_lea),
-        .name = @tagName(Feature.slow_lea),
         .llvm_name = "slow-lea",
         .description = "LEA instruction with certain arguments is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_pmaddwd)] = .{
-        .index = @enumToInt(Feature.slow_pmaddwd),
-        .name = @tagName(Feature.slow_pmaddwd),
         .llvm_name = "slow-pmaddwd",
         .description = "PMADDWD is slower than PMULLD",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_pmulld)] = .{
-        .index = @enumToInt(Feature.slow_pmulld),
-        .name = @tagName(Feature.slow_pmulld),
         .llvm_name = "slow-pmulld",
         .description = "PMULLD instruction is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_shld)] = .{
-        .index = @enumToInt(Feature.slow_shld),
-        .name = @tagName(Feature.slow_shld),
         .llvm_name = "slow-shld",
         .description = "SHLD instruction is slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_two_mem_ops)] = .{
-        .index = @enumToInt(Feature.slow_two_mem_ops),
-        .name = @tagName(Feature.slow_two_mem_ops),
         .llvm_name = "slow-two-mem-ops",
         .description = "Two memory operand instructions are slow",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_unaligned_mem_16)] = .{
-        .index = @enumToInt(Feature.slow_unaligned_mem_16),
-        .name = @tagName(Feature.slow_unaligned_mem_16),
         .llvm_name = "slow-unaligned-mem-16",
         .description = "Slow unaligned 16-byte memory access",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.slow_unaligned_mem_32)] = .{
-        .index = @enumToInt(Feature.slow_unaligned_mem_32),
-        .name = @tagName(Feature.slow_unaligned_mem_32),
         .llvm_name = "slow-unaligned-mem-32",
         .description = "Slow unaligned 32-byte memory access",
-        .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 floating point features",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sse)] = .{
-        .index = @enumToInt(Feature.sse),
-        .name = @tagName(Feature.sse),
         .llvm_name = "sse",
         .description = "Enable SSE instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sse_unaligned_mem)] = .{
-        .index = @enumToInt(Feature.sse_unaligned_mem),
-        .name = @tagName(Feature.sse_unaligned_mem),
         .llvm_name = "sse-unaligned-mem",
         .description = "Allow unaligned memory operands with SSE instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.sse2)] = .{
-        .index = @enumToInt(Feature.sse2),
-        .name = @tagName(Feature.sse2),
         .llvm_name = "sse2",
         .description = "Enable SSE2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse,
         }),
     };
     result[@enumToInt(Feature.sse3)] = .{
-        .index = @enumToInt(Feature.sse3),
-        .name = @tagName(Feature.sse3),
         .llvm_name = "sse3",
         .description = "Enable SSE3 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse2,
         }),
     };
     result[@enumToInt(Feature.sse4_1)] = .{
-        .index = @enumToInt(Feature.sse4_1),
-        .name = @tagName(Feature.sse4_1),
         .llvm_name = "sse4.1",
         .description = "Enable SSE 4.1 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .ssse3,
         }),
     };
     result[@enumToInt(Feature.sse4_2)] = .{
-        .index = @enumToInt(Feature.sse4_2),
-        .name = @tagName(Feature.sse4_2),
         .llvm_name = "sse4.2",
         .description = "Enable SSE 4.2 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse4_1,
         }),
     };
     result[@enumToInt(Feature.sse4a)] = .{
-        .index = @enumToInt(Feature.sse4a),
-        .name = @tagName(Feature.sse4a),
         .llvm_name = "sse4a",
         .description = "Support SSE 4a instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse3,
         }),
     };
     result[@enumToInt(Feature.ssse3)] = .{
-        .index = @enumToInt(Feature.ssse3),
-        .name = @tagName(Feature.ssse3),
         .llvm_name = "ssse3",
         .description = "Enable SSSE3 instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .sse3,
         }),
     };
     result[@enumToInt(Feature.tbm)] = .{
-        .index = @enumToInt(Feature.tbm),
-        .name = @tagName(Feature.tbm),
         .llvm_name = "tbm",
         .description = "Enable TBM instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.vaes)] = .{
-        .index = @enumToInt(Feature.vaes),
-        .name = @tagName(Feature.vaes),
         .llvm_name = "vaes",
         .description = "Promote selected AES instructions to AVX512/AVX registers",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .aes,
             .avx,
         }),
     };
     result[@enumToInt(Feature.vpclmulqdq)] = .{
-        .index = @enumToInt(Feature.vpclmulqdq),
-        .name = @tagName(Feature.vpclmulqdq),
         .llvm_name = "vpclmulqdq",
         .description = "Enable vpclmulqdq instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .avx,
             .pclmul,
         }),
     };
     result[@enumToInt(Feature.waitpkg)] = .{
-        .index = @enumToInt(Feature.waitpkg),
-        .name = @tagName(Feature.waitpkg),
         .llvm_name = "waitpkg",
         .description = "Wait and pause enhancements",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.wbnoinvd)] = .{
-        .index = @enumToInt(Feature.wbnoinvd),
-        .name = @tagName(Feature.wbnoinvd),
         .llvm_name = "wbnoinvd",
         .description = "Write Back No Invalidate",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.x87)] = .{
-        .index = @enumToInt(Feature.x87),
-        .name = @tagName(Feature.x87),
         .llvm_name = "x87",
         .description = "Enable X87 float instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xop)] = .{
-        .index = @enumToInt(Feature.xop),
-        .name = @tagName(Feature.xop),
         .llvm_name = "xop",
         .description = "Enable XOP instructions",
-        .dependencies = featureSet(&[_]Feature{
+        .dependencies = sparseFeatureSet(&[_]Feature{
             .fma4,
         }),
     };
     result[@enumToInt(Feature.xsave)] = .{
-        .index = @enumToInt(Feature.xsave),
-        .name = @tagName(Feature.xsave),
         .llvm_name = "xsave",
         .description = "Support xsave instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xsavec)] = .{
-        .index = @enumToInt(Feature.xsavec),
-        .name = @tagName(Feature.xsavec),
         .llvm_name = "xsavec",
         .description = "Support xsavec instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xsaveopt)] = .{
-        .index = @enumToInt(Feature.xsaveopt),
-        .name = @tagName(Feature.xsaveopt),
         .llvm_name = "xsaveopt",
         .description = "Support xsaveopt instructions",
-        .dependencies = featureSet(&[_]Feature{}),
+        .dependencies = sparseFeatureSet(&[_]Feature{}),
     };
     result[@enumToInt(Feature.xsaves)] = .{
-        .index = @enumToInt(Feature.xsaves),
-        .name = @tagName(Feature.xsaves),
         .llvm_name = "xsaves",
         .description = "Support xsaves 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;
 };
 
@@ -1069,7 +834,7 @@ pub const cpu = struct {
     pub const amdfam10 = Cpu{
         .name = "amdfam10",
         .llvm_name = "amdfam10",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -1089,7 +854,7 @@ pub const cpu = struct {
     pub const athlon = Cpu{
         .name = "athlon",
         .llvm_name = "athlon",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .cmov,
             .cx8,
@@ -1102,7 +867,7 @@ pub const cpu = struct {
     pub const athlon_4 = Cpu{
         .name = "athlon_4",
         .llvm_name = "athlon-4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .cmov,
             .cx8,
@@ -1117,7 +882,7 @@ pub const cpu = struct {
     pub const athlon_fx = Cpu{
         .name = "athlon_fx",
         .llvm_name = "athlon-fx",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -1134,7 +899,7 @@ pub const cpu = struct {
     pub const athlon_mp = Cpu{
         .name = "athlon_mp",
         .llvm_name = "athlon-mp",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .cmov,
             .cx8,
@@ -1149,7 +914,7 @@ pub const cpu = struct {
     pub const athlon_tbird = Cpu{
         .name = "athlon_tbird",
         .llvm_name = "athlon-tbird",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .cmov,
             .cx8,
@@ -1162,7 +927,7 @@ pub const cpu = struct {
     pub const athlon_xp = Cpu{
         .name = "athlon_xp",
         .llvm_name = "athlon-xp",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .cmov,
             .cx8,
@@ -1177,7 +942,7 @@ pub const cpu = struct {
     pub const athlon64 = Cpu{
         .name = "athlon64",
         .llvm_name = "athlon64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -1194,7 +959,7 @@ pub const cpu = struct {
     pub const athlon64_sse3 = Cpu{
         .name = "athlon64_sse3",
         .llvm_name = "athlon64-sse3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -1212,7 +977,7 @@ pub const cpu = struct {
     pub const atom = Cpu{
         .name = "atom",
         .llvm_name = "atom",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -1236,7 +1001,7 @@ pub const cpu = struct {
     pub const barcelona = Cpu{
         .name = "barcelona",
         .llvm_name = "barcelona",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -1256,7 +1021,7 @@ pub const cpu = struct {
     pub const bdver1 = Cpu{
         .name = "bdver1",
         .llvm_name = "bdver1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .branchfusion,
@@ -1283,7 +1048,7 @@ pub const cpu = struct {
     pub const bdver2 = Cpu{
         .name = "bdver2",
         .llvm_name = "bdver2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .bmi,
@@ -1315,7 +1080,7 @@ pub const cpu = struct {
     pub const bdver3 = Cpu{
         .name = "bdver3",
         .llvm_name = "bdver3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .bmi,
@@ -1349,7 +1114,7 @@ pub const cpu = struct {
     pub const bdver4 = Cpu{
         .name = "bdver4",
         .llvm_name = "bdver4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .avx2,
@@ -1386,7 +1151,7 @@ pub const cpu = struct {
     pub const bonnell = Cpu{
         .name = "bonnell",
         .llvm_name = "bonnell",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -1410,7 +1175,7 @@ pub const cpu = struct {
     pub const broadwell = Cpu{
         .name = "broadwell",
         .llvm_name = "broadwell",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .avx,
@@ -1454,7 +1219,7 @@ pub const cpu = struct {
     pub const btver1 = Cpu{
         .name = "btver1",
         .llvm_name = "btver1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -1478,7 +1243,7 @@ pub const cpu = struct {
     pub const btver2 = Cpu{
         .name = "btver2",
         .llvm_name = "btver2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .avx,
@@ -1514,7 +1279,7 @@ pub const cpu = struct {
     pub const c3 = Cpu{
         .name = "c3",
         .llvm_name = "c3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnow",
             .slow_unaligned_mem_16,
             .x87,
@@ -1523,7 +1288,7 @@ pub const cpu = struct {
     pub const c3_2 = Cpu{
         .name = "c3_2",
         .llvm_name = "c3-2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -1536,7 +1301,7 @@ pub const cpu = struct {
     pub const cannonlake = Cpu{
         .name = "cannonlake",
         .llvm_name = "cannonlake",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -1595,7 +1360,7 @@ pub const cpu = struct {
     pub const cascadelake = Cpu{
         .name = "cascadelake",
         .llvm_name = "cascadelake",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -1653,7 +1418,7 @@ pub const cpu = struct {
     pub const cooperlake = Cpu{
         .name = "cooperlake",
         .llvm_name = "cooperlake",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -1712,7 +1477,7 @@ pub const cpu = struct {
     pub const core_avx_i = Cpu{
         .name = "core_avx_i",
         .llvm_name = "core-avx-i",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .avx,
             .cmov,
@@ -1744,7 +1509,7 @@ pub const cpu = struct {
     pub const core_avx2 = Cpu{
         .name = "core_avx2",
         .llvm_name = "core-avx2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .avx,
             .avx2,
@@ -1785,7 +1550,7 @@ pub const cpu = struct {
     pub const core2 = Cpu{
         .name = "core2",
         .llvm_name = "core2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -1803,7 +1568,7 @@ pub const cpu = struct {
     pub const corei7 = Cpu{
         .name = "corei7",
         .llvm_name = "corei7",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -1821,7 +1586,7 @@ pub const cpu = struct {
     pub const corei7_avx = Cpu{
         .name = "corei7_avx",
         .llvm_name = "corei7-avx",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .avx,
             .cmov,
@@ -1850,7 +1615,7 @@ pub const cpu = struct {
     pub const generic = Cpu{
         .name = "generic",
         .llvm_name = "generic",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cx8,
             .slow_unaligned_mem_16,
             .x87,
@@ -1859,7 +1624,7 @@ pub const cpu = struct {
     pub const geode = Cpu{
         .name = "geode",
         .llvm_name = "geode",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .cx8,
             .slow_unaligned_mem_16,
@@ -1869,7 +1634,7 @@ pub const cpu = struct {
     pub const goldmont = Cpu{
         .name = "goldmont",
         .llvm_name = "goldmont",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .clflushopt,
@@ -1905,7 +1670,7 @@ pub const cpu = struct {
     pub const goldmont_plus = Cpu{
         .name = "goldmont_plus",
         .llvm_name = "goldmont-plus",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .clflushopt,
@@ -1943,7 +1708,7 @@ pub const cpu = struct {
     pub const haswell = Cpu{
         .name = "haswell",
         .llvm_name = "haswell",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .avx,
             .avx2,
@@ -1984,7 +1749,7 @@ pub const cpu = struct {
     pub const _i386 = Cpu{
         .name = "_i386",
         .llvm_name = "i386",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .slow_unaligned_mem_16,
             .x87,
         }),
@@ -1992,7 +1757,7 @@ pub const cpu = struct {
     pub const _i486 = Cpu{
         .name = "_i486",
         .llvm_name = "i486",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .slow_unaligned_mem_16,
             .x87,
         }),
@@ -2000,7 +1765,7 @@ pub const cpu = struct {
     pub const _i586 = Cpu{
         .name = "_i586",
         .llvm_name = "i586",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cx8,
             .slow_unaligned_mem_16,
             .x87,
@@ -2009,7 +1774,7 @@ pub const cpu = struct {
     pub const _i686 = Cpu{
         .name = "_i686",
         .llvm_name = "i686",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .slow_unaligned_mem_16,
@@ -2019,7 +1784,7 @@ pub const cpu = struct {
     pub const icelake_client = Cpu{
         .name = "icelake_client",
         .llvm_name = "icelake-client",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2087,7 +1852,7 @@ pub const cpu = struct {
     pub const icelake_server = Cpu{
         .name = "icelake_server",
         .llvm_name = "icelake-server",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2157,7 +1922,7 @@ pub const cpu = struct {
     pub const ivybridge = Cpu{
         .name = "ivybridge",
         .llvm_name = "ivybridge",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .avx,
             .cmov,
@@ -2189,7 +1954,7 @@ pub const cpu = struct {
     pub const k6 = Cpu{
         .name = "k6",
         .llvm_name = "k6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cx8,
             .mmx,
             .slow_unaligned_mem_16,
@@ -2199,7 +1964,7 @@ pub const cpu = struct {
     pub const k6_2 = Cpu{
         .name = "k6_2",
         .llvm_name = "k6-2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnow",
             .cx8,
             .slow_unaligned_mem_16,
@@ -2209,7 +1974,7 @@ pub const cpu = struct {
     pub const k6_3 = Cpu{
         .name = "k6_3",
         .llvm_name = "k6-3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnow",
             .cx8,
             .slow_unaligned_mem_16,
@@ -2219,7 +1984,7 @@ pub const cpu = struct {
     pub const k8 = Cpu{
         .name = "k8",
         .llvm_name = "k8",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -2236,7 +2001,7 @@ pub const cpu = struct {
     pub const k8_sse3 = Cpu{
         .name = "k8_sse3",
         .llvm_name = "k8-sse3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -2254,7 +2019,7 @@ pub const cpu = struct {
     pub const knl = Cpu{
         .name = "knl",
         .llvm_name = "knl",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2297,7 +2062,7 @@ pub const cpu = struct {
     pub const knm = Cpu{
         .name = "knm",
         .llvm_name = "knm",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2341,12 +2106,12 @@ pub const cpu = struct {
     pub const lakemont = Cpu{
         .name = "lakemont",
         .llvm_name = "lakemont",
-        .features = featureSet(&[_]Feature{}),
+        .features = featureSet(&all_features, &[_]Feature{}),
     };
     pub const nehalem = Cpu{
         .name = "nehalem",
         .llvm_name = "nehalem",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -2364,7 +2129,7 @@ pub const cpu = struct {
     pub const nocona = Cpu{
         .name = "nocona",
         .llvm_name = "nocona",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -2380,7 +2145,7 @@ pub const cpu = struct {
     pub const opteron = Cpu{
         .name = "opteron",
         .llvm_name = "opteron",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -2397,7 +2162,7 @@ pub const cpu = struct {
     pub const opteron_sse3 = Cpu{
         .name = "opteron_sse3",
         .llvm_name = "opteron-sse3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnowa",
             .@"64bit",
             .cmov,
@@ -2415,7 +2180,7 @@ pub const cpu = struct {
     pub const penryn = Cpu{
         .name = "penryn",
         .llvm_name = "penryn",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -2433,7 +2198,7 @@ pub const cpu = struct {
     pub const pentium = Cpu{
         .name = "pentium",
         .llvm_name = "pentium",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cx8,
             .slow_unaligned_mem_16,
             .x87,
@@ -2442,7 +2207,7 @@ pub const cpu = struct {
     pub const pentium_m = Cpu{
         .name = "pentium_m",
         .llvm_name = "pentium-m",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2456,7 +2221,7 @@ pub const cpu = struct {
     pub const pentium_mmx = Cpu{
         .name = "pentium_mmx",
         .llvm_name = "pentium-mmx",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cx8,
             .mmx,
             .slow_unaligned_mem_16,
@@ -2466,7 +2231,7 @@ pub const cpu = struct {
     pub const pentium2 = Cpu{
         .name = "pentium2",
         .llvm_name = "pentium2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2479,7 +2244,7 @@ pub const cpu = struct {
     pub const pentium3 = Cpu{
         .name = "pentium3",
         .llvm_name = "pentium3",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2493,7 +2258,7 @@ pub const cpu = struct {
     pub const pentium3m = Cpu{
         .name = "pentium3m",
         .llvm_name = "pentium3m",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2507,7 +2272,7 @@ pub const cpu = struct {
     pub const pentium4 = Cpu{
         .name = "pentium4",
         .llvm_name = "pentium4",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2521,7 +2286,7 @@ pub const cpu = struct {
     pub const pentium4m = Cpu{
         .name = "pentium4m",
         .llvm_name = "pentium4m",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2535,7 +2300,7 @@ pub const cpu = struct {
     pub const pentiumpro = Cpu{
         .name = "pentiumpro",
         .llvm_name = "pentiumpro",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .nopl,
@@ -2546,7 +2311,7 @@ pub const cpu = struct {
     pub const prescott = Cpu{
         .name = "prescott",
         .llvm_name = "prescott",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2560,7 +2325,7 @@ pub const cpu = struct {
     pub const sandybridge = Cpu{
         .name = "sandybridge",
         .llvm_name = "sandybridge",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .avx,
             .cmov,
@@ -2589,7 +2354,7 @@ pub const cpu = struct {
     pub const silvermont = Cpu{
         .name = "silvermont",
         .llvm_name = "silvermont",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -2617,7 +2382,7 @@ pub const cpu = struct {
     pub const skx = Cpu{
         .name = "skx",
         .llvm_name = "skx",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2674,7 +2439,7 @@ pub const cpu = struct {
     pub const skylake = Cpu{
         .name = "skylake",
         .llvm_name = "skylake",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2725,7 +2490,7 @@ pub const cpu = struct {
     pub const skylake_avx512 = Cpu{
         .name = "skylake_avx512",
         .llvm_name = "skylake-avx512",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2782,7 +2547,7 @@ pub const cpu = struct {
     pub const slm = Cpu{
         .name = "slm",
         .llvm_name = "slm",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -2810,7 +2575,7 @@ pub const cpu = struct {
     pub const tremont = Cpu{
         .name = "tremont",
         .llvm_name = "tremont",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .aes,
             .cldemote,
@@ -2853,7 +2618,7 @@ pub const cpu = struct {
     pub const westmere = Cpu{
         .name = "westmere",
         .llvm_name = "westmere",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx16,
@@ -2872,7 +2637,7 @@ pub const cpu = struct {
     pub const winchip_c6 = Cpu{
         .name = "winchip_c6",
         .llvm_name = "winchip-c6",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .mmx,
             .slow_unaligned_mem_16,
             .x87,
@@ -2881,7 +2646,7 @@ pub const cpu = struct {
     pub const winchip2 = Cpu{
         .name = "winchip2",
         .llvm_name = "winchip2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"3dnow",
             .slow_unaligned_mem_16,
             .x87,
@@ -2890,7 +2655,7 @@ pub const cpu = struct {
     pub const x86_64 = Cpu{
         .name = "x86_64",
         .llvm_name = "x86-64",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .cmov,
             .cx8,
@@ -2907,7 +2672,7 @@ pub const cpu = struct {
     pub const yonah = Cpu{
         .name = "yonah",
         .llvm_name = "yonah",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .cmov,
             .cx8,
             .fxsr,
@@ -2921,7 +2686,7 @@ pub const cpu = struct {
     pub const znver1 = Cpu{
         .name = "znver1",
         .llvm_name = "znver1",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
@@ -2965,7 +2730,7 @@ pub const cpu = struct {
     pub const znver2 = Cpu{
         .name = "znver2",
         .llvm_name = "znver2",
-        .features = featureSet(&[_]Feature{
+        .features = featureSet(&all_features, &[_]Feature{
             .@"64bit",
             .adx,
             .aes,
diff --git a/src-self-hosted/stage1.zig b/src-self-hosted/stage1.zig
index a11d3aae88..e6aa97f32c 100644
--- a/src-self-hosted/stage1.zig
+++ b/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();
diff --git a/src/all_types.hpp b/src/all_types.hpp
index df52c29a4e..fae7dae077 100644
--- a/src/all_types.hpp
+++ b/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
diff --git a/src/codegen.cpp b/src/codegen.cpp
index ffdf0e5bb0..f7cfc95b3a 100644
--- a/src/codegen.cpp
+++ b/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,
diff --git a/src/main.cpp b/src/main.cpp
index d12ae850fa..bc181f3d5d 100644
--- a/src/main.cpp
+++ b/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;