Handling target features

[giocri]

i have a function with #[target_feature(enable = "neon")] is there any way to have something like

#[target_feature(enable = "neon")]
my_function()//neon impl
#[not(target_feature(enable = "neon"))]
my_function()//non neon impl

or do i actually always need a wrapper function that checks if neon is present?

[nerditation]

I think you meant to use #[cfg(target_feature = "neon")]?.

the #[target_feature(...)] attribute is a (per-function) codegen option for the backend, it's related, but not the equivalent to conditional compilcation guards.

see also this previous question:

Compiling without AVX instructions

I'm trying to compile Rustdesk server to run on older hardware which does not support AVX and I cannot compile it directly on it: sub-repo: GitHub - rustdesk/hbb_common I have tried multiple options like setting RUSTFLAGS = "-C target-feature=-avx,-avx2" also similar things in Cargo.toml or .cargo/config.toml . But I still get binary executable which have these instructions enabled. Can it be from a dependency or the flags are ignored? What can I try or analyze?

or this one:

Disable unsupported SIMD code generation

Problem I've written some SIMD intrinsics code targeting x86-64: SSE4.1, AVX, and AVX2. I began reading some of the assembly output, and came across a troubling result. When I made the mistake of not explicitly enabling AVX2 but only AVX, the compiler generated weird code sequences for AVX2 intrinsics. This is very problematic since code like this may go unnoticed unless the actual assembly is inspected with every version. Is there any way to disable or protect against this code generation? Ex…

[giocri]

i was hoping to do both, the #[targhet_feature(..)] to be able to use neon stuff in my function and the conditional compilation to stop it from coloring the functions that use it

[nerditation]

@giocri

i was hoping to do both ...

it doesn't make much sense to use both on the same function.

if you want to select different implementations at compile time, use #[cfg(target_feature = "neon")] and #[cfg(not(target_feature = "neon"))] (or use the x cfg-if crate). in this case, the #[target_feature(...)] attribute is redundent anyway.

if you want to select the function at runtime, you can use #[target_feature(...)], but you'll have to use runtime feature detection (such as std::is_x86_feature_detected!(...)), conditional compilation (such as the #[cfg(target_feature = ...)] attribute or the cfg!(target_feature = ...) macro) is useless in this case.

if you want to conditionally enable special target features only for targets without it, something like this:

#[cfg_attr(not(target_feature = "neon"), target_feature(enable = "neon"))]
fn foo() {
    // ...
}

think again: it's equivalent to just use #[target_feature(enable = "neon")]!

@giocri

... to stop it from coloring the functions that use it

if you use #[target_feature()], the coloring problem is inevitable, but you can control the scope of it. passing a -C target_feature compiler flag controls the global "color", while a (runtime-checked) conditional unsafe block limits the target feature locally.

using conditional compilation can select different functions (with different "colors") to call at compile time, but then you don't need #[target_feature()] in such cases, you set the global "color" for the entire compilation unit instead.

the target feature attribute is additive only, you cannot disable a feature for a selected function (we don't have #[target_feature(disable = ...)]), disabling a target feature can only be done globally as -C target_feature=-feature_name compiler flag.