pub const all_features = blk: {
const len = @typeInfo(Feature).@"enum".field_names.len;
std.debug.assert(len <= CpuFeature.Set.needed_bit_count);
var result: [len]CpuFeature = undefined;
result[@backingInt(Feature.@"64bit")] = .{
.llvm_name = "64bit",
.description = "Enable 64-bit mode",
.dependencies = featureSet(&[_]Feature{
.@"64bit_support",
}),
};
result[@backingInt(Feature.@"64bit_support")] = .{
.llvm_name = "64bit-support",
.description = "Supports 64-bit instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.@"64bitregs")] = .{
.llvm_name = "64bitregs",
.description = "Enable 64-bit registers usage for ppc32 [beta]",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.allow_unaligned_fp_access)] = .{
.llvm_name = "allow-unaligned-fp-access",
.description = "CPU does not trap on unaligned FP access",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.altivec)] = .{
.llvm_name = "altivec",
.description = "Enable Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.booke)] = .{
.llvm_name = "booke",
.description = "Enable Book E instructions",
.dependencies = featureSet(&[_]Feature{
.icbt,
}),
};
result[@backingInt(Feature.bpermd)] = .{
.llvm_name = "bpermd",
.description = "Enable the bpermd instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.cmpb)] = .{
.llvm_name = "cmpb",
.description = "Enable the cmpb instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.crbits)] = .{
.llvm_name = "crbits",
.description = "Use condition-register bits individually",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.crypto)] = .{
.llvm_name = "crypto",
.description = "Enable POWER8 Crypto instructions",
.dependencies = featureSet(&[_]Feature{
.power8_altivec,
}),
};
result[@backingInt(Feature.direct_move)] = .{
.llvm_name = "direct-move",
.description = "Enable Power8 direct move instructions",
.dependencies = featureSet(&[_]Feature{
.vsx,
}),
};
result[@backingInt(Feature.e500)] = .{
.llvm_name = "e500",
.description = "Enable E500/E500mc instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.efpu2)] = .{
.llvm_name = "efpu2",
.description = "Enable Embedded Floating-Point APU 2 instructions",
.dependencies = featureSet(&[_]Feature{
.spe,
}),
};
result[@backingInt(Feature.extdiv)] = .{
.llvm_name = "extdiv",
.description = "Enable extended divide instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.fast_MFLR)] = .{
.llvm_name = "fast-MFLR",
.description = "MFLR is a fast instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.fcpsgn)] = .{
.llvm_name = "fcpsgn",
.description = "Enable the fcpsgn instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.float128)] = .{
.llvm_name = "float128",
.description = "Enable the __float128 data type for IEEE-754R Binary128.",
.dependencies = featureSet(&[_]Feature{
.vsx,
}),
};
result[@backingInt(Feature.fpcvt)] = .{
.llvm_name = "fpcvt",
.description = "Enable fc[ft]* (unsigned and single-precision) and lfiwzx instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.fprnd)] = .{
.llvm_name = "fprnd",
.description = "Enable the fri[mnpz] instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.fpu)] = .{
.llvm_name = "fpu",
.description = "Enable classic FPU instructions",
.dependencies = featureSet(&[_]Feature{
.hard_float,
}),
};
result[@backingInt(Feature.fre)] = .{
.llvm_name = "fre",
.description = "Enable the fre instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.fres)] = .{
.llvm_name = "fres",
.description = "Enable the fres instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.frsqrte)] = .{
.llvm_name = "frsqrte",
.description = "Enable the frsqrte instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.frsqrtes)] = .{
.llvm_name = "frsqrtes",
.description = "Enable the frsqrtes instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.fsqrt)] = .{
.llvm_name = "fsqrt",
.description = "Enable the fsqrt instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.fuse_add_logical)] = .{
.llvm_name = "fuse-add-logical",
.description = "Target supports Add with Logical Operations fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_addi_load)] = .{
.llvm_name = "fuse-addi-load",
.description = "Power8 Addi-Load fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_addis_load)] = .{
.llvm_name = "fuse-addis-load",
.description = "Power8 Addis-Load fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_arith_add)] = .{
.llvm_name = "fuse-arith-add",
.description = "Target supports Arithmetic Operations with Add fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_back2back)] = .{
.llvm_name = "fuse-back2back",
.description = "Target supports general back to back fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_cmp)] = .{
.llvm_name = "fuse-cmp",
.description = "Target supports Comparison Operations fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_logical)] = .{
.llvm_name = "fuse-logical",
.description = "Target supports Logical Operations fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_logical_add)] = .{
.llvm_name = "fuse-logical-add",
.description = "Target supports Logical with Add Operations fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_sha3)] = .{
.llvm_name = "fuse-sha3",
.description = "Target supports SHA3 assist fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_store)] = .{
.llvm_name = "fuse-store",
.description = "Target supports store clustering",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_wideimm)] = .{
.llvm_name = "fuse-wideimm",
.description = "Target supports Wide-Immediate fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fuse_zeromove)] = .{
.llvm_name = "fuse-zeromove",
.description = "Target supports move to SPR with branch fusion",
.dependencies = featureSet(&[_]Feature{
.fusion,
}),
};
result[@backingInt(Feature.fusion)] = .{
.llvm_name = "fusion",
.description = "Target supports instruction fusion",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.hard_float)] = .{
.llvm_name = "hard-float",
.description = "Enable floating-point instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.htm)] = .{
.llvm_name = "htm",
.description = "Enable Hardware Transactional Memory instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.icbt)] = .{
.llvm_name = "icbt",
.description = "Enable icbt instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.invariant_function_descriptors)] = .{
.llvm_name = "invariant-function-descriptors",
.description = "Assume function descriptors are invariant",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.isa_future_instructions)] = .{
.llvm_name = "isa-future-instructions",
.description = "Enable instructions for Future ISA.",
.dependencies = featureSet(&[_]Feature{
.isa_v31_instructions,
}),
};
result[@backingInt(Feature.isa_v206_instructions)] = .{
.llvm_name = "isa-v206-instructions",
.description = "Enable instructions in ISA 2.06.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.isa_v207_instructions)] = .{
.llvm_name = "isa-v207-instructions",
.description = "Enable instructions in ISA 2.07.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.isa_v30_instructions)] = .{
.llvm_name = "isa-v30-instructions",
.description = "Enable instructions in ISA 3.0.",
.dependencies = featureSet(&[_]Feature{
.isa_v207_instructions,
}),
};
result[@backingInt(Feature.isa_v31_instructions)] = .{
.llvm_name = "isa-v31-instructions",
.description = "Enable instructions in ISA 3.1.",
.dependencies = featureSet(&[_]Feature{
.isa_v30_instructions,
}),
};
result[@backingInt(Feature.isel)] = .{
.llvm_name = "isel",
.description = "Enable the isel instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.ldbrx)] = .{
.llvm_name = "ldbrx",
.description = "Enable the ldbrx instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.lfiwax)] = .{
.llvm_name = "lfiwax",
.description = "Enable the lfiwax instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.longcall)] = .{
.llvm_name = "longcall",
.description = "Always use indirect calls",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.mfocrf)] = .{
.llvm_name = "mfocrf",
.description = "Enable the MFOCRF instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.mma)] = .{
.llvm_name = "mma",
.description = "Enable MMA instructions",
.dependencies = featureSet(&[_]Feature{
.paired_vector_memops,
.power8_vector,
.power9_altivec,
}),
};
result[@backingInt(Feature.msync)] = .{
.llvm_name = "msync",
.description = "Has only the msync instruction instead of sync",
.dependencies = featureSet(&[_]Feature{
.booke,
}),
};
result[@backingInt(Feature.paired_vector_memops)] = .{
.llvm_name = "paired-vector-memops",
.description = "32Byte load and store instructions",
.dependencies = featureSet(&[_]Feature{
.isa_v30_instructions,
}),
};
result[@backingInt(Feature.partword_atomics)] = .{
.llvm_name = "partword-atomics",
.description = "Enable l[bh]arx and st[bh]cx.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.pcrelative_memops)] = .{
.llvm_name = "pcrelative-memops",
.description = "Enable PC relative Memory Ops",
.dependencies = featureSet(&[_]Feature{
.prefix_instrs,
}),
};
result[@backingInt(Feature.popcntd)] = .{
.llvm_name = "popcntd",
.description = "Enable the popcnt[dw] instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.power10_vector)] = .{
.llvm_name = "power10-vector",
.description = "Enable POWER10 vector instructions",
.dependencies = featureSet(&[_]Feature{
.isa_v31_instructions,
.power9_vector,
}),
};
result[@backingInt(Feature.power8_altivec)] = .{
.llvm_name = "power8-altivec",
.description = "Enable POWER8 Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.altivec,
}),
};
result[@backingInt(Feature.power8_vector)] = .{
.llvm_name = "power8-vector",
.description = "Enable POWER8 vector instructions",
.dependencies = featureSet(&[_]Feature{
.power8_altivec,
.vsx,
}),
};
result[@backingInt(Feature.power9_altivec)] = .{
.llvm_name = "power9-altivec",
.description = "Enable POWER9 Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.isa_v30_instructions,
.power8_altivec,
}),
};
result[@backingInt(Feature.power9_vector)] = .{
.llvm_name = "power9-vector",
.description = "Enable POWER9 vector instructions",
.dependencies = featureSet(&[_]Feature{
.power8_vector,
.power9_altivec,
}),
};
result[@backingInt(Feature.ppc4xx)] = .{
.llvm_name = "ppc4xx",
.description = "Enable PPC 4xx instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.ppc6xx)] = .{
.llvm_name = "ppc6xx",
.description = "Enable PPC 6xx instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.ppc_postra_sched)] = .{
.llvm_name = "ppc-postra-sched",
.description = "Use PowerPC post-RA scheduling strategy",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.ppc_prera_sched)] = .{
.llvm_name = "ppc-prera-sched",
.description = "Use PowerPC pre-RA scheduling strategy",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.predictable_select_expensive)] = .{
.llvm_name = "predictable-select-expensive",
.description = "Prefer likely predicted branches over selects",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.prefix_instrs)] = .{
.llvm_name = "prefix-instrs",
.description = "Enable prefixed instructions",
.dependencies = featureSet(&[_]Feature{
.isa_v31_instructions,
}),
};
result[@backingInt(Feature.privileged)] = .{
.llvm_name = "privileged",
.description = "Add privileged instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.quadword_atomics)] = .{
.llvm_name = "quadword-atomics",
.description = "Enable lqarx and stqcx.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.recipprec)] = .{
.llvm_name = "recipprec",
.description = "Assume higher precision reciprocal estimates",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.rop_protect)] = .{
.llvm_name = "rop-protect",
.description = "Add ROP protect",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.secure_plt)] = .{
.llvm_name = "secure-plt",
.description = "Enable secure plt mode",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.slow_popcntd)] = .{
.llvm_name = "slow-popcntd",
.description = "Has slow popcnt[dw] instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.spe)] = .{
.llvm_name = "spe",
.description = "Enable SPE instructions",
.dependencies = featureSet(&[_]Feature{
.hard_float,
}),
};
result[@backingInt(Feature.stfiwx)] = .{
.llvm_name = "stfiwx",
.description = "Enable the stfiwx instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@backingInt(Feature.two_const_nr)] = .{
.llvm_name = "two-const-nr",
.description = "Requires two constant Newton-Raphson computation",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.vectors_use_two_units)] = .{
.llvm_name = "vectors-use-two-units",
.description = "Vectors use two units",
.dependencies = featureSet(&[_]Feature{}),
};
result[@backingInt(Feature.vsx)] = .{
.llvm_name = "vsx",
.description = "Enable VSX instructions",
.dependencies = featureSet(&[_]Feature{
.altivec,
}),
};
const ti = @typeInfo(Feature);
for (&result, 0..) |*elem, i| {
elem.index = i;
elem.name = ti.@"enum".field_names[i];
}
break :blk result;
}
