42e5f3bfdbadded4634c4ff596cd11aaad409ba9 - zig - fork of https://codeberg.org/ziglang/zig

blob 42e5f3bf (66319B) - Raw
      1 //! This file is auto-generated by tools/update_cpu_features.zig.
      2 
      3 const std = @import("../std.zig");
      4 const CpuFeature = std.Target.Cpu.Feature;
      5 const CpuModel = std.Target.Cpu.Model;
      6 
      7 pub const Feature = enum {
      8     @"32bit",
      9     @"8msecext",
     10     a76,
     11     aclass,
     12     acquire_release,
     13     aes,
     14     avoid_movs_shop,
     15     avoid_partial_cpsr,
     16     bf16,
     17     cde,
     18     cdecp0,
     19     cdecp1,
     20     cdecp2,
     21     cdecp3,
     22     cdecp4,
     23     cdecp5,
     24     cdecp6,
     25     cdecp7,
     26     cheap_predicable_cpsr,
     27     crc,
     28     crypto,
     29     d32,
     30     db,
     31     dfb,
     32     disable_postra_scheduler,
     33     dont_widen_vmovs,
     34     dotprod,
     35     dsp,
     36     execute_only,
     37     expand_fp_mlx,
     38     exynos,
     39     fp16,
     40     fp16fml,
     41     fp64,
     42     fp_armv8,
     43     fp_armv8d16,
     44     fp_armv8d16sp,
     45     fp_armv8sp,
     46     fpao,
     47     fpregs,
     48     fpregs16,
     49     fpregs64,
     50     fullfp16,
     51     fuse_aes,
     52     fuse_literals,
     53     harden_sls_blr,
     54     harden_sls_nocomdat,
     55     harden_sls_retbr,
     56     has_v4t,
     57     has_v5t,
     58     has_v5te,
     59     has_v6,
     60     has_v6k,
     61     has_v6m,
     62     has_v6t2,
     63     has_v7,
     64     has_v7clrex,
     65     has_v8,
     66     has_v8_1a,
     67     has_v8_1m_main,
     68     has_v8_2a,
     69     has_v8_3a,
     70     has_v8_4a,
     71     has_v8_5a,
     72     has_v8_6a,
     73     has_v8_7a,
     74     has_v8m,
     75     has_v8m_main,
     76     hwdiv,
     77     hwdiv_arm,
     78     i8mm,
     79     iwmmxt,
     80     iwmmxt2,
     81     lob,
     82     long_calls,
     83     loop_align,
     84     m3,
     85     mclass,
     86     mp,
     87     muxed_units,
     88     mve,
     89     mve1beat,
     90     mve2beat,
     91     mve4beat,
     92     mve_fp,
     93     nacl_trap,
     94     neon,
     95     neon_fpmovs,
     96     neonfp,
     97     no_branch_predictor,
     98     no_movt,
     99     no_neg_immediates,
    100     noarm,
    101     nonpipelined_vfp,
    102     perfmon,
    103     prefer_ishst,
    104     prefer_vmovsr,
    105     prof_unpr,
    106     r4,
    107     ras,
    108     rclass,
    109     read_tp_hard,
    110     reserve_r9,
    111     ret_addr_stack,
    112     sb,
    113     sha2,
    114     slow_fp_brcc,
    115     slow_load_D_subreg,
    116     slow_odd_reg,
    117     slow_vdup32,
    118     slow_vgetlni32,
    119     slowfpvfmx,
    120     slowfpvmlx,
    121     soft_float,
    122     splat_vfp_neon,
    123     strict_align,
    124     swift,
    125     thumb2,
    126     thumb_mode,
    127     trustzone,
    128     use_misched,
    129     v2,
    130     v2a,
    131     v3,
    132     v3m,
    133     v4,
    134     v4t,
    135     v5t,
    136     v5te,
    137     v5tej,
    138     v6,
    139     v6j,
    140     v6k,
    141     v6kz,
    142     v6m,
    143     v6sm,
    144     v6t2,
    145     v7a,
    146     v7em,
    147     v7k,
    148     v7m,
    149     v7r,
    150     v7s,
    151     v7ve,
    152     v8_1a,
    153     v8_1m_main,
    154     v8_2a,
    155     v8_3a,
    156     v8_4a,
    157     v8_5a,
    158     v8_6a,
    159     v8_7a,
    160     v8a,
    161     v8m,
    162     v8m_main,
    163     v8r,
    164     vfp2,
    165     vfp2sp,
    166     vfp3,
    167     vfp3d16,
    168     vfp3d16sp,
    169     vfp3sp,
    170     vfp4,
    171     vfp4d16,
    172     vfp4d16sp,
    173     vfp4sp,
    174     virtualization,
    175     vldn_align,
    176     vmlx_forwarding,
    177     vmlx_hazards,
    178     wide_stride_vfp,
    179     xscale,
    180     zcz,
    181 };
    182 
    183 pub const featureSet = CpuFeature.feature_set_fns(Feature).featureSet;
    184 pub const featureSetHas = CpuFeature.feature_set_fns(Feature).featureSetHas;
    185 pub const featureSetHasAny = CpuFeature.feature_set_fns(Feature).featureSetHasAny;
    186 pub const featureSetHasAll = CpuFeature.feature_set_fns(Feature).featureSetHasAll;
    187 
    188 pub const all_features = blk: {
    189     @setEvalBranchQuota(10000);
    190     const len = @typeInfo(Feature).Enum.fields.len;
    191     std.debug.assert(len <= CpuFeature.Set.needed_bit_count);
    192     var result: [len]CpuFeature = undefined;
    193     result[@enumToInt(Feature.@"32bit")] = .{
    194         .llvm_name = "32bit",
    195         .description = "Prefer 32-bit Thumb instrs",
    196         .dependencies = featureSet(&[_]Feature{}),
    197     };
    198     result[@enumToInt(Feature.@"8msecext")] = .{
    199         .llvm_name = "8msecext",
    200         .description = "Enable support for ARMv8-M Security Extensions",
    201         .dependencies = featureSet(&[_]Feature{}),
    202     };
    203     result[@enumToInt(Feature.a76)] = .{
    204         .llvm_name = "a76",
    205         .description = "Cortex-A76 ARM processors",
    206         .dependencies = featureSet(&[_]Feature{}),
    207     };
    208     result[@enumToInt(Feature.aclass)] = .{
    209         .llvm_name = "aclass",
    210         .description = "Is application profile ('A' series)",
    211         .dependencies = featureSet(&[_]Feature{}),
    212     };
    213     result[@enumToInt(Feature.acquire_release)] = .{
    214         .llvm_name = "acquire-release",
    215         .description = "Has v8 acquire/release (lda/ldaex  etc) instructions",
    216         .dependencies = featureSet(&[_]Feature{}),
    217     };
    218     result[@enumToInt(Feature.aes)] = .{
    219         .llvm_name = "aes",
    220         .description = "Enable AES support",
    221         .dependencies = featureSet(&[_]Feature{
    222             .neon,
    223         }),
    224     };
    225     result[@enumToInt(Feature.avoid_movs_shop)] = .{
    226         .llvm_name = "avoid-movs-shop",
    227         .description = "Avoid movs instructions with shifter operand",
    228         .dependencies = featureSet(&[_]Feature{}),
    229     };
    230     result[@enumToInt(Feature.avoid_partial_cpsr)] = .{
    231         .llvm_name = "avoid-partial-cpsr",
    232         .description = "Avoid CPSR partial update for OOO execution",
    233         .dependencies = featureSet(&[_]Feature{}),
    234     };
    235     result[@enumToInt(Feature.bf16)] = .{
    236         .llvm_name = "bf16",
    237         .description = "Enable support for BFloat16 instructions",
    238         .dependencies = featureSet(&[_]Feature{
    239             .neon,
    240         }),
    241     };
    242     result[@enumToInt(Feature.cde)] = .{
    243         .llvm_name = "cde",
    244         .description = "Support CDE instructions",
    245         .dependencies = featureSet(&[_]Feature{
    246             .has_v8m_main,
    247         }),
    248     };
    249     result[@enumToInt(Feature.cdecp0)] = .{
    250         .llvm_name = "cdecp0",
    251         .description = "Coprocessor 0 ISA is CDEv1",
    252         .dependencies = featureSet(&[_]Feature{
    253             .cde,
    254         }),
    255     };
    256     result[@enumToInt(Feature.cdecp1)] = .{
    257         .llvm_name = "cdecp1",
    258         .description = "Coprocessor 1 ISA is CDEv1",
    259         .dependencies = featureSet(&[_]Feature{
    260             .cde,
    261         }),
    262     };
    263     result[@enumToInt(Feature.cdecp2)] = .{
    264         .llvm_name = "cdecp2",
    265         .description = "Coprocessor 2 ISA is CDEv1",
    266         .dependencies = featureSet(&[_]Feature{
    267             .cde,
    268         }),
    269     };
    270     result[@enumToInt(Feature.cdecp3)] = .{
    271         .llvm_name = "cdecp3",
    272         .description = "Coprocessor 3 ISA is CDEv1",
    273         .dependencies = featureSet(&[_]Feature{
    274             .cde,
    275         }),
    276     };
    277     result[@enumToInt(Feature.cdecp4)] = .{
    278         .llvm_name = "cdecp4",
    279         .description = "Coprocessor 4 ISA is CDEv1",
    280         .dependencies = featureSet(&[_]Feature{
    281             .cde,
    282         }),
    283     };
    284     result[@enumToInt(Feature.cdecp5)] = .{
    285         .llvm_name = "cdecp5",
    286         .description = "Coprocessor 5 ISA is CDEv1",
    287         .dependencies = featureSet(&[_]Feature{
    288             .cde,
    289         }),
    290     };
    291     result[@enumToInt(Feature.cdecp6)] = .{
    292         .llvm_name = "cdecp6",
    293         .description = "Coprocessor 6 ISA is CDEv1",
    294         .dependencies = featureSet(&[_]Feature{
    295             .cde,
    296         }),
    297     };
    298     result[@enumToInt(Feature.cdecp7)] = .{
    299         .llvm_name = "cdecp7",
    300         .description = "Coprocessor 7 ISA is CDEv1",
    301         .dependencies = featureSet(&[_]Feature{
    302             .cde,
    303         }),
    304     };
    305     result[@enumToInt(Feature.cheap_predicable_cpsr)] = .{
    306         .llvm_name = "cheap-predicable-cpsr",
    307         .description = "Disable +1 predication cost for instructions updating CPSR",
    308         .dependencies = featureSet(&[_]Feature{}),
    309     };
    310     result[@enumToInt(Feature.crc)] = .{
    311         .llvm_name = "crc",
    312         .description = "Enable support for CRC instructions",
    313         .dependencies = featureSet(&[_]Feature{}),
    314     };
    315     result[@enumToInt(Feature.crypto)] = .{
    316         .llvm_name = "crypto",
    317         .description = "Enable support for Cryptography extensions",
    318         .dependencies = featureSet(&[_]Feature{
    319             .aes,
    320             .sha2,
    321         }),
    322     };
    323     result[@enumToInt(Feature.d32)] = .{
    324         .llvm_name = "d32",
    325         .description = "Extend FP to 32 double registers",
    326         .dependencies = featureSet(&[_]Feature{}),
    327     };
    328     result[@enumToInt(Feature.db)] = .{
    329         .llvm_name = "db",
    330         .description = "Has data barrier (dmb/dsb) instructions",
    331         .dependencies = featureSet(&[_]Feature{}),
    332     };
    333     result[@enumToInt(Feature.dfb)] = .{
    334         .llvm_name = "dfb",
    335         .description = "Has full data barrier (dfb) instruction",
    336         .dependencies = featureSet(&[_]Feature{}),
    337     };
    338     result[@enumToInt(Feature.disable_postra_scheduler)] = .{
    339         .llvm_name = "disable-postra-scheduler",
    340         .description = "Don't schedule again after register allocation",
    341         .dependencies = featureSet(&[_]Feature{}),
    342     };
    343     result[@enumToInt(Feature.dont_widen_vmovs)] = .{
    344         .llvm_name = "dont-widen-vmovs",
    345         .description = "Don't widen VMOVS to VMOVD",
    346         .dependencies = featureSet(&[_]Feature{}),
    347     };
    348     result[@enumToInt(Feature.dotprod)] = .{
    349         .llvm_name = "dotprod",
    350         .description = "Enable support for dot product instructions",
    351         .dependencies = featureSet(&[_]Feature{
    352             .neon,
    353         }),
    354     };
    355     result[@enumToInt(Feature.dsp)] = .{
    356         .llvm_name = "dsp",
    357         .description = "Supports DSP instructions in ARM and/or Thumb2",
    358         .dependencies = featureSet(&[_]Feature{}),
    359     };
    360     result[@enumToInt(Feature.execute_only)] = .{
    361         .llvm_name = "execute-only",
    362         .description = "Enable the generation of execute only code.",
    363         .dependencies = featureSet(&[_]Feature{}),
    364     };
    365     result[@enumToInt(Feature.expand_fp_mlx)] = .{
    366         .llvm_name = "expand-fp-mlx",
    367         .description = "Expand VFP/NEON MLA/MLS instructions",
    368         .dependencies = featureSet(&[_]Feature{}),
    369     };
    370     result[@enumToInt(Feature.exynos)] = .{
    371         .llvm_name = "exynos",
    372         .description = "Samsung Exynos processors",
    373         .dependencies = featureSet(&[_]Feature{
    374             .crc,
    375             .crypto,
    376             .expand_fp_mlx,
    377             .fuse_aes,
    378             .fuse_literals,
    379             .hwdiv,
    380             .hwdiv_arm,
    381             .prof_unpr,
    382             .ret_addr_stack,
    383             .slow_fp_brcc,
    384             .slow_vdup32,
    385             .slow_vgetlni32,
    386             .slowfpvfmx,
    387             .slowfpvmlx,
    388             .splat_vfp_neon,
    389             .wide_stride_vfp,
    390             .zcz,
    391         }),
    392     };
    393     result[@enumToInt(Feature.fp16)] = .{
    394         .llvm_name = "fp16",
    395         .description = "Enable half-precision floating point",
    396         .dependencies = featureSet(&[_]Feature{}),
    397     };
    398     result[@enumToInt(Feature.fp16fml)] = .{
    399         .llvm_name = "fp16fml",
    400         .description = "Enable full half-precision floating point fml instructions",
    401         .dependencies = featureSet(&[_]Feature{
    402             .fullfp16,
    403         }),
    404     };
    405     result[@enumToInt(Feature.fp64)] = .{
    406         .llvm_name = "fp64",
    407         .description = "Floating point unit supports double precision",
    408         .dependencies = featureSet(&[_]Feature{
    409             .fpregs64,
    410         }),
    411     };
    412     result[@enumToInt(Feature.fp_armv8)] = .{
    413         .llvm_name = "fp-armv8",
    414         .description = "Enable ARMv8 FP",
    415         .dependencies = featureSet(&[_]Feature{
    416             .fp_armv8d16,
    417             .fp_armv8sp,
    418             .vfp4,
    419         }),
    420     };
    421     result[@enumToInt(Feature.fp_armv8d16)] = .{
    422         .llvm_name = "fp-armv8d16",
    423         .description = "Enable ARMv8 FP with only 16 d-registers",
    424         .dependencies = featureSet(&[_]Feature{
    425             .fp_armv8d16sp,
    426             .vfp4d16,
    427         }),
    428     };
    429     result[@enumToInt(Feature.fp_armv8d16sp)] = .{
    430         .llvm_name = "fp-armv8d16sp",
    431         .description = "Enable ARMv8 FP with only 16 d-registers and no double precision",
    432         .dependencies = featureSet(&[_]Feature{
    433             .vfp4d16sp,
    434         }),
    435     };
    436     result[@enumToInt(Feature.fp_armv8sp)] = .{
    437         .llvm_name = "fp-armv8sp",
    438         .description = "Enable ARMv8 FP with no double precision",
    439         .dependencies = featureSet(&[_]Feature{
    440             .fp_armv8d16sp,
    441             .vfp4sp,
    442         }),
    443     };
    444     result[@enumToInt(Feature.fpao)] = .{
    445         .llvm_name = "fpao",
    446         .description = "Enable fast computation of positive address offsets",
    447         .dependencies = featureSet(&[_]Feature{}),
    448     };
    449     result[@enumToInt(Feature.fpregs)] = .{
    450         .llvm_name = "fpregs",
    451         .description = "Enable FP registers",
    452         .dependencies = featureSet(&[_]Feature{}),
    453     };
    454     result[@enumToInt(Feature.fpregs16)] = .{
    455         .llvm_name = "fpregs16",
    456         .description = "Enable 16-bit FP registers",
    457         .dependencies = featureSet(&[_]Feature{
    458             .fpregs,
    459         }),
    460     };
    461     result[@enumToInt(Feature.fpregs64)] = .{
    462         .llvm_name = "fpregs64",
    463         .description = "Enable 64-bit FP registers",
    464         .dependencies = featureSet(&[_]Feature{
    465             .fpregs,
    466         }),
    467     };
    468     result[@enumToInt(Feature.fullfp16)] = .{
    469         .llvm_name = "fullfp16",
    470         .description = "Enable full half-precision floating point",
    471         .dependencies = featureSet(&[_]Feature{
    472             .fp_armv8d16sp,
    473             .fpregs16,
    474         }),
    475     };
    476     result[@enumToInt(Feature.fuse_aes)] = .{
    477         .llvm_name = "fuse-aes",
    478         .description = "CPU fuses AES crypto operations",
    479         .dependencies = featureSet(&[_]Feature{}),
    480     };
    481     result[@enumToInt(Feature.fuse_literals)] = .{
    482         .llvm_name = "fuse-literals",
    483         .description = "CPU fuses literal generation operations",
    484         .dependencies = featureSet(&[_]Feature{}),
    485     };
    486     result[@enumToInt(Feature.harden_sls_blr)] = .{
    487         .llvm_name = "harden-sls-blr",
    488         .description = "Harden against straight line speculation across indirect calls",
    489         .dependencies = featureSet(&[_]Feature{}),
    490     };
    491     result[@enumToInt(Feature.harden_sls_nocomdat)] = .{
    492         .llvm_name = "harden-sls-nocomdat",
    493         .description = "Generate thunk code for SLS mitigation in the normal text section",
    494         .dependencies = featureSet(&[_]Feature{}),
    495     };
    496     result[@enumToInt(Feature.harden_sls_retbr)] = .{
    497         .llvm_name = "harden-sls-retbr",
    498         .description = "Harden against straight line speculation across RETurn and BranchRegister instructions",
    499         .dependencies = featureSet(&[_]Feature{}),
    500     };
    501     result[@enumToInt(Feature.has_v4t)] = .{
    502         .llvm_name = "v4t",
    503         .description = "Support ARM v4T instructions",
    504         .dependencies = featureSet(&[_]Feature{}),
    505     };
    506     result[@enumToInt(Feature.has_v5t)] = .{
    507         .llvm_name = "v5t",
    508         .description = "Support ARM v5T instructions",
    509         .dependencies = featureSet(&[_]Feature{
    510             .has_v4t,
    511         }),
    512     };
    513     result[@enumToInt(Feature.has_v5te)] = .{
    514         .llvm_name = "v5te",
    515         .description = "Support ARM v5TE, v5TEj, and v5TExp instructions",
    516         .dependencies = featureSet(&[_]Feature{
    517             .has_v5t,
    518         }),
    519     };
    520     result[@enumToInt(Feature.has_v6)] = .{
    521         .llvm_name = "v6",
    522         .description = "Support ARM v6 instructions",
    523         .dependencies = featureSet(&[_]Feature{
    524             .has_v5te,
    525         }),
    526     };
    527     result[@enumToInt(Feature.has_v6k)] = .{
    528         .llvm_name = "v6k",
    529         .description = "Support ARM v6k instructions",
    530         .dependencies = featureSet(&[_]Feature{
    531             .has_v6,
    532         }),
    533     };
    534     result[@enumToInt(Feature.has_v6m)] = .{
    535         .llvm_name = "v6m",
    536         .description = "Support ARM v6M instructions",
    537         .dependencies = featureSet(&[_]Feature{
    538             .has_v6,
    539         }),
    540     };
    541     result[@enumToInt(Feature.has_v6t2)] = .{
    542         .llvm_name = "v6t2",
    543         .description = "Support ARM v6t2 instructions",
    544         .dependencies = featureSet(&[_]Feature{
    545             .has_v6k,
    546             .has_v8m,
    547             .thumb2,
    548         }),
    549     };
    550     result[@enumToInt(Feature.has_v7)] = .{
    551         .llvm_name = "v7",
    552         .description = "Support ARM v7 instructions",
    553         .dependencies = featureSet(&[_]Feature{
    554             .has_v6t2,
    555             .has_v7clrex,
    556             .perfmon,
    557         }),
    558     };
    559     result[@enumToInt(Feature.has_v7clrex)] = .{
    560         .llvm_name = "v7clrex",
    561         .description = "Has v7 clrex instruction",
    562         .dependencies = featureSet(&[_]Feature{}),
    563     };
    564     result[@enumToInt(Feature.has_v8)] = .{
    565         .llvm_name = "v8",
    566         .description = "Support ARM v8 instructions",
    567         .dependencies = featureSet(&[_]Feature{
    568             .acquire_release,
    569             .has_v7,
    570         }),
    571     };
    572     result[@enumToInt(Feature.has_v8_1a)] = .{
    573         .llvm_name = "v8.1a",
    574         .description = "Support ARM v8.1a instructions",
    575         .dependencies = featureSet(&[_]Feature{
    576             .has_v8,
    577         }),
    578     };
    579     result[@enumToInt(Feature.has_v8_1m_main)] = .{
    580         .llvm_name = "v8.1m.main",
    581         .description = "Support ARM v8-1M Mainline instructions",
    582         .dependencies = featureSet(&[_]Feature{
    583             .has_v8m_main,
    584         }),
    585     };
    586     result[@enumToInt(Feature.has_v8_2a)] = .{
    587         .llvm_name = "v8.2a",
    588         .description = "Support ARM v8.2a instructions",
    589         .dependencies = featureSet(&[_]Feature{
    590             .has_v8_1a,
    591         }),
    592     };
    593     result[@enumToInt(Feature.has_v8_3a)] = .{
    594         .llvm_name = "v8.3a",
    595         .description = "Support ARM v8.3a instructions",
    596         .dependencies = featureSet(&[_]Feature{
    597             .has_v8_2a,
    598         }),
    599     };
    600     result[@enumToInt(Feature.has_v8_4a)] = .{
    601         .llvm_name = "v8.4a",
    602         .description = "Support ARM v8.4a instructions",
    603         .dependencies = featureSet(&[_]Feature{
    604             .dotprod,
    605             .has_v8_3a,
    606         }),
    607     };
    608     result[@enumToInt(Feature.has_v8_5a)] = .{
    609         .llvm_name = "v8.5a",
    610         .description = "Support ARM v8.5a instructions",
    611         .dependencies = featureSet(&[_]Feature{
    612             .has_v8_4a,
    613             .sb,
    614         }),
    615     };
    616     result[@enumToInt(Feature.has_v8_6a)] = .{
    617         .llvm_name = "v8.6a",
    618         .description = "Support ARM v8.6a instructions",
    619         .dependencies = featureSet(&[_]Feature{
    620             .bf16,
    621             .has_v8_5a,
    622             .i8mm,
    623         }),
    624     };
    625     result[@enumToInt(Feature.has_v8_7a)] = .{
    626         .llvm_name = "v8.7a",
    627         .description = "Support ARM v8.7a instructions",
    628         .dependencies = featureSet(&[_]Feature{
    629             .has_v8_6a,
    630         }),
    631     };
    632     result[@enumToInt(Feature.has_v8m)] = .{
    633         .llvm_name = "v8m",
    634         .description = "Support ARM v8M Baseline instructions",
    635         .dependencies = featureSet(&[_]Feature{
    636             .has_v6m,
    637         }),
    638     };
    639     result[@enumToInt(Feature.has_v8m_main)] = .{
    640         .llvm_name = "v8m.main",
    641         .description = "Support ARM v8M Mainline instructions",
    642         .dependencies = featureSet(&[_]Feature{
    643             .has_v7,
    644         }),
    645     };
    646     result[@enumToInt(Feature.hwdiv)] = .{
    647         .llvm_name = "hwdiv",
    648         .description = "Enable divide instructions in Thumb",
    649         .dependencies = featureSet(&[_]Feature{}),
    650     };
    651     result[@enumToInt(Feature.hwdiv_arm)] = .{
    652         .llvm_name = "hwdiv-arm",
    653         .description = "Enable divide instructions in ARM mode",
    654         .dependencies = featureSet(&[_]Feature{}),
    655     };
    656     result[@enumToInt(Feature.i8mm)] = .{
    657         .llvm_name = "i8mm",
    658         .description = "Enable Matrix Multiply Int8 Extension",
    659         .dependencies = featureSet(&[_]Feature{
    660             .neon,
    661         }),
    662     };
    663     result[@enumToInt(Feature.iwmmxt)] = .{
    664         .llvm_name = "iwmmxt",
    665         .description = "ARMv5te architecture",
    666         .dependencies = featureSet(&[_]Feature{
    667             .v5te,
    668         }),
    669     };
    670     result[@enumToInt(Feature.iwmmxt2)] = .{
    671         .llvm_name = "iwmmxt2",
    672         .description = "ARMv5te architecture",
    673         .dependencies = featureSet(&[_]Feature{
    674             .v5te,
    675         }),
    676     };
    677     result[@enumToInt(Feature.lob)] = .{
    678         .llvm_name = "lob",
    679         .description = "Enable Low Overhead Branch extensions",
    680         .dependencies = featureSet(&[_]Feature{}),
    681     };
    682     result[@enumToInt(Feature.long_calls)] = .{
    683         .llvm_name = "long-calls",
    684         .description = "Generate calls via indirect call instructions",
    685         .dependencies = featureSet(&[_]Feature{}),
    686     };
    687     result[@enumToInt(Feature.loop_align)] = .{
    688         .llvm_name = "loop-align",
    689         .description = "Prefer 32-bit alignment for loops",
    690         .dependencies = featureSet(&[_]Feature{}),
    691     };
    692     result[@enumToInt(Feature.m3)] = .{
    693         .llvm_name = "m3",
    694         .description = "Cortex-M3 ARM processors",
    695         .dependencies = featureSet(&[_]Feature{}),
    696     };
    697     result[@enumToInt(Feature.mclass)] = .{
    698         .llvm_name = "mclass",
    699         .description = "Is microcontroller profile ('M' series)",
    700         .dependencies = featureSet(&[_]Feature{}),
    701     };
    702     result[@enumToInt(Feature.mp)] = .{
    703         .llvm_name = "mp",
    704         .description = "Supports Multiprocessing extension",
    705         .dependencies = featureSet(&[_]Feature{}),
    706     };
    707     result[@enumToInt(Feature.muxed_units)] = .{
    708         .llvm_name = "muxed-units",
    709         .description = "Has muxed AGU and NEON/FPU",
    710         .dependencies = featureSet(&[_]Feature{}),
    711     };
    712     result[@enumToInt(Feature.mve)] = .{
    713         .llvm_name = "mve",
    714         .description = "Support M-Class Vector Extension with integer ops",
    715         .dependencies = featureSet(&[_]Feature{
    716             .dsp,
    717             .fpregs16,
    718             .fpregs64,
    719             .has_v8_1m_main,
    720         }),
    721     };
    722     result[@enumToInt(Feature.mve1beat)] = .{
    723         .llvm_name = "mve1beat",
    724         .description = "Model MVE instructions as a 1 beat per tick architecture",
    725         .dependencies = featureSet(&[_]Feature{}),
    726     };
    727     result[@enumToInt(Feature.mve2beat)] = .{
    728         .llvm_name = "mve2beat",
    729         .description = "Model MVE instructions as a 2 beats per tick architecture",
    730         .dependencies = featureSet(&[_]Feature{}),
    731     };
    732     result[@enumToInt(Feature.mve4beat)] = .{
    733         .llvm_name = "mve4beat",
    734         .description = "Model MVE instructions as a 4 beats per tick architecture",
    735         .dependencies = featureSet(&[_]Feature{}),
    736     };
    737     result[@enumToInt(Feature.mve_fp)] = .{
    738         .llvm_name = "mve.fp",
    739         .description = "Support M-Class Vector Extension with integer and floating ops",
    740         .dependencies = featureSet(&[_]Feature{
    741             .fullfp16,
    742             .mve,
    743         }),
    744     };
    745     result[@enumToInt(Feature.nacl_trap)] = .{
    746         .llvm_name = "nacl-trap",
    747         .description = "NaCl trap",
    748         .dependencies = featureSet(&[_]Feature{}),
    749     };
    750     result[@enumToInt(Feature.neon)] = .{
    751         .llvm_name = "neon",
    752         .description = "Enable NEON instructions",
    753         .dependencies = featureSet(&[_]Feature{
    754             .vfp3,
    755         }),
    756     };
    757     result[@enumToInt(Feature.neon_fpmovs)] = .{
    758         .llvm_name = "neon-fpmovs",
    759         .description = "Convert VMOVSR, VMOVRS, VMOVS to NEON",
    760         .dependencies = featureSet(&[_]Feature{}),
    761     };
    762     result[@enumToInt(Feature.neonfp)] = .{
    763         .llvm_name = "neonfp",
    764         .description = "Use NEON for single precision FP",
    765         .dependencies = featureSet(&[_]Feature{}),
    766     };
    767     result[@enumToInt(Feature.no_branch_predictor)] = .{
    768         .llvm_name = "no-branch-predictor",
    769         .description = "Has no branch predictor",
    770         .dependencies = featureSet(&[_]Feature{}),
    771     };
    772     result[@enumToInt(Feature.no_movt)] = .{
    773         .llvm_name = "no-movt",
    774         .description = "Don't use movt/movw pairs for 32-bit imms",
    775         .dependencies = featureSet(&[_]Feature{}),
    776     };
    777     result[@enumToInt(Feature.no_neg_immediates)] = .{
    778         .llvm_name = "no-neg-immediates",
    779         .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.",
    780         .dependencies = featureSet(&[_]Feature{}),
    781     };
    782     result[@enumToInt(Feature.noarm)] = .{
    783         .llvm_name = "noarm",
    784         .description = "Does not support ARM mode execution",
    785         .dependencies = featureSet(&[_]Feature{}),
    786     };
    787     result[@enumToInt(Feature.nonpipelined_vfp)] = .{
    788         .llvm_name = "nonpipelined-vfp",
    789         .description = "VFP instructions are not pipelined",
    790         .dependencies = featureSet(&[_]Feature{}),
    791     };
    792     result[@enumToInt(Feature.perfmon)] = .{
    793         .llvm_name = "perfmon",
    794         .description = "Enable support for Performance Monitor extensions",
    795         .dependencies = featureSet(&[_]Feature{}),
    796     };
    797     result[@enumToInt(Feature.prefer_ishst)] = .{
    798         .llvm_name = "prefer-ishst",
    799         .description = "Prefer ISHST barriers",
    800         .dependencies = featureSet(&[_]Feature{}),
    801     };
    802     result[@enumToInt(Feature.prefer_vmovsr)] = .{
    803         .llvm_name = "prefer-vmovsr",
    804         .description = "Prefer VMOVSR",
    805         .dependencies = featureSet(&[_]Feature{}),
    806     };
    807     result[@enumToInt(Feature.prof_unpr)] = .{
    808         .llvm_name = "prof-unpr",
    809         .description = "Is profitable to unpredicate",
    810         .dependencies = featureSet(&[_]Feature{}),
    811     };
    812     result[@enumToInt(Feature.r4)] = .{
    813         .llvm_name = "r4",
    814         .description = "Cortex-R4 ARM processors",
    815         .dependencies = featureSet(&[_]Feature{}),
    816     };
    817     result[@enumToInt(Feature.ras)] = .{
    818         .llvm_name = "ras",
    819         .description = "Enable Reliability, Availability and Serviceability extensions",
    820         .dependencies = featureSet(&[_]Feature{}),
    821     };
    822     result[@enumToInt(Feature.rclass)] = .{
    823         .llvm_name = "rclass",
    824         .description = "Is realtime profile ('R' series)",
    825         .dependencies = featureSet(&[_]Feature{}),
    826     };
    827     result[@enumToInt(Feature.read_tp_hard)] = .{
    828         .llvm_name = "read-tp-hard",
    829         .description = "Reading thread pointer from register",
    830         .dependencies = featureSet(&[_]Feature{}),
    831     };
    832     result[@enumToInt(Feature.reserve_r9)] = .{
    833         .llvm_name = "reserve-r9",
    834         .description = "Reserve R9, making it unavailable as GPR",
    835         .dependencies = featureSet(&[_]Feature{}),
    836     };
    837     result[@enumToInt(Feature.ret_addr_stack)] = .{
    838         .llvm_name = "ret-addr-stack",
    839         .description = "Has return address stack",
    840         .dependencies = featureSet(&[_]Feature{}),
    841     };
    842     result[@enumToInt(Feature.sb)] = .{
    843         .llvm_name = "sb",
    844         .description = "Enable v8.5a Speculation Barrier",
    845         .dependencies = featureSet(&[_]Feature{}),
    846     };
    847     result[@enumToInt(Feature.sha2)] = .{
    848         .llvm_name = "sha2",
    849         .description = "Enable SHA1 and SHA256 support",
    850         .dependencies = featureSet(&[_]Feature{
    851             .neon,
    852         }),
    853     };
    854     result[@enumToInt(Feature.slow_fp_brcc)] = .{
    855         .llvm_name = "slow-fp-brcc",
    856         .description = "FP compare + branch is slow",
    857         .dependencies = featureSet(&[_]Feature{}),
    858     };
    859     result[@enumToInt(Feature.slow_load_D_subreg)] = .{
    860         .llvm_name = "slow-load-D-subreg",
    861         .description = "Loading into D subregs is slow",
    862         .dependencies = featureSet(&[_]Feature{}),
    863     };
    864     result[@enumToInt(Feature.slow_odd_reg)] = .{
    865         .llvm_name = "slow-odd-reg",
    866         .description = "VLDM/VSTM starting with an odd register is slow",
    867         .dependencies = featureSet(&[_]Feature{}),
    868     };
    869     result[@enumToInt(Feature.slow_vdup32)] = .{
    870         .llvm_name = "slow-vdup32",
    871         .description = "Has slow VDUP32 - prefer VMOV",
    872         .dependencies = featureSet(&[_]Feature{}),
    873     };
    874     result[@enumToInt(Feature.slow_vgetlni32)] = .{
    875         .llvm_name = "slow-vgetlni32",
    876         .description = "Has slow VGETLNi32 - prefer VMOV",
    877         .dependencies = featureSet(&[_]Feature{}),
    878     };
    879     result[@enumToInt(Feature.slowfpvfmx)] = .{
    880         .llvm_name = "slowfpvfmx",
    881         .description = "Disable VFP / NEON FMA instructions",
    882         .dependencies = featureSet(&[_]Feature{}),
    883     };
    884     result[@enumToInt(Feature.slowfpvmlx)] = .{
    885         .llvm_name = "slowfpvmlx",
    886         .description = "Disable VFP / NEON MAC instructions",
    887         .dependencies = featureSet(&[_]Feature{}),
    888     };
    889     result[@enumToInt(Feature.soft_float)] = .{
    890         .llvm_name = "soft-float",
    891         .description = "Use software floating point features.",
    892         .dependencies = featureSet(&[_]Feature{}),
    893     };
    894     result[@enumToInt(Feature.splat_vfp_neon)] = .{
    895         .llvm_name = "splat-vfp-neon",
    896         .description = "Splat register from VFP to NEON",
    897         .dependencies = featureSet(&[_]Feature{
    898             .dont_widen_vmovs,
    899         }),
    900     };
    901     result[@enumToInt(Feature.strict_align)] = .{
    902         .llvm_name = "strict-align",
    903         .description = "Disallow all unaligned memory access",
    904         .dependencies = featureSet(&[_]Feature{}),
    905     };
    906     result[@enumToInt(Feature.swift)] = .{
    907         .llvm_name = "swift",
    908         .description = "Swift ARM processors",
    909         .dependencies = featureSet(&[_]Feature{}),
    910     };
    911     result[@enumToInt(Feature.thumb2)] = .{
    912         .llvm_name = "thumb2",
    913         .description = "Enable Thumb2 instructions",
    914         .dependencies = featureSet(&[_]Feature{}),
    915     };
    916     result[@enumToInt(Feature.thumb_mode)] = .{
    917         .llvm_name = "thumb-mode",
    918         .description = "Thumb mode",
    919         .dependencies = featureSet(&[_]Feature{}),
    920     };
    921     result[@enumToInt(Feature.trustzone)] = .{
    922         .llvm_name = "trustzone",
    923         .description = "Enable support for TrustZone security extensions",
    924         .dependencies = featureSet(&[_]Feature{}),
    925     };
    926     result[@enumToInt(Feature.use_misched)] = .{
    927         .llvm_name = "use-misched",
    928         .description = "Use the MachineScheduler",
    929         .dependencies = featureSet(&[_]Feature{}),
    930     };
    931     result[@enumToInt(Feature.v2)] = .{
    932         .llvm_name = "armv2",
    933         .description = "ARMv2 architecture",
    934         .dependencies = featureSet(&[_]Feature{
    935             .strict_align,
    936         }),
    937     };
    938     result[@enumToInt(Feature.v2a)] = .{
    939         .llvm_name = "armv2a",
    940         .description = "ARMv2a architecture",
    941         .dependencies = featureSet(&[_]Feature{
    942             .strict_align,
    943         }),
    944     };
    945     result[@enumToInt(Feature.v3)] = .{
    946         .llvm_name = "armv3",
    947         .description = "ARMv3 architecture",
    948         .dependencies = featureSet(&[_]Feature{
    949             .strict_align,
    950         }),
    951     };
    952     result[@enumToInt(Feature.v3m)] = .{
    953         .llvm_name = "armv3m",
    954         .description = "ARMv3m architecture",
    955         .dependencies = featureSet(&[_]Feature{
    956             .strict_align,
    957         }),
    958     };
    959     result[@enumToInt(Feature.v4)] = .{
    960         .llvm_name = "armv4",
    961         .description = "ARMv4 architecture",
    962         .dependencies = featureSet(&[_]Feature{
    963             .strict_align,
    964         }),
    965     };
    966     result[@enumToInt(Feature.v4t)] = .{
    967         .llvm_name = "armv4t",
    968         .description = "ARMv4t architecture",
    969         .dependencies = featureSet(&[_]Feature{
    970             .has_v4t,
    971             .strict_align,
    972         }),
    973     };
    974     result[@enumToInt(Feature.v5t)] = .{
    975         .llvm_name = "armv5t",
    976         .description = "ARMv5t architecture",
    977         .dependencies = featureSet(&[_]Feature{
    978             .has_v5t,
    979             .strict_align,
    980         }),
    981     };
    982     result[@enumToInt(Feature.v5te)] = .{
    983         .llvm_name = "armv5te",
    984         .description = "ARMv5te architecture",
    985         .dependencies = featureSet(&[_]Feature{
    986             .has_v5te,
    987             .strict_align,
    988         }),
    989     };
    990     result[@enumToInt(Feature.v5tej)] = .{
    991         .llvm_name = "armv5tej",
    992         .description = "ARMv5tej architecture",
    993         .dependencies = featureSet(&[_]Feature{
    994             .has_v5te,
    995             .strict_align,
    996         }),
    997     };
    998     result[@enumToInt(Feature.v6)] = .{
    999         .llvm_name = "armv6",
   1000         .description = "ARMv6 architecture",
   1001         .dependencies = featureSet(&[_]Feature{
   1002             .dsp,
   1003             .has_v6,
   1004         }),
   1005     };
   1006     result[@enumToInt(Feature.v6j)] = .{
   1007         .llvm_name = "armv6j",
   1008         .description = "ARMv7a architecture",
   1009         .dependencies = featureSet(&[_]Feature{
   1010             .v6,
   1011         }),
   1012     };
   1013     result[@enumToInt(Feature.v6k)] = .{
   1014         .llvm_name = "armv6k",
   1015         .description = "ARMv6k architecture",
   1016         .dependencies = featureSet(&[_]Feature{
   1017             .has_v6k,
   1018         }),
   1019     };
   1020     result[@enumToInt(Feature.v6kz)] = .{
   1021         .llvm_name = "armv6kz",
   1022         .description = "ARMv6kz architecture",
   1023         .dependencies = featureSet(&[_]Feature{
   1024             .has_v6k,
   1025             .trustzone,
   1026         }),
   1027     };
   1028     result[@enumToInt(Feature.v6m)] = .{
   1029         .llvm_name = "armv6-m",
   1030         .description = "ARMv6m architecture",
   1031         .dependencies = featureSet(&[_]Feature{
   1032             .db,
   1033             .has_v6m,
   1034             .mclass,
   1035             .noarm,
   1036             .strict_align,
   1037             .thumb_mode,
   1038         }),
   1039     };
   1040     result[@enumToInt(Feature.v6sm)] = .{
   1041         .llvm_name = "armv6s-m",
   1042         .description = "ARMv6sm architecture",
   1043         .dependencies = featureSet(&[_]Feature{
   1044             .db,
   1045             .has_v6m,
   1046             .mclass,
   1047             .noarm,
   1048             .strict_align,
   1049             .thumb_mode,
   1050         }),
   1051     };
   1052     result[@enumToInt(Feature.v6t2)] = .{
   1053         .llvm_name = "armv6t2",
   1054         .description = "ARMv6t2 architecture",
   1055         .dependencies = featureSet(&[_]Feature{
   1056             .dsp,
   1057             .has_v6t2,
   1058         }),
   1059     };
   1060     result[@enumToInt(Feature.v7a)] = .{
   1061         .llvm_name = "armv7-a",
   1062         .description = "ARMv7a architecture",
   1063         .dependencies = featureSet(&[_]Feature{
   1064             .aclass,
   1065             .db,
   1066             .dsp,
   1067             .has_v7,
   1068             .neon,
   1069         }),
   1070     };
   1071     result[@enumToInt(Feature.v7em)] = .{
   1072         .llvm_name = "armv7e-m",
   1073         .description = "ARMv7em architecture",
   1074         .dependencies = featureSet(&[_]Feature{
   1075             .db,
   1076             .dsp,
   1077             .has_v7,
   1078             .hwdiv,
   1079             .mclass,
   1080             .noarm,
   1081             .thumb_mode,
   1082         }),
   1083     };
   1084     result[@enumToInt(Feature.v7k)] = .{
   1085         .llvm_name = "armv7k",
   1086         .description = "ARMv7a architecture",
   1087         .dependencies = featureSet(&[_]Feature{
   1088             .v7a,
   1089         }),
   1090     };
   1091     result[@enumToInt(Feature.v7m)] = .{
   1092         .llvm_name = "armv7-m",
   1093         .description = "ARMv7m architecture",
   1094         .dependencies = featureSet(&[_]Feature{
   1095             .db,
   1096             .has_v7,
   1097             .hwdiv,
   1098             .mclass,
   1099             .noarm,
   1100             .thumb_mode,
   1101         }),
   1102     };
   1103     result[@enumToInt(Feature.v7r)] = .{
   1104         .llvm_name = "armv7-r",
   1105         .description = "ARMv7r architecture",
   1106         .dependencies = featureSet(&[_]Feature{
   1107             .db,
   1108             .dsp,
   1109             .has_v7,
   1110             .hwdiv,
   1111             .rclass,
   1112         }),
   1113     };
   1114     result[@enumToInt(Feature.v7s)] = .{
   1115         .llvm_name = "armv7s",
   1116         .description = "ARMv7a architecture",
   1117         .dependencies = featureSet(&[_]Feature{
   1118             .v7a,
   1119         }),
   1120     };
   1121     result[@enumToInt(Feature.v7ve)] = .{
   1122         .llvm_name = "armv7ve",
   1123         .description = "ARMv7ve architecture",
   1124         .dependencies = featureSet(&[_]Feature{
   1125             .aclass,
   1126             .db,
   1127             .dsp,
   1128             .has_v7,
   1129             .mp,
   1130             .neon,
   1131             .trustzone,
   1132             .virtualization,
   1133         }),
   1134     };
   1135     result[@enumToInt(Feature.v8_1a)] = .{
   1136         .llvm_name = "armv8.1-a",
   1137         .description = "ARMv81a architecture",
   1138         .dependencies = featureSet(&[_]Feature{
   1139             .aclass,
   1140             .crc,
   1141             .crypto,
   1142             .db,
   1143             .dsp,
   1144             .fp_armv8,
   1145             .has_v8_1a,
   1146             .mp,
   1147             .trustzone,
   1148             .virtualization,
   1149         }),
   1150     };
   1151     result[@enumToInt(Feature.v8_1m_main)] = .{
   1152         .llvm_name = "armv8.1-m.main",
   1153         .description = "ARMv81mMainline architecture",
   1154         .dependencies = featureSet(&[_]Feature{
   1155             .@"8msecext",
   1156             .acquire_release,
   1157             .db,
   1158             .has_v8_1m_main,
   1159             .hwdiv,
   1160             .lob,
   1161             .mclass,
   1162             .noarm,
   1163             .ras,
   1164             .thumb_mode,
   1165         }),
   1166     };
   1167     result[@enumToInt(Feature.v8_2a)] = .{
   1168         .llvm_name = "armv8.2-a",
   1169         .description = "ARMv82a architecture",
   1170         .dependencies = featureSet(&[_]Feature{
   1171             .aclass,
   1172             .crc,
   1173             .crypto,
   1174             .db,
   1175             .dsp,
   1176             .fp_armv8,
   1177             .has_v8_2a,
   1178             .mp,
   1179             .ras,
   1180             .trustzone,
   1181             .virtualization,
   1182         }),
   1183     };
   1184     result[@enumToInt(Feature.v8_3a)] = .{
   1185         .llvm_name = "armv8.3-a",
   1186         .description = "ARMv83a architecture",
   1187         .dependencies = featureSet(&[_]Feature{
   1188             .aclass,
   1189             .crc,
   1190             .crypto,
   1191             .db,
   1192             .dsp,
   1193             .fp_armv8,
   1194             .has_v8_3a,
   1195             .mp,
   1196             .ras,
   1197             .trustzone,
   1198             .virtualization,
   1199         }),
   1200     };
   1201     result[@enumToInt(Feature.v8_4a)] = .{
   1202         .llvm_name = "armv8.4-a",
   1203         .description = "ARMv84a architecture",
   1204         .dependencies = featureSet(&[_]Feature{
   1205             .aclass,
   1206             .crc,
   1207             .crypto,
   1208             .db,
   1209             .dsp,
   1210             .fp_armv8,
   1211             .has_v8_4a,
   1212             .mp,
   1213             .ras,
   1214             .trustzone,
   1215             .virtualization,
   1216         }),
   1217     };
   1218     result[@enumToInt(Feature.v8_5a)] = .{
   1219         .llvm_name = "armv8.5-a",
   1220         .description = "ARMv85a architecture",
   1221         .dependencies = featureSet(&[_]Feature{
   1222             .aclass,
   1223             .crc,
   1224             .crypto,
   1225             .db,
   1226             .dsp,
   1227             .fp_armv8,
   1228             .has_v8_5a,
   1229             .mp,
   1230             .ras,
   1231             .trustzone,
   1232             .virtualization,
   1233         }),
   1234     };
   1235     result[@enumToInt(Feature.v8_6a)] = .{
   1236         .llvm_name = "armv8.6-a",
   1237         .description = "ARMv86a architecture",
   1238         .dependencies = featureSet(&[_]Feature{
   1239             .aclass,
   1240             .crc,
   1241             .crypto,
   1242             .db,
   1243             .dsp,
   1244             .fp_armv8,
   1245             .has_v8_6a,
   1246             .mp,
   1247             .ras,
   1248             .trustzone,
   1249             .virtualization,
   1250         }),
   1251     };
   1252     result[@enumToInt(Feature.v8_7a)] = .{
   1253         .llvm_name = "armv8.7-a",
   1254         .description = "ARMv87a architecture",
   1255         .dependencies = featureSet(&[_]Feature{
   1256             .aclass,
   1257             .crc,
   1258             .crypto,
   1259             .db,
   1260             .dsp,
   1261             .fp_armv8,
   1262             .has_v8_7a,
   1263             .mp,
   1264             .ras,
   1265             .trustzone,
   1266             .virtualization,
   1267         }),
   1268     };
   1269     result[@enumToInt(Feature.v8a)] = .{
   1270         .llvm_name = "armv8-a",
   1271         .description = "ARMv8a architecture",
   1272         .dependencies = featureSet(&[_]Feature{
   1273             .aclass,
   1274             .crc,
   1275             .crypto,
   1276             .db,
   1277             .dsp,
   1278             .fp_armv8,
   1279             .has_v8,
   1280             .mp,
   1281             .trustzone,
   1282             .virtualization,
   1283         }),
   1284     };
   1285     result[@enumToInt(Feature.v8m)] = .{
   1286         .llvm_name = "armv8-m.base",
   1287         .description = "ARMv8mBaseline architecture",
   1288         .dependencies = featureSet(&[_]Feature{
   1289             .@"8msecext",
   1290             .acquire_release,
   1291             .db,
   1292             .has_v7clrex,
   1293             .has_v8m,
   1294             .hwdiv,
   1295             .mclass,
   1296             .noarm,
   1297             .strict_align,
   1298             .thumb_mode,
   1299         }),
   1300     };
   1301     result[@enumToInt(Feature.v8m_main)] = .{
   1302         .llvm_name = "armv8-m.main",
   1303         .description = "ARMv8mMainline architecture",
   1304         .dependencies = featureSet(&[_]Feature{
   1305             .@"8msecext",
   1306             .acquire_release,
   1307             .db,
   1308             .has_v8m_main,
   1309             .hwdiv,
   1310             .mclass,
   1311             .noarm,
   1312             .thumb_mode,
   1313         }),
   1314     };
   1315     result[@enumToInt(Feature.v8r)] = .{
   1316         .llvm_name = "armv8-r",
   1317         .description = "ARMv8r architecture",
   1318         .dependencies = featureSet(&[_]Feature{
   1319             .crc,
   1320             .db,
   1321             .dfb,
   1322             .dsp,
   1323             .fp_armv8,
   1324             .has_v8,
   1325             .mp,
   1326             .neon,
   1327             .rclass,
   1328             .virtualization,
   1329         }),
   1330     };
   1331     result[@enumToInt(Feature.vfp2)] = .{
   1332         .llvm_name = "vfp2",
   1333         .description = "Enable VFP2 instructions",
   1334         .dependencies = featureSet(&[_]Feature{
   1335             .fp64,
   1336             .vfp2sp,
   1337         }),
   1338     };
   1339     result[@enumToInt(Feature.vfp2sp)] = .{
   1340         .llvm_name = "vfp2sp",
   1341         .description = "Enable VFP2 instructions with no double precision",
   1342         .dependencies = featureSet(&[_]Feature{
   1343             .fpregs,
   1344         }),
   1345     };
   1346     result[@enumToInt(Feature.vfp3)] = .{
   1347         .llvm_name = "vfp3",
   1348         .description = "Enable VFP3 instructions",
   1349         .dependencies = featureSet(&[_]Feature{
   1350             .vfp3d16,
   1351             .vfp3sp,
   1352         }),
   1353     };
   1354     result[@enumToInt(Feature.vfp3d16)] = .{
   1355         .llvm_name = "vfp3d16",
   1356         .description = "Enable VFP3 instructions with only 16 d-registers",
   1357         .dependencies = featureSet(&[_]Feature{
   1358             .vfp2,
   1359             .vfp3d16sp,
   1360         }),
   1361     };
   1362     result[@enumToInt(Feature.vfp3d16sp)] = .{
   1363         .llvm_name = "vfp3d16sp",
   1364         .description = "Enable VFP3 instructions with only 16 d-registers and no double precision",
   1365         .dependencies = featureSet(&[_]Feature{
   1366             .vfp2sp,
   1367         }),
   1368     };
   1369     result[@enumToInt(Feature.vfp3sp)] = .{
   1370         .llvm_name = "vfp3sp",
   1371         .description = "Enable VFP3 instructions with no double precision",
   1372         .dependencies = featureSet(&[_]Feature{
   1373             .d32,
   1374             .vfp3d16sp,
   1375         }),
   1376     };
   1377     result[@enumToInt(Feature.vfp4)] = .{
   1378         .llvm_name = "vfp4",
   1379         .description = "Enable VFP4 instructions",
   1380         .dependencies = featureSet(&[_]Feature{
   1381             .vfp3,
   1382             .vfp4d16,
   1383             .vfp4sp,
   1384         }),
   1385     };
   1386     result[@enumToInt(Feature.vfp4d16)] = .{
   1387         .llvm_name = "vfp4d16",
   1388         .description = "Enable VFP4 instructions with only 16 d-registers",
   1389         .dependencies = featureSet(&[_]Feature{
   1390             .vfp3d16,
   1391             .vfp4d16sp,
   1392         }),
   1393     };
   1394     result[@enumToInt(Feature.vfp4d16sp)] = .{
   1395         .llvm_name = "vfp4d16sp",
   1396         .description = "Enable VFP4 instructions with only 16 d-registers and no double precision",
   1397         .dependencies = featureSet(&[_]Feature{
   1398             .fp16,
   1399             .vfp3d16sp,
   1400         }),
   1401     };
   1402     result[@enumToInt(Feature.vfp4sp)] = .{
   1403         .llvm_name = "vfp4sp",
   1404         .description = "Enable VFP4 instructions with no double precision",
   1405         .dependencies = featureSet(&[_]Feature{
   1406             .vfp3sp,
   1407             .vfp4d16sp,
   1408         }),
   1409     };
   1410     result[@enumToInt(Feature.virtualization)] = .{
   1411         .llvm_name = "virtualization",
   1412         .description = "Supports Virtualization extension",
   1413         .dependencies = featureSet(&[_]Feature{
   1414             .hwdiv,
   1415             .hwdiv_arm,
   1416         }),
   1417     };
   1418     result[@enumToInt(Feature.vldn_align)] = .{
   1419         .llvm_name = "vldn-align",
   1420         .description = "Check for VLDn unaligned access",
   1421         .dependencies = featureSet(&[_]Feature{}),
   1422     };
   1423     result[@enumToInt(Feature.vmlx_forwarding)] = .{
   1424         .llvm_name = "vmlx-forwarding",
   1425         .description = "Has multiplier accumulator forwarding",
   1426         .dependencies = featureSet(&[_]Feature{}),
   1427     };
   1428     result[@enumToInt(Feature.vmlx_hazards)] = .{
   1429         .llvm_name = "vmlx-hazards",
   1430         .description = "Has VMLx hazards",
   1431         .dependencies = featureSet(&[_]Feature{}),
   1432     };
   1433     result[@enumToInt(Feature.wide_stride_vfp)] = .{
   1434         .llvm_name = "wide-stride-vfp",
   1435         .description = "Use a wide stride when allocating VFP registers",
   1436         .dependencies = featureSet(&[_]Feature{}),
   1437     };
   1438     result[@enumToInt(Feature.xscale)] = .{
   1439         .llvm_name = "xscale",
   1440         .description = "ARMv5te architecture",
   1441         .dependencies = featureSet(&[_]Feature{
   1442             .v5te,
   1443         }),
   1444     };
   1445     result[@enumToInt(Feature.zcz)] = .{
   1446         .llvm_name = "zcz",
   1447         .description = "Has zero-cycle zeroing instructions",
   1448         .dependencies = featureSet(&[_]Feature{}),
   1449     };
   1450     const ti = @typeInfo(Feature);
   1451     for (result) |*elem, i| {
   1452         elem.index = i;
   1453         elem.name = ti.Enum.fields[i].name;
   1454     }
   1455     break :blk result;
   1456 };
   1457 
   1458 pub const cpu = struct {
   1459     pub const arm1020e = CpuModel{
   1460         .name = "arm1020e",
   1461         .llvm_name = "arm1020e",
   1462         .features = featureSet(&[_]Feature{
   1463             .v5te,
   1464         }),
   1465     };
   1466     pub const arm1020t = CpuModel{
   1467         .name = "arm1020t",
   1468         .llvm_name = "arm1020t",
   1469         .features = featureSet(&[_]Feature{
   1470             .v5t,
   1471         }),
   1472     };
   1473     pub const arm1022e = CpuModel{
   1474         .name = "arm1022e",
   1475         .llvm_name = "arm1022e",
   1476         .features = featureSet(&[_]Feature{
   1477             .v5te,
   1478         }),
   1479     };
   1480     pub const arm10e = CpuModel{
   1481         .name = "arm10e",
   1482         .llvm_name = "arm10e",
   1483         .features = featureSet(&[_]Feature{
   1484             .v5te,
   1485         }),
   1486     };
   1487     pub const arm10tdmi = CpuModel{
   1488         .name = "arm10tdmi",
   1489         .llvm_name = "arm10tdmi",
   1490         .features = featureSet(&[_]Feature{
   1491             .v5t,
   1492         }),
   1493     };
   1494     pub const arm1136j_s = CpuModel{
   1495         .name = "arm1136j_s",
   1496         .llvm_name = "arm1136j-s",
   1497         .features = featureSet(&[_]Feature{
   1498             .v6,
   1499         }),
   1500     };
   1501     pub const arm1136jf_s = CpuModel{
   1502         .name = "arm1136jf_s",
   1503         .llvm_name = "arm1136jf-s",
   1504         .features = featureSet(&[_]Feature{
   1505             .slowfpvmlx,
   1506             .v6,
   1507             .vfp2,
   1508         }),
   1509     };
   1510     pub const arm1156t2_s = CpuModel{
   1511         .name = "arm1156t2_s",
   1512         .llvm_name = "arm1156t2-s",
   1513         .features = featureSet(&[_]Feature{
   1514             .v6t2,
   1515         }),
   1516     };
   1517     pub const arm1156t2f_s = CpuModel{
   1518         .name = "arm1156t2f_s",
   1519         .llvm_name = "arm1156t2f-s",
   1520         .features = featureSet(&[_]Feature{
   1521             .slowfpvmlx,
   1522             .v6t2,
   1523             .vfp2,
   1524         }),
   1525     };
   1526     pub const arm1176jz_s = CpuModel{
   1527         .name = "arm1176jz_s",
   1528         .llvm_name = "arm1176jz-s",
   1529         .features = featureSet(&[_]Feature{
   1530             .v6kz,
   1531         }),
   1532     };
   1533     pub const arm1176jzf_s = CpuModel{
   1534         .name = "arm1176jzf_s",
   1535         .llvm_name = "arm1176jzf-s",
   1536         .features = featureSet(&[_]Feature{
   1537             .slowfpvmlx,
   1538             .v6kz,
   1539             .vfp2,
   1540         }),
   1541     };
   1542     pub const arm710t = CpuModel{
   1543         .name = "arm710t",
   1544         .llvm_name = "arm710t",
   1545         .features = featureSet(&[_]Feature{
   1546             .v4t,
   1547         }),
   1548     };
   1549     pub const arm720t = CpuModel{
   1550         .name = "arm720t",
   1551         .llvm_name = "arm720t",
   1552         .features = featureSet(&[_]Feature{
   1553             .v4t,
   1554         }),
   1555     };
   1556     pub const arm7tdmi = CpuModel{
   1557         .name = "arm7tdmi",
   1558         .llvm_name = "arm7tdmi",
   1559         .features = featureSet(&[_]Feature{
   1560             .v4t,
   1561         }),
   1562     };
   1563     pub const arm7tdmi_s = CpuModel{
   1564         .name = "arm7tdmi_s",
   1565         .llvm_name = "arm7tdmi-s",
   1566         .features = featureSet(&[_]Feature{
   1567             .v4t,
   1568         }),
   1569     };
   1570     pub const arm8 = CpuModel{
   1571         .name = "arm8",
   1572         .llvm_name = "arm8",
   1573         .features = featureSet(&[_]Feature{
   1574             .v4,
   1575         }),
   1576     };
   1577     pub const arm810 = CpuModel{
   1578         .name = "arm810",
   1579         .llvm_name = "arm810",
   1580         .features = featureSet(&[_]Feature{
   1581             .v4,
   1582         }),
   1583     };
   1584     pub const arm9 = CpuModel{
   1585         .name = "arm9",
   1586         .llvm_name = "arm9",
   1587         .features = featureSet(&[_]Feature{
   1588             .v4t,
   1589         }),
   1590     };
   1591     pub const arm920 = CpuModel{
   1592         .name = "arm920",
   1593         .llvm_name = "arm920",
   1594         .features = featureSet(&[_]Feature{
   1595             .v4t,
   1596         }),
   1597     };
   1598     pub const arm920t = CpuModel{
   1599         .name = "arm920t",
   1600         .llvm_name = "arm920t",
   1601         .features = featureSet(&[_]Feature{
   1602             .v4t,
   1603         }),
   1604     };
   1605     pub const arm922t = CpuModel{
   1606         .name = "arm922t",
   1607         .llvm_name = "arm922t",
   1608         .features = featureSet(&[_]Feature{
   1609             .v4t,
   1610         }),
   1611     };
   1612     pub const arm926ej_s = CpuModel{
   1613         .name = "arm926ej_s",
   1614         .llvm_name = "arm926ej-s",
   1615         .features = featureSet(&[_]Feature{
   1616             .v5te,
   1617         }),
   1618     };
   1619     pub const arm940t = CpuModel{
   1620         .name = "arm940t",
   1621         .llvm_name = "arm940t",
   1622         .features = featureSet(&[_]Feature{
   1623             .v4t,
   1624         }),
   1625     };
   1626     pub const arm946e_s = CpuModel{
   1627         .name = "arm946e_s",
   1628         .llvm_name = "arm946e-s",
   1629         .features = featureSet(&[_]Feature{
   1630             .v5te,
   1631         }),
   1632     };
   1633     pub const arm966e_s = CpuModel{
   1634         .name = "arm966e_s",
   1635         .llvm_name = "arm966e-s",
   1636         .features = featureSet(&[_]Feature{
   1637             .v5te,
   1638         }),
   1639     };
   1640     pub const arm968e_s = CpuModel{
   1641         .name = "arm968e_s",
   1642         .llvm_name = "arm968e-s",
   1643         .features = featureSet(&[_]Feature{
   1644             .v5te,
   1645         }),
   1646     };
   1647     pub const arm9e = CpuModel{
   1648         .name = "arm9e",
   1649         .llvm_name = "arm9e",
   1650         .features = featureSet(&[_]Feature{
   1651             .v5te,
   1652         }),
   1653     };
   1654     pub const arm9tdmi = CpuModel{
   1655         .name = "arm9tdmi",
   1656         .llvm_name = "arm9tdmi",
   1657         .features = featureSet(&[_]Feature{
   1658             .v4t,
   1659         }),
   1660     };
   1661     pub const baseline = CpuModel{
   1662         .name = "baseline",
   1663         .llvm_name = "generic",
   1664         .features = featureSet(&[_]Feature{
   1665             .v7a,
   1666         }),
   1667     };
   1668     pub const cortex_a12 = CpuModel{
   1669         .name = "cortex_a12",
   1670         .llvm_name = "cortex-a12",
   1671         .features = featureSet(&[_]Feature{
   1672             .avoid_partial_cpsr,
   1673             .mp,
   1674             .ret_addr_stack,
   1675             .trustzone,
   1676             .v7a,
   1677             .vfp4,
   1678             .virtualization,
   1679             .vmlx_forwarding,
   1680         }),
   1681     };
   1682     pub const cortex_a15 = CpuModel{
   1683         .name = "cortex_a15",
   1684         .llvm_name = "cortex-a15",
   1685         .features = featureSet(&[_]Feature{
   1686             .avoid_partial_cpsr,
   1687             .mp,
   1688             .muxed_units,
   1689             .ret_addr_stack,
   1690             .splat_vfp_neon,
   1691             .trustzone,
   1692             .v7a,
   1693             .vfp4,
   1694             .virtualization,
   1695             .vldn_align,
   1696         }),
   1697     };
   1698     pub const cortex_a17 = CpuModel{
   1699         .name = "cortex_a17",
   1700         .llvm_name = "cortex-a17",
   1701         .features = featureSet(&[_]Feature{
   1702             .avoid_partial_cpsr,
   1703             .mp,
   1704             .ret_addr_stack,
   1705             .trustzone,
   1706             .v7a,
   1707             .vfp4,
   1708             .virtualization,
   1709             .vmlx_forwarding,
   1710         }),
   1711     };
   1712     pub const cortex_a32 = CpuModel{
   1713         .name = "cortex_a32",
   1714         .llvm_name = "cortex-a32",
   1715         .features = featureSet(&[_]Feature{
   1716             .v8a,
   1717         }),
   1718     };
   1719     pub const cortex_a35 = CpuModel{
   1720         .name = "cortex_a35",
   1721         .llvm_name = "cortex-a35",
   1722         .features = featureSet(&[_]Feature{
   1723             .v8a,
   1724         }),
   1725     };
   1726     pub const cortex_a5 = CpuModel{
   1727         .name = "cortex_a5",
   1728         .llvm_name = "cortex-a5",
   1729         .features = featureSet(&[_]Feature{
   1730             .mp,
   1731             .ret_addr_stack,
   1732             .slow_fp_brcc,
   1733             .slowfpvfmx,
   1734             .slowfpvmlx,
   1735             .trustzone,
   1736             .v7a,
   1737             .vfp4,
   1738             .vmlx_forwarding,
   1739         }),
   1740     };
   1741     pub const cortex_a53 = CpuModel{
   1742         .name = "cortex_a53",
   1743         .llvm_name = "cortex-a53",
   1744         .features = featureSet(&[_]Feature{
   1745             .fpao,
   1746             .v8a,
   1747         }),
   1748     };
   1749     pub const cortex_a55 = CpuModel{
   1750         .name = "cortex_a55",
   1751         .llvm_name = "cortex-a55",
   1752         .features = featureSet(&[_]Feature{
   1753             .dotprod,
   1754             .v8_2a,
   1755         }),
   1756     };
   1757     pub const cortex_a57 = CpuModel{
   1758         .name = "cortex_a57",
   1759         .llvm_name = "cortex-a57",
   1760         .features = featureSet(&[_]Feature{
   1761             .avoid_partial_cpsr,
   1762             .cheap_predicable_cpsr,
   1763             .fpao,
   1764             .v8a,
   1765         }),
   1766     };
   1767     pub const cortex_a7 = CpuModel{
   1768         .name = "cortex_a7",
   1769         .llvm_name = "cortex-a7",
   1770         .features = featureSet(&[_]Feature{
   1771             .mp,
   1772             .ret_addr_stack,
   1773             .slow_fp_brcc,
   1774             .slowfpvfmx,
   1775             .slowfpvmlx,
   1776             .trustzone,
   1777             .v7a,
   1778             .vfp4,
   1779             .virtualization,
   1780             .vmlx_forwarding,
   1781             .vmlx_hazards,
   1782         }),
   1783     };
   1784     pub const cortex_a72 = CpuModel{
   1785         .name = "cortex_a72",
   1786         .llvm_name = "cortex-a72",
   1787         .features = featureSet(&[_]Feature{
   1788             .v8a,
   1789         }),
   1790     };
   1791     pub const cortex_a73 = CpuModel{
   1792         .name = "cortex_a73",
   1793         .llvm_name = "cortex-a73",
   1794         .features = featureSet(&[_]Feature{
   1795             .v8a,
   1796         }),
   1797     };
   1798     pub const cortex_a75 = CpuModel{
   1799         .name = "cortex_a75",
   1800         .llvm_name = "cortex-a75",
   1801         .features = featureSet(&[_]Feature{
   1802             .dotprod,
   1803             .v8_2a,
   1804         }),
   1805     };
   1806     pub const cortex_a76 = CpuModel{
   1807         .name = "cortex_a76",
   1808         .llvm_name = "cortex-a76",
   1809         .features = featureSet(&[_]Feature{
   1810             .a76,
   1811             .dotprod,
   1812             .fullfp16,
   1813             .v8_2a,
   1814         }),
   1815     };
   1816     pub const cortex_a76ae = CpuModel{
   1817         .name = "cortex_a76ae",
   1818         .llvm_name = "cortex-a76ae",
   1819         .features = featureSet(&[_]Feature{
   1820             .a76,
   1821             .dotprod,
   1822             .fullfp16,
   1823             .v8_2a,
   1824         }),
   1825     };
   1826     pub const cortex_a77 = CpuModel{
   1827         .name = "cortex_a77",
   1828         .llvm_name = "cortex-a77",
   1829         .features = featureSet(&[_]Feature{
   1830             .dotprod,
   1831             .fullfp16,
   1832             .v8_2a,
   1833         }),
   1834     };
   1835     pub const cortex_a78 = CpuModel{
   1836         .name = "cortex_a78",
   1837         .llvm_name = "cortex-a78",
   1838         .features = featureSet(&[_]Feature{
   1839             .dotprod,
   1840             .fullfp16,
   1841             .v8_2a,
   1842         }),
   1843     };
   1844     pub const cortex_a78c = CpuModel{
   1845         .name = "cortex_a78c",
   1846         .llvm_name = "cortex-a78c",
   1847         .features = featureSet(&[_]Feature{
   1848             .dotprod,
   1849             .fullfp16,
   1850             .v8_2a,
   1851         }),
   1852     };
   1853     pub const cortex_a8 = CpuModel{
   1854         .name = "cortex_a8",
   1855         .llvm_name = "cortex-a8",
   1856         .features = featureSet(&[_]Feature{
   1857             .nonpipelined_vfp,
   1858             .ret_addr_stack,
   1859             .slow_fp_brcc,
   1860             .slowfpvfmx,
   1861             .slowfpvmlx,
   1862             .trustzone,
   1863             .v7a,
   1864             .vmlx_forwarding,
   1865             .vmlx_hazards,
   1866         }),
   1867     };
   1868     pub const cortex_a9 = CpuModel{
   1869         .name = "cortex_a9",
   1870         .llvm_name = "cortex-a9",
   1871         .features = featureSet(&[_]Feature{
   1872             .avoid_partial_cpsr,
   1873             .expand_fp_mlx,
   1874             .fp16,
   1875             .mp,
   1876             .muxed_units,
   1877             .neon_fpmovs,
   1878             .prefer_vmovsr,
   1879             .ret_addr_stack,
   1880             .trustzone,
   1881             .v7a,
   1882             .vldn_align,
   1883             .vmlx_forwarding,
   1884             .vmlx_hazards,
   1885         }),
   1886     };
   1887     pub const cortex_m0 = CpuModel{
   1888         .name = "cortex_m0",
   1889         .llvm_name = "cortex-m0",
   1890         .features = featureSet(&[_]Feature{
   1891             .no_branch_predictor,
   1892             .v6m,
   1893         }),
   1894     };
   1895     pub const cortex_m0plus = CpuModel{
   1896         .name = "cortex_m0plus",
   1897         .llvm_name = "cortex-m0plus",
   1898         .features = featureSet(&[_]Feature{
   1899             .no_branch_predictor,
   1900             .v6m,
   1901         }),
   1902     };
   1903     pub const cortex_m1 = CpuModel{
   1904         .name = "cortex_m1",
   1905         .llvm_name = "cortex-m1",
   1906         .features = featureSet(&[_]Feature{
   1907             .no_branch_predictor,
   1908             .v6m,
   1909         }),
   1910     };
   1911     pub const cortex_m23 = CpuModel{
   1912         .name = "cortex_m23",
   1913         .llvm_name = "cortex-m23",
   1914         .features = featureSet(&[_]Feature{
   1915             .no_branch_predictor,
   1916             .no_movt,
   1917             .v8m,
   1918         }),
   1919     };
   1920     pub const cortex_m3 = CpuModel{
   1921         .name = "cortex_m3",
   1922         .llvm_name = "cortex-m3",
   1923         .features = featureSet(&[_]Feature{
   1924             .loop_align,
   1925             .m3,
   1926             .no_branch_predictor,
   1927             .use_misched,
   1928             .v7m,
   1929         }),
   1930     };
   1931     pub const cortex_m33 = CpuModel{
   1932         .name = "cortex_m33",
   1933         .llvm_name = "cortex-m33",
   1934         .features = featureSet(&[_]Feature{
   1935             .dsp,
   1936             .fp_armv8d16sp,
   1937             .loop_align,
   1938             .no_branch_predictor,
   1939             .slowfpvfmx,
   1940             .slowfpvmlx,
   1941             .use_misched,
   1942             .v8m_main,
   1943         }),
   1944     };
   1945     pub const cortex_m35p = CpuModel{
   1946         .name = "cortex_m35p",
   1947         .llvm_name = "cortex-m35p",
   1948         .features = featureSet(&[_]Feature{
   1949             .dsp,
   1950             .fp_armv8d16sp,
   1951             .loop_align,
   1952             .no_branch_predictor,
   1953             .slowfpvfmx,
   1954             .slowfpvmlx,
   1955             .use_misched,
   1956             .v8m_main,
   1957         }),
   1958     };
   1959     pub const cortex_m4 = CpuModel{
   1960         .name = "cortex_m4",
   1961         .llvm_name = "cortex-m4",
   1962         .features = featureSet(&[_]Feature{
   1963             .loop_align,
   1964             .no_branch_predictor,
   1965             .slowfpvfmx,
   1966             .slowfpvmlx,
   1967             .use_misched,
   1968             .v7em,
   1969             .vfp4d16sp,
   1970         }),
   1971     };
   1972     pub const cortex_m55 = CpuModel{
   1973         .name = "cortex_m55",
   1974         .llvm_name = "cortex-m55",
   1975         .features = featureSet(&[_]Feature{
   1976             .fp_armv8d16,
   1977             .loop_align,
   1978             .mve_fp,
   1979             .no_branch_predictor,
   1980             .slowfpvmlx,
   1981             .use_misched,
   1982             .v8_1m_main,
   1983         }),
   1984     };
   1985     pub const cortex_m7 = CpuModel{
   1986         .name = "cortex_m7",
   1987         .llvm_name = "cortex-m7",
   1988         .features = featureSet(&[_]Feature{
   1989             .fp_armv8d16,
   1990             .use_misched,
   1991             .v7em,
   1992         }),
   1993     };
   1994     pub const cortex_r4 = CpuModel{
   1995         .name = "cortex_r4",
   1996         .llvm_name = "cortex-r4",
   1997         .features = featureSet(&[_]Feature{
   1998             .avoid_partial_cpsr,
   1999             .r4,
   2000             .ret_addr_stack,
   2001             .v7r,
   2002         }),
   2003     };
   2004     pub const cortex_r4f = CpuModel{
   2005         .name = "cortex_r4f",
   2006         .llvm_name = "cortex-r4f",
   2007         .features = featureSet(&[_]Feature{
   2008             .avoid_partial_cpsr,
   2009             .r4,
   2010             .ret_addr_stack,
   2011             .slow_fp_brcc,
   2012             .slowfpvfmx,
   2013             .slowfpvmlx,
   2014             .v7r,
   2015             .vfp3d16,
   2016         }),
   2017     };
   2018     pub const cortex_r5 = CpuModel{
   2019         .name = "cortex_r5",
   2020         .llvm_name = "cortex-r5",
   2021         .features = featureSet(&[_]Feature{
   2022             .avoid_partial_cpsr,
   2023             .hwdiv_arm,
   2024             .ret_addr_stack,
   2025             .slow_fp_brcc,
   2026             .slowfpvfmx,
   2027             .slowfpvmlx,
   2028             .v7r,
   2029             .vfp3d16,
   2030         }),
   2031     };
   2032     pub const cortex_r52 = CpuModel{
   2033         .name = "cortex_r52",
   2034         .llvm_name = "cortex-r52",
   2035         .features = featureSet(&[_]Feature{
   2036             .fpao,
   2037             .use_misched,
   2038             .v8r,
   2039         }),
   2040     };
   2041     pub const cortex_r7 = CpuModel{
   2042         .name = "cortex_r7",
   2043         .llvm_name = "cortex-r7",
   2044         .features = featureSet(&[_]Feature{
   2045             .avoid_partial_cpsr,
   2046             .fp16,
   2047             .hwdiv_arm,
   2048             .mp,
   2049             .ret_addr_stack,
   2050             .slow_fp_brcc,
   2051             .slowfpvfmx,
   2052             .slowfpvmlx,
   2053             .v7r,
   2054             .vfp3d16,
   2055         }),
   2056     };
   2057     pub const cortex_r8 = CpuModel{
   2058         .name = "cortex_r8",
   2059         .llvm_name = "cortex-r8",
   2060         .features = featureSet(&[_]Feature{
   2061             .avoid_partial_cpsr,
   2062             .fp16,
   2063             .hwdiv_arm,
   2064             .mp,
   2065             .ret_addr_stack,
   2066             .slow_fp_brcc,
   2067             .slowfpvfmx,
   2068             .slowfpvmlx,
   2069             .v7r,
   2070             .vfp3d16,
   2071         }),
   2072     };
   2073     pub const cortex_x1 = CpuModel{
   2074         .name = "cortex_x1",
   2075         .llvm_name = "cortex-x1",
   2076         .features = featureSet(&[_]Feature{
   2077             .dotprod,
   2078             .fullfp16,
   2079             .v8_2a,
   2080         }),
   2081     };
   2082     pub const cyclone = CpuModel{
   2083         .name = "cyclone",
   2084         .llvm_name = "cyclone",
   2085         .features = featureSet(&[_]Feature{
   2086             .avoid_movs_shop,
   2087             .avoid_partial_cpsr,
   2088             .disable_postra_scheduler,
   2089             .neonfp,
   2090             .ret_addr_stack,
   2091             .slowfpvfmx,
   2092             .slowfpvmlx,
   2093             .swift,
   2094             .use_misched,
   2095             .v8a,
   2096             .zcz,
   2097         }),
   2098     };
   2099     pub const ep9312 = CpuModel{
   2100         .name = "ep9312",
   2101         .llvm_name = "ep9312",
   2102         .features = featureSet(&[_]Feature{
   2103             .v4t,
   2104         }),
   2105     };
   2106     pub const exynos_m1 = CpuModel{
   2107         .name = "exynos_m1",
   2108         .llvm_name = null,
   2109         .features = featureSet(&[_]Feature{
   2110             .exynos,
   2111             .v8a,
   2112         }),
   2113     };
   2114     pub const exynos_m2 = CpuModel{
   2115         .name = "exynos_m2",
   2116         .llvm_name = null,
   2117         .features = featureSet(&[_]Feature{
   2118             .exynos,
   2119             .v8a,
   2120         }),
   2121     };
   2122     pub const exynos_m3 = CpuModel{
   2123         .name = "exynos_m3",
   2124         .llvm_name = "exynos-m3",
   2125         .features = featureSet(&[_]Feature{
   2126             .exynos,
   2127             .v8a,
   2128         }),
   2129     };
   2130     pub const exynos_m4 = CpuModel{
   2131         .name = "exynos_m4",
   2132         .llvm_name = "exynos-m4",
   2133         .features = featureSet(&[_]Feature{
   2134             .dotprod,
   2135             .exynos,
   2136             .fullfp16,
   2137             .v8_2a,
   2138         }),
   2139     };
   2140     pub const exynos_m5 = CpuModel{
   2141         .name = "exynos_m5",
   2142         .llvm_name = "exynos-m5",
   2143         .features = featureSet(&[_]Feature{
   2144             .dotprod,
   2145             .exynos,
   2146             .fullfp16,
   2147             .v8_2a,
   2148         }),
   2149     };
   2150     pub const generic = CpuModel{
   2151         .name = "generic",
   2152         .llvm_name = "generic",
   2153         .features = featureSet(&[_]Feature{}),
   2154     };
   2155     pub const iwmmxt = CpuModel{
   2156         .name = "iwmmxt",
   2157         .llvm_name = "iwmmxt",
   2158         .features = featureSet(&[_]Feature{
   2159             .v5te,
   2160         }),
   2161     };
   2162     pub const krait = CpuModel{
   2163         .name = "krait",
   2164         .llvm_name = "krait",
   2165         .features = featureSet(&[_]Feature{
   2166             .avoid_partial_cpsr,
   2167             .hwdiv,
   2168             .hwdiv_arm,
   2169             .muxed_units,
   2170             .ret_addr_stack,
   2171             .v7a,
   2172             .vfp4,
   2173             .vldn_align,
   2174             .vmlx_forwarding,
   2175         }),
   2176     };
   2177     pub const kryo = CpuModel{
   2178         .name = "kryo",
   2179         .llvm_name = "kryo",
   2180         .features = featureSet(&[_]Feature{
   2181             .v8a,
   2182         }),
   2183     };
   2184     pub const mpcore = CpuModel{
   2185         .name = "mpcore",
   2186         .llvm_name = "mpcore",
   2187         .features = featureSet(&[_]Feature{
   2188             .slowfpvmlx,
   2189             .v6k,
   2190             .vfp2,
   2191         }),
   2192     };
   2193     pub const mpcorenovfp = CpuModel{
   2194         .name = "mpcorenovfp",
   2195         .llvm_name = "mpcorenovfp",
   2196         .features = featureSet(&[_]Feature{
   2197             .v6k,
   2198         }),
   2199     };
   2200     pub const neoverse_n1 = CpuModel{
   2201         .name = "neoverse_n1",
   2202         .llvm_name = "neoverse-n1",
   2203         .features = featureSet(&[_]Feature{
   2204             .dotprod,
   2205             .v8_2a,
   2206         }),
   2207     };
   2208     pub const neoverse_n2 = CpuModel{
   2209         .name = "neoverse_n2",
   2210         .llvm_name = "neoverse-n2",
   2211         .features = featureSet(&[_]Feature{
   2212             .bf16,
   2213             .i8mm,
   2214             .v8_5a,
   2215         }),
   2216     };
   2217     pub const neoverse_v1 = CpuModel{
   2218         .name = "neoverse_v1",
   2219         .llvm_name = "neoverse-v1",
   2220         .features = featureSet(&[_]Feature{
   2221             .bf16,
   2222             .fullfp16,
   2223             .i8mm,
   2224             .v8_4a,
   2225         }),
   2226     };
   2227     pub const sc000 = CpuModel{
   2228         .name = "sc000",
   2229         .llvm_name = "sc000",
   2230         .features = featureSet(&[_]Feature{
   2231             .no_branch_predictor,
   2232             .v6m,
   2233         }),
   2234     };
   2235     pub const sc300 = CpuModel{
   2236         .name = "sc300",
   2237         .llvm_name = "sc300",
   2238         .features = featureSet(&[_]Feature{
   2239             .m3,
   2240             .no_branch_predictor,
   2241             .use_misched,
   2242             .v7m,
   2243         }),
   2244     };
   2245     pub const strongarm = CpuModel{
   2246         .name = "strongarm",
   2247         .llvm_name = "strongarm",
   2248         .features = featureSet(&[_]Feature{
   2249             .v4,
   2250         }),
   2251     };
   2252     pub const strongarm110 = CpuModel{
   2253         .name = "strongarm110",
   2254         .llvm_name = "strongarm110",
   2255         .features = featureSet(&[_]Feature{
   2256             .v4,
   2257         }),
   2258     };
   2259     pub const strongarm1100 = CpuModel{
   2260         .name = "strongarm1100",
   2261         .llvm_name = "strongarm1100",
   2262         .features = featureSet(&[_]Feature{
   2263             .v4,
   2264         }),
   2265     };
   2266     pub const strongarm1110 = CpuModel{
   2267         .name = "strongarm1110",
   2268         .llvm_name = "strongarm1110",
   2269         .features = featureSet(&[_]Feature{
   2270             .v4,
   2271         }),
   2272     };
   2273     pub const swift = CpuModel{
   2274         .name = "swift",
   2275         .llvm_name = "swift",
   2276         .features = featureSet(&[_]Feature{
   2277             .avoid_movs_shop,
   2278             .avoid_partial_cpsr,
   2279             .disable_postra_scheduler,
   2280             .hwdiv,
   2281             .hwdiv_arm,
   2282             .mp,
   2283             .neonfp,
   2284             .prefer_ishst,
   2285             .prof_unpr,
   2286             .ret_addr_stack,
   2287             .slow_load_D_subreg,
   2288             .slow_odd_reg,
   2289             .slow_vdup32,
   2290             .slow_vgetlni32,
   2291             .slowfpvfmx,
   2292             .slowfpvmlx,
   2293             .swift,
   2294             .use_misched,
   2295             .v7a,
   2296             .vfp4,
   2297             .vmlx_hazards,
   2298             .wide_stride_vfp,
   2299         }),
   2300     };
   2301     pub const xscale = CpuModel{
   2302         .name = "xscale",
   2303         .llvm_name = "xscale",
   2304         .features = featureSet(&[_]Feature{
   2305             .v5te,
   2306         }),
   2307     };
   2308 };
	zig fork of https://codeberg.org/ziglang/zig
	Log \| Files \| Refs \| README \| LICENSE