ABI checks: add support for tier2 arches

See #131800 for the data collection behind this change.

Also adds a test that exercise the "empty list of features" path.
This commit is contained in:
Luca Versari 2024-11-10 11:36:50 +01:00
parent 6503543d11
commit 295cffc4b4
10 changed files with 136 additions and 41 deletions

View File

@ -1,12 +1,19 @@
monomorphize_abi_error_disabled_vector_type_call = monomorphize_abi_error_disabled_vector_type_call =
ABI error: this function call uses a vector type that requires the `{$required_feature}` target feature, which is not enabled in the caller this function call uses a SIMD vector type that (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled in the caller
.label = function called here .label = function called here
.help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`) .help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`)
monomorphize_abi_error_disabled_vector_type_def = monomorphize_abi_error_disabled_vector_type_def =
ABI error: this function definition uses a vector type that requires the `{$required_feature}` target feature, which is not enabled this function definition uses a SIMD vector type that (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled
.label = function defined here .label = function defined here
.help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`) .help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`)
monomorphize_abi_error_unsupported_vector_type_call =
this function call uses a SIMD vector type that is not currently supported with the chosen ABI
.label = function called here
monomorphize_abi_error_unsupported_vector_type_def =
this function definition uses a SIMD vector type that is not currently supported with the chosen ABI
.label = function defined here
monomorphize_couldnt_dump_mono_stats = monomorphize_couldnt_dump_mono_stats =
unexpected error occurred while dumping monomorphization stats: {$error} unexpected error occurred while dumping monomorphization stats: {$error}

View File

@ -110,3 +110,17 @@ pub(crate) struct AbiErrorDisabledVectorTypeCall<'a> {
pub span: Span, pub span: Span,
pub required_feature: &'a str, pub required_feature: &'a str,
} }
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_def)]
pub(crate) struct AbiErrorUnsupportedVectorTypeDef {
#[label]
pub span: Span,
}
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_call)]
pub(crate) struct AbiErrorUnsupportedVectorTypeCall {
#[label]
pub span: Span,
}

View File

@ -10,7 +10,10 @@ use rustc_span::{DUMMY_SP, Span, Symbol};
use rustc_target::abi::call::{FnAbi, PassMode}; use rustc_target::abi::call::{FnAbi, PassMode};
use rustc_target::abi::{BackendRepr, RegKind}; use rustc_target::abi::{BackendRepr, RegKind};
use crate::errors::{AbiErrorDisabledVectorTypeCall, AbiErrorDisabledVectorTypeDef}; use crate::errors::{
AbiErrorDisabledVectorTypeCall, AbiErrorDisabledVectorTypeDef,
AbiErrorUnsupportedVectorTypeCall, AbiErrorUnsupportedVectorTypeDef,
};
fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool { fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
match mode { match mode {
@ -23,11 +26,15 @@ fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
} }
} }
/// Checks whether a certain function ABI is compatible with the target features currently enabled
/// for a certain function.
/// If not, `emit_err` is called, with `Some(feature)` if a certain feature should be enabled and
/// with `None` if no feature is known that would make the ABI compatible.
fn do_check_abi<'tcx>( fn do_check_abi<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
abi: &FnAbi<'tcx, Ty<'tcx>>, abi: &FnAbi<'tcx, Ty<'tcx>>,
target_feature_def: DefId, target_feature_def: DefId,
mut emit_err: impl FnMut(&'static str), mut emit_err: impl FnMut(Option<&'static str>),
) { ) {
let Some(feature_def) = tcx.sess.target.features_for_correct_vector_abi() else { let Some(feature_def) = tcx.sess.target.features_for_correct_vector_abi() else {
return; return;
@ -40,7 +47,7 @@ fn do_check_abi<'tcx>(
let feature = match feature_def.iter().find(|(bits, _)| size.bits() <= *bits) { let feature = match feature_def.iter().find(|(bits, _)| size.bits() <= *bits) {
Some((_, feature)) => feature, Some((_, feature)) => feature,
None => { None => {
emit_err("<no available feature for this size>"); emit_err(None);
continue; continue;
} }
}; };
@ -48,7 +55,7 @@ fn do_check_abi<'tcx>(
if !tcx.sess.unstable_target_features.contains(&feature_sym) if !tcx.sess.unstable_target_features.contains(&feature_sym)
&& !codegen_attrs.target_features.iter().any(|x| x.name == feature_sym) && !codegen_attrs.target_features.iter().any(|x| x.name == feature_sym)
{ {
emit_err(feature); emit_err(Some(&feature));
} }
} }
} }
@ -65,12 +72,21 @@ fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
}; };
do_check_abi(tcx, abi, instance.def_id(), |required_feature| { do_check_abi(tcx, abi, instance.def_id(), |required_feature| {
let span = tcx.def_span(instance.def_id()); let span = tcx.def_span(instance.def_id());
tcx.emit_node_span_lint( if let Some(required_feature) = required_feature {
ABI_UNSUPPORTED_VECTOR_TYPES, tcx.emit_node_span_lint(
CRATE_HIR_ID, ABI_UNSUPPORTED_VECTOR_TYPES,
span, CRATE_HIR_ID,
AbiErrorDisabledVectorTypeDef { span, required_feature }, span,
); AbiErrorDisabledVectorTypeDef { span, required_feature },
);
} else {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
AbiErrorUnsupportedVectorTypeDef { span },
);
}
}) })
} }
@ -109,12 +125,21 @@ fn check_call_site_abi<'tcx>(
return; return;
}; };
do_check_abi(tcx, callee_abi, caller.def_id(), |required_feature| { do_check_abi(tcx, callee_abi, caller.def_id(), |required_feature| {
tcx.emit_node_span_lint( if let Some(required_feature) = required_feature {
ABI_UNSUPPORTED_VECTOR_TYPES, tcx.emit_node_span_lint(
CRATE_HIR_ID, ABI_UNSUPPORTED_VECTOR_TYPES,
span, CRATE_HIR_ID,
AbiErrorDisabledVectorTypeCall { span, required_feature }, span,
); AbiErrorDisabledVectorTypeCall { span, required_feature },
);
} else {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
AbiErrorUnsupportedVectorTypeCall { span },
);
}
}); });
} }

View File

@ -586,9 +586,20 @@ pub fn all_rust_features() -> impl Iterator<Item = (&'static str, Stability)> {
// certain size to have their "proper" ABI on each architecture. // certain size to have their "proper" ABI on each architecture.
// Note that they must be kept sorted by vector size. // Note that they must be kept sorted by vector size.
const X86_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = const X86_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] =
&[(128, "sse"), (256, "avx"), (512, "avx512f")]; &[(128, "sse"), (256, "avx"), (512, "avx512f")]; // FIXME: might need changes for AVX10.
const AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(128, "neon")]; const AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(128, "neon")];
// We might want to add "helium" too.
const ARM_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(128, "neon")];
const POWERPC_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(128, "altivec")];
const WASM_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(128, "simd128")];
const S390X_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(128, "vector")];
const RISCV_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] =
&[/*(64, "zvl64b"), */ (128, "v")];
// Always warn on SPARC, as the necessary target features cannot be enabled in Rust at the moment.
const SPARC_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[/*(128, "vis")*/];
impl super::spec::Target { impl super::spec::Target {
pub fn rust_target_features(&self) -> &'static [(&'static str, Stability, ImpliedFeatures)] { pub fn rust_target_features(&self) -> &'static [(&'static str, Stability, ImpliedFeatures)] {
match &*self.arch { match &*self.arch {
@ -613,8 +624,15 @@ impl super::spec::Target {
pub fn features_for_correct_vector_abi(&self) -> Option<&'static [(u64, &'static str)]> { pub fn features_for_correct_vector_abi(&self) -> Option<&'static [(u64, &'static str)]> {
match &*self.arch { match &*self.arch {
"x86" | "x86_64" => Some(X86_FEATURES_FOR_CORRECT_VECTOR_ABI), "x86" | "x86_64" => Some(X86_FEATURES_FOR_CORRECT_VECTOR_ABI),
"aarch64" => Some(AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI), "aarch64" | "arm64ec" => Some(AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI),
// FIXME: add support for non-tier1 architectures "arm" => Some(ARM_FEATURES_FOR_CORRECT_VECTOR_ABI),
"powerpc" | "powerpc64" => Some(POWERPC_FEATURES_FOR_CORRECT_VECTOR_ABI),
"loongarch64" => Some(&[]), // on-stack ABI, so we complain about all by-val vectors
"riscv32" | "riscv64" => Some(RISCV_FEATURES_FOR_CORRECT_VECTOR_ABI),
"wasm32" | "wasm64" => Some(WASM_FEATURES_FOR_CORRECT_VECTOR_ABI),
"s390x" => Some(S390X_FEATURES_FOR_CORRECT_VECTOR_ABI),
"sparc" | "sparc64" => Some(SPARC_FEATURES_FOR_CORRECT_VECTOR_ABI),
// FIXME: add support for non-tier2 architectures
_ => None, _ => None,
} }
} }

View File

@ -0,0 +1,19 @@
//@ needs-llvm-components: sparc
//@ compile-flags: --target=sparc-unknown-none-elf --crate-type=rlib
//@ build-pass
//@ ignore-pass (test emits codegen-time warnings)
#![no_core]
#![feature(no_core, lang_items, repr_simd)]
#![allow(improper_ctypes_definitions)]
#[lang = "sized"]
trait Sized {}
#[lang = "copy"]
trait Copy {}
#[repr(simd)]
pub struct SimdVec([i32; 4]);
pub extern "C" fn pass_by_vec(_: SimdVec) {}
//~^ this function definition uses a SIMD vector type that is not currently supported with the chosen ABI
//~| WARNING this was previously accepted by the compiler

View File

@ -0,0 +1,12 @@
warning: this function definition uses a SIMD vector type that is not currently supported with the chosen ABI
--> $DIR/simd-abi-checks-empty-list.rs:17:1
|
LL | pub extern "C" fn pass_by_vec(_: SimdVec) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= note: `#[warn(abi_unsupported_vector_types)]` on by default
warning: 1 warning emitted

View File

@ -12,19 +12,19 @@ use std::arch::x86_64::*;
struct Wrapper(__m256); struct Wrapper(__m256);
unsafe extern "C" fn w(_: Wrapper) { unsafe extern "C" fn w(_: Wrapper) {
//~^ ABI error: this function definition uses a vector type that requires the `avx` target feature, which is not enabled //~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
todo!() todo!()
} }
unsafe extern "C" fn f(_: __m256) { unsafe extern "C" fn f(_: __m256) {
//~^ ABI error: this function definition uses a vector type that requires the `avx` target feature, which is not enabled //~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
todo!() todo!()
} }
unsafe extern "C" fn g() -> __m256 { unsafe extern "C" fn g() -> __m256 {
//~^ ABI error: this function definition uses a vector type that requires the `avx` target feature, which is not enabled //~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
todo!() todo!()
} }
@ -53,16 +53,16 @@ unsafe fn test() {
fn main() { fn main() {
unsafe { unsafe {
f(g()); f(g());
//~^ WARNING ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller //~^ WARNING this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
//~| WARNING ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller //~| WARNING this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
} }
unsafe { unsafe {
gavx(favx()); gavx(favx());
//~^ WARNING ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller //~^ WARNING this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
//~| WARNING ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller //~| WARNING this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
} }
@ -73,8 +73,8 @@ fn main() {
unsafe { unsafe {
w(Wrapper(g())); w(Wrapper(g()));
//~^ WARNING ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller //~^ WARNING this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
//~| WARNING ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller //~| WARNING this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
} }

View File

@ -1,4 +1,4 @@
warning: ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:55:11 --> $DIR/simd-abi-checks.rs:55:11
| |
LL | f(g()); LL | f(g());
@ -9,7 +9,7 @@ LL | f(g());
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
warning: ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:55:9 --> $DIR/simd-abi-checks.rs:55:9
| |
LL | f(g()); LL | f(g());
@ -19,7 +19,7 @@ LL | f(g());
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:63:14 --> $DIR/simd-abi-checks.rs:63:14
| |
LL | gavx(favx()); LL | gavx(favx());
@ -29,7 +29,7 @@ LL | gavx(favx());
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:63:9 --> $DIR/simd-abi-checks.rs:63:9
| |
LL | gavx(favx()); LL | gavx(favx());
@ -39,7 +39,7 @@ LL | gavx(favx());
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:75:19 --> $DIR/simd-abi-checks.rs:75:19
| |
LL | w(Wrapper(g())); LL | w(Wrapper(g()));
@ -49,7 +49,7 @@ LL | w(Wrapper(g()));
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function call uses a vector type that requires the `avx` target feature, which is not enabled in the caller warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:75:9 --> $DIR/simd-abi-checks.rs:75:9
| |
LL | w(Wrapper(g())); LL | w(Wrapper(g()));
@ -59,7 +59,7 @@ LL | w(Wrapper(g()));
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function definition uses a vector type that requires the `avx` target feature, which is not enabled warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:26:1 --> $DIR/simd-abi-checks.rs:26:1
| |
LL | unsafe extern "C" fn g() -> __m256 { LL | unsafe extern "C" fn g() -> __m256 {
@ -69,7 +69,7 @@ LL | unsafe extern "C" fn g() -> __m256 {
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function definition uses a vector type that requires the `avx` target feature, which is not enabled warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:20:1 --> $DIR/simd-abi-checks.rs:20:1
| |
LL | unsafe extern "C" fn f(_: __m256) { LL | unsafe extern "C" fn f(_: __m256) {
@ -79,7 +79,7 @@ LL | unsafe extern "C" fn f(_: __m256) {
= note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558> = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`) = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
warning: ABI error: this function definition uses a vector type that requires the `avx` target feature, which is not enabled warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:14:1 --> $DIR/simd-abi-checks.rs:14:1
| |
LL | unsafe extern "C" fn w(_: Wrapper) { LL | unsafe extern "C" fn w(_: Wrapper) {

View File

@ -19,6 +19,6 @@ pub struct SseVector([i64; 2]);
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn f(_: SseVector) { pub unsafe extern "C" fn f(_: SseVector) {
//~^ ABI error: this function definition uses a vector type that requires the `sse` target feature, which is not enabled //~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `sse` target feature, which is not enabled
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler
} }

View File

@ -1,4 +1,4 @@
warning: ABI error: this function definition uses a vector type that requires the `sse` target feature, which is not enabled warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `sse` target feature, which is not enabled
--> $DIR/sse-abi-checks.rs:21:1 --> $DIR/sse-abi-checks.rs:21:1
| |
LL | pub unsafe extern "C" fn f(_: SseVector) { LL | pub unsafe extern "C" fn f(_: SseVector) {