nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-06-05 11:48:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #137092 - RalfJung:abi_unsupported_vector_types-better-error, r=compiler-errors

Browse Source 
abi_unsupported_vector_types: say which type is the problem
This commit is contained in:
Jacob Pratt 2025-02-16 00:51:25 -05:00 committed by GitHub
commit f10f0f09c8
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 129 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
compiler/rustc_monomorphize/messages.ftl
View File

@ -1,17 +1,17 @@
monomorphize_abi_error_disabled_vector_type_call = monomorphize_abi_error_disabled_vector_type_call =
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 this function call uses SIMD vector type `{$ty}` which (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 =
this function definition uses a SIMD vector type that (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled this function definition uses SIMD vector type `{$ty}` which (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 = monomorphize_abi_error_unsupported_vector_type_call =
this function call uses a SIMD vector type that is not currently supported with the chosen ABI this function call uses SIMD vector type `{$ty}` which is not currently supported with the chosen ABI
.label = function called here .label = function called here
monomorphize_abi_error_unsupported_vector_type_def = monomorphize_abi_error_unsupported_vector_type_def =
this function definition uses a SIMD vector type that is not currently supported with the chosen ABI this function definition uses SIMD vector type `{$ty}` which is not currently supported with the chosen ABI
.label = function defined here .label = function defined here
monomorphize_couldnt_dump_mono_stats = monomorphize_couldnt_dump_mono_stats =

9
compiler/rustc_monomorphize/src/errors.rs
View File

@ -1,6 +1,7 @@
use std::path::PathBuf; use std::path::PathBuf;
use rustc_macros::{Diagnostic, LintDiagnostic}; use rustc_macros::{Diagnostic, LintDiagnostic};
use rustc_middle::ty::Ty;
use rustc_span::{Span, Symbol}; use rustc_span::{Span, Symbol};
#[derive(Diagnostic)] #[derive(Diagnostic)]
@ -75,6 +76,7 @@ pub(crate) struct AbiErrorDisabledVectorTypeDef<'a> {
#[label] #[label]
pub span: Span, pub span: Span,
pub required_feature: &'a str, pub required_feature: &'a str,
pub ty: Ty<'a>,
} }
#[derive(LintDiagnostic)] #[derive(LintDiagnostic)]
@ -84,18 +86,21 @@ pub(crate) struct AbiErrorDisabledVectorTypeCall<'a> {
#[label] #[label]
pub span: Span, pub span: Span,
pub required_feature: &'a str, pub required_feature: &'a str,
pub ty: Ty<'a>,
} }
#[derive(LintDiagnostic)] #[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_def)] #[diag(monomorphize_abi_error_unsupported_vector_type_def)]
pub(crate) struct AbiErrorUnsupportedVectorTypeDef { pub(crate) struct AbiErrorUnsupportedVectorTypeDef<'a> {
#[label] #[label]
pub span: Span, pub span: Span,
pub ty: Ty<'a>,
} }
#[derive(LintDiagnostic)] #[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_call)] #[diag(monomorphize_abi_error_unsupported_vector_type_call)]
pub(crate) struct AbiErrorUnsupportedVectorTypeCall { pub(crate) struct AbiErrorUnsupportedVectorTypeCall<'a> {
#[label] #[label]
pub span: Span, pub span: Span,
pub ty: Ty<'a>,
} }

18
compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
View File

@ -34,7 +34,7 @@ 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(Option<&'static str>), mut emit_err: impl FnMut(Ty<'tcx>, Option<&'static str>),
) { ) {
let feature_def = tcx.sess.target.features_for_correct_vector_abi(); let feature_def = tcx.sess.target.features_for_correct_vector_abi();
let codegen_attrs = tcx.codegen_fn_attrs(target_feature_def); let codegen_attrs = tcx.codegen_fn_attrs(target_feature_def);
@ -45,7 +45,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(None); emit_err(arg_abi.layout.ty, None);
continue; continue;
} }
}; };
@ -53,7 +53,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(Some(&feature)); emit_err(arg_abi.layout.ty, Some(&feature));
} }
} }
} }
@ -69,21 +69,21 @@ fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
// function. // function.
return; return;
}; };
do_check_abi(tcx, abi, instance.def_id(), |required_feature| { do_check_abi(tcx, abi, instance.def_id(), |ty, required_feature| {
let span = tcx.def_span(instance.def_id()); let span = tcx.def_span(instance.def_id());
if let Some(required_feature) = required_feature { if let Some(required_feature) = required_feature {
tcx.emit_node_span_lint( tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES, ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID, CRATE_HIR_ID,
span, span,
AbiErrorDisabledVectorTypeDef { span, required_feature }, AbiErrorDisabledVectorTypeDef { span, required_feature, ty },
); );
} else { } else {
tcx.emit_node_span_lint( tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES, ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID, CRATE_HIR_ID,
span, span,
AbiErrorUnsupportedVectorTypeDef { span }, AbiErrorUnsupportedVectorTypeDef { span, ty },
); );
} }
}) })
@ -123,20 +123,20 @@ fn check_call_site_abi<'tcx>(
// ABI failed to compute; this will not get through codegen. // ABI failed to compute; this will not get through codegen.
return; return;
}; };
do_check_abi(tcx, callee_abi, caller.def_id(), |required_feature| { do_check_abi(tcx, callee_abi, caller.def_id(), |ty, required_feature| {
if let Some(required_feature) = required_feature { if let Some(required_feature) = required_feature {
tcx.emit_node_span_lint( tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES, ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID, CRATE_HIR_ID,
span, span,
AbiErrorDisabledVectorTypeCall { span, required_feature }, AbiErrorDisabledVectorTypeCall { span, required_feature, ty },
); );
} else { } else {
tcx.emit_node_span_lint( tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES, ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID, CRATE_HIR_ID,
span, span,
AbiErrorUnsupportedVectorTypeCall { span }, AbiErrorUnsupportedVectorTypeCall { span, ty },
); );
} }
}); });

2
tests/ui/simd-abi-checks-empty-list.rs
View File

@ -15,5 +15,5 @@ trait Copy {}
pub struct SimdVec([i32; 4]); pub struct SimdVec([i32; 4]);
pub extern "C" fn pass_by_vec(_: SimdVec) {} 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 //~^ this function definition uses SIMD vector type `SimdVec` which is not currently supported with the chosen ABI
//~| WARNING this was previously accepted by the compiler //~| WARNING this was previously accepted by the compiler

4
tests/ui/simd-abi-checks-empty-list.stderr
View File

@ -1,4 +1,4 @@
warning: this function definition uses a SIMD vector type that is not currently supported with the chosen ABI warning: this function definition uses SIMD vector type `SimdVec` which is not currently supported with the chosen ABI
--> $DIR/simd-abi-checks-empty-list.rs:17:1 --> $DIR/simd-abi-checks-empty-list.rs:17:1
| |
LL | pub extern "C" fn pass_by_vec(_: SimdVec) {} LL | pub extern "C" fn pass_by_vec(_: SimdVec) {}
@ -11,7 +11,7 @@ LL | pub extern "C" fn pass_by_vec(_: SimdVec) {}
warning: 1 warning emitted warning: 1 warning emitted
Future incompatibility report: Future breakage diagnostic: Future incompatibility report: Future breakage diagnostic:
warning: this function definition uses a SIMD vector type that is not currently supported with the chosen ABI warning: this function definition uses SIMD vector type `SimdVec` which is not currently supported with the chosen ABI
--> $DIR/simd-abi-checks-empty-list.rs:17:1 --> $DIR/simd-abi-checks-empty-list.rs:17:1
| |
LL | pub extern "C" fn pass_by_vec(_: SimdVec) {} LL | pub extern "C" fn pass_by_vec(_: SimdVec) {}

20
tests/ui/simd-abi-checks-s390x.rs
View File

@ -44,13 +44,13 @@ impl<T: Copy> Copy for TransparentWrapper<T> {}
#[no_mangle] #[no_mangle]
extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
*x *x
} }
#[no_mangle] #[no_mangle]
extern "C" fn vector_ret(x: &i8x16) -> i8x16 { extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
*x *x
} }
@ -99,7 +99,7 @@ extern "C" fn vector_wrapper_ret_large(x: &Wrapper<i8x32>) -> Wrapper<i8x32> {
extern "C" fn vector_transparent_wrapper_ret_small( extern "C" fn vector_transparent_wrapper_ret_small(
x: &TransparentWrapper<i8x8>, x: &TransparentWrapper<i8x8>,
) -> TransparentWrapper<i8x8> { ) -> TransparentWrapper<i8x8> {
//~^^^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^^^ ERROR requires the `vector` target feature, which is not enabled
//~^^^^ WARN this was previously accepted //~^^^^ WARN this was previously accepted
*x *x
} }
@ -107,7 +107,7 @@ extern "C" fn vector_transparent_wrapper_ret_small(
extern "C" fn vector_transparent_wrapper_ret( extern "C" fn vector_transparent_wrapper_ret(
x: &TransparentWrapper<i8x16>, x: &TransparentWrapper<i8x16>,
) -> TransparentWrapper<i8x16> { ) -> TransparentWrapper<i8x16> {
//~^^^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^^^ ERROR requires the `vector` target feature, which is not enabled
//~^^^^ WARN this was previously accepted //~^^^^ WARN this was previously accepted
*x *x
} }
@ -121,13 +121,13 @@ extern "C" fn vector_transparent_wrapper_ret_large(
#[no_mangle] #[no_mangle]
extern "C" fn vector_arg_small(x: i8x8) -> i64 { extern "C" fn vector_arg_small(x: i8x8) -> i64 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
unsafe { *(&x as *const i8x8 as *const i64) } unsafe { *(&x as *const i8x8 as *const i64) }
} }
#[no_mangle] #[no_mangle]
extern "C" fn vector_arg(x: i8x16) -> i64 { extern "C" fn vector_arg(x: i8x16) -> i64 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
unsafe { *(&x as *const i8x16 as *const i64) } unsafe { *(&x as *const i8x16 as *const i64) }
} }
@ -139,13 +139,13 @@ extern "C" fn vector_arg_large(x: i8x32) -> i64 {
#[no_mangle] #[no_mangle]
extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
unsafe { *(&x as *const Wrapper<i8x8> as *const i64) } unsafe { *(&x as *const Wrapper<i8x8> as *const i64) }
} }
#[no_mangle] #[no_mangle]
extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
unsafe { *(&x as *const Wrapper<i8x16> as *const i64) } unsafe { *(&x as *const Wrapper<i8x16> as *const i64) }
} }
@ -157,13 +157,13 @@ extern "C" fn vector_wrapper_arg_large(x: Wrapper<i8x32>) -> i64 {
#[no_mangle] #[no_mangle]
extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) } unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) }
} }
#[no_mangle] #[no_mangle]
extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
//~^ ERROR this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled //~^ ERROR requires the `vector` target feature, which is not enabled
//~^^ WARN this was previously accepted //~^^ WARN this was previously accepted
unsafe { *(&x as *const TransparentWrapper<i8x16> as *const i64) } unsafe { *(&x as *const TransparentWrapper<i8x16> as *const i64) }
} }

40
tests/ui/simd-abi-checks-s390x.z10.stderr
View File

@ -1,4 +1,4 @@
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:46:1 --> $DIR/simd-abi-checks-s390x.rs:46:1
| |
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -13,7 +13,7 @@ note: the lint level is defined here
LL | #![deny(abi_unsupported_vector_types)] LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:52:1 --> $DIR/simd-abi-checks-s390x.rs:52:1
| |
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 { LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -23,7 +23,7 @@ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:99:1 --> $DIR/simd-abi-checks-s390x.rs:99:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret_small( LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -35,7 +35,7 @@ LL | | ) -> TransparentWrapper<i8x8> {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:107:1 --> $DIR/simd-abi-checks-s390x.rs:107:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret( LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -47,7 +47,7 @@ LL | | ) -> TransparentWrapper<i8x16> {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:123:1 --> $DIR/simd-abi-checks-s390x.rs:123:1
| |
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 { LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -57,7 +57,7 @@ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:129:1 --> $DIR/simd-abi-checks-s390x.rs:129:1
| |
LL | extern "C" fn vector_arg(x: i8x16) -> i64 { LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -67,7 +67,7 @@ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:141:1 --> $DIR/simd-abi-checks-s390x.rs:141:1
| |
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
@ -77,7 +77,7 @@ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:147:1 --> $DIR/simd-abi-checks-s390x.rs:147:1
| |
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -87,7 +87,7 @@ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:159:1 --> $DIR/simd-abi-checks-s390x.rs:159:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
@ -97,7 +97,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:165:1 --> $DIR/simd-abi-checks-s390x.rs:165:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
@ -110,7 +110,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>)
error: aborting due to 10 previous errors error: aborting due to 10 previous errors
Future incompatibility report: Future breakage diagnostic: Future incompatibility report: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:46:1 --> $DIR/simd-abi-checks-s390x.rs:46:1
| |
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -126,7 +126,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:52:1 --> $DIR/simd-abi-checks-s390x.rs:52:1
| |
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 { LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -142,7 +142,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:99:1 --> $DIR/simd-abi-checks-s390x.rs:99:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret_small( LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -160,7 +160,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:107:1 --> $DIR/simd-abi-checks-s390x.rs:107:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret( LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -178,7 +178,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:123:1 --> $DIR/simd-abi-checks-s390x.rs:123:1
| |
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 { LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -194,7 +194,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:129:1 --> $DIR/simd-abi-checks-s390x.rs:129:1
| |
LL | extern "C" fn vector_arg(x: i8x16) -> i64 { LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -210,7 +210,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:141:1 --> $DIR/simd-abi-checks-s390x.rs:141:1
| |
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
@ -226,7 +226,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:147:1 --> $DIR/simd-abi-checks-s390x.rs:147:1
| |
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -242,7 +242,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:159:1 --> $DIR/simd-abi-checks-s390x.rs:159:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
@ -258,7 +258,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:165:1 --> $DIR/simd-abi-checks-s390x.rs:165:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {

40
tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr
View File

@ -1,4 +1,4 @@
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:46:1 --> $DIR/simd-abi-checks-s390x.rs:46:1
| |
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -13,7 +13,7 @@ note: the lint level is defined here
LL | #![deny(abi_unsupported_vector_types)] LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:52:1 --> $DIR/simd-abi-checks-s390x.rs:52:1
| |
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 { LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -23,7 +23,7 @@ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:99:1 --> $DIR/simd-abi-checks-s390x.rs:99:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret_small( LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -35,7 +35,7 @@ LL | | ) -> TransparentWrapper<i8x8> {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:107:1 --> $DIR/simd-abi-checks-s390x.rs:107:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret( LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -47,7 +47,7 @@ LL | | ) -> TransparentWrapper<i8x16> {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:123:1 --> $DIR/simd-abi-checks-s390x.rs:123:1
| |
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 { LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -57,7 +57,7 @@ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:129:1 --> $DIR/simd-abi-checks-s390x.rs:129:1
| |
LL | extern "C" fn vector_arg(x: i8x16) -> i64 { LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -67,7 +67,7 @@ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:141:1 --> $DIR/simd-abi-checks-s390x.rs:141:1
| |
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
@ -77,7 +77,7 @@ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:147:1 --> $DIR/simd-abi-checks-s390x.rs:147:1
| |
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -87,7 +87,7 @@ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:159:1 --> $DIR/simd-abi-checks-s390x.rs:159:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
@ -97,7 +97,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:165:1 --> $DIR/simd-abi-checks-s390x.rs:165:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
@ -110,7 +110,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>)
error: aborting due to 10 previous errors error: aborting due to 10 previous errors
Future incompatibility report: Future breakage diagnostic: Future incompatibility report: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:46:1 --> $DIR/simd-abi-checks-s390x.rs:46:1
| |
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -126,7 +126,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:52:1 --> $DIR/simd-abi-checks-s390x.rs:52:1
| |
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 { LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -142,7 +142,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:99:1 --> $DIR/simd-abi-checks-s390x.rs:99:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret_small( LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -160,7 +160,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:107:1 --> $DIR/simd-abi-checks-s390x.rs:107:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret( LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -178,7 +178,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:123:1 --> $DIR/simd-abi-checks-s390x.rs:123:1
| |
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 { LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -194,7 +194,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:129:1 --> $DIR/simd-abi-checks-s390x.rs:129:1
| |
LL | extern "C" fn vector_arg(x: i8x16) -> i64 { LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -210,7 +210,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:141:1 --> $DIR/simd-abi-checks-s390x.rs:141:1
| |
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
@ -226,7 +226,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:147:1 --> $DIR/simd-abi-checks-s390x.rs:147:1
| |
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -242,7 +242,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:159:1 --> $DIR/simd-abi-checks-s390x.rs:159:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
@ -258,7 +258,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:165:1 --> $DIR/simd-abi-checks-s390x.rs:165:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {

40
tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr
View File

@ -1,4 +1,4 @@
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:46:1 --> $DIR/simd-abi-checks-s390x.rs:46:1
| |
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -13,7 +13,7 @@ note: the lint level is defined here
LL | #![deny(abi_unsupported_vector_types)] LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:52:1 --> $DIR/simd-abi-checks-s390x.rs:52:1
| |
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 { LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -23,7 +23,7 @@ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:99:1 --> $DIR/simd-abi-checks-s390x.rs:99:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret_small( LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -35,7 +35,7 @@ LL | | ) -> TransparentWrapper<i8x8> {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:107:1 --> $DIR/simd-abi-checks-s390x.rs:107:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret( LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -47,7 +47,7 @@ LL | | ) -> TransparentWrapper<i8x16> {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:123:1 --> $DIR/simd-abi-checks-s390x.rs:123:1
| |
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 { LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -57,7 +57,7 @@ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:129:1 --> $DIR/simd-abi-checks-s390x.rs:129:1
| |
LL | extern "C" fn vector_arg(x: i8x16) -> i64 { LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -67,7 +67,7 @@ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:141:1 --> $DIR/simd-abi-checks-s390x.rs:141:1
| |
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
@ -77,7 +77,7 @@ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:147:1 --> $DIR/simd-abi-checks-s390x.rs:147:1
| |
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -87,7 +87,7 @@ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:159:1 --> $DIR/simd-abi-checks-s390x.rs:159:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
@ -97,7 +97,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8
= 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=+vector`) or locally (`#[target_feature(enable="vector")]`) = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:165:1 --> $DIR/simd-abi-checks-s390x.rs:165:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
@ -110,7 +110,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>)
error: aborting due to 10 previous errors error: aborting due to 10 previous errors
Future incompatibility report: Future breakage diagnostic: Future incompatibility report: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:46:1 --> $DIR/simd-abi-checks-s390x.rs:46:1
| |
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 { LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -126,7 +126,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:52:1 --> $DIR/simd-abi-checks-s390x.rs:52:1
| |
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 { LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -142,7 +142,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:99:1 --> $DIR/simd-abi-checks-s390x.rs:99:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret_small( LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -160,7 +160,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:107:1 --> $DIR/simd-abi-checks-s390x.rs:107:1
| |
LL | / extern "C" fn vector_transparent_wrapper_ret( LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -178,7 +178,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:123:1 --> $DIR/simd-abi-checks-s390x.rs:123:1
| |
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 { LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -194,7 +194,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:129:1 --> $DIR/simd-abi-checks-s390x.rs:129:1
| |
LL | extern "C" fn vector_arg(x: i8x16) -> i64 { LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -210,7 +210,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:141:1 --> $DIR/simd-abi-checks-s390x.rs:141:1
| |
LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 { LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
@ -226,7 +226,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:147:1 --> $DIR/simd-abi-checks-s390x.rs:147:1
| |
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 { LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -242,7 +242,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:159:1 --> $DIR/simd-abi-checks-s390x.rs:159:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
@ -258,7 +258,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Future breakage diagnostic: Future breakage diagnostic:
error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
--> $DIR/simd-abi-checks-s390x.rs:165:1 --> $DIR/simd-abi-checks-s390x.rs:165:1
| |
LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 { LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {

22
tests/ui/simd-abi-checks.rs
View File

@ -13,19 +13,19 @@ use std::arch::x86_64::*;
struct Wrapper(__m256); struct Wrapper(__m256);
unsafe extern "C" fn w(_: Wrapper) { unsafe extern "C" fn w(_: Wrapper) {
//~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled //~^ 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) {
//~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled //~^ 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 {
//~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled //~^ 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!()
} }
@ -55,23 +55,23 @@ unsafe fn test() {
unsafe fn in_closure() -> impl FnOnce() -> __m256 { unsafe fn in_closure() -> impl FnOnce() -> __m256 {
#[inline(always)] // this disables target-feature inheritance #[inline(always)] // this disables target-feature inheritance
|| g() || g()
//~^ 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 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
} }
fn main() { fn main() {
unsafe { unsafe {
f(g()); f(g());
//~^ 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 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 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 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 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 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
} }
@ -82,8 +82,8 @@ fn main() {
unsafe { unsafe {
w(Wrapper(g())); w(Wrapper(g()));
//~^ 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 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 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
} }
@ -98,7 +98,7 @@ fn main() {
fn some_extern() -> __m256; fn some_extern() -> __m256;
} }
some_extern(); some_extern();
//~^ 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 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
} }
} }

44
tests/ui/simd-abi-checks.stderr
View File

@ -1,4 +1,4 @@
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:64:11 --> $DIR/simd-abi-checks.rs:64: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: 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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:64:9 --> $DIR/simd-abi-checks.rs:64: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: 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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:72:14 --> $DIR/simd-abi-checks.rs:72: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: 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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:72:9 --> $DIR/simd-abi-checks.rs:72: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: 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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:84:19 --> $DIR/simd-abi-checks.rs:84: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: 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 function call uses SIMD vector type `Wrapper` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:84:9 --> $DIR/simd-abi-checks.rs:84: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: 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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:100:9 --> $DIR/simd-abi-checks.rs:100:9
| |
LL | some_extern(); LL | some_extern();
@ -69,7 +69,7 @@ LL | some_extern();
= 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: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled warning: this function definition uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:27:1 --> $DIR/simd-abi-checks.rs:27:1
| |
LL | unsafe extern "C" fn g() -> __m256 { LL | unsafe extern "C" fn g() -> __m256 {
@ -79,7 +79,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: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled warning: this function definition uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:21:1 --> $DIR/simd-abi-checks.rs:21:1
| |
LL | unsafe extern "C" fn f(_: __m256) { LL | unsafe extern "C" fn f(_: __m256) {
@ -89,7 +89,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: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled warning: this function definition uses SIMD vector type `Wrapper` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:15:1 --> $DIR/simd-abi-checks.rs:15:1
| |
LL | unsafe extern "C" fn w(_: Wrapper) { LL | unsafe extern "C" fn w(_: Wrapper) {
@ -99,7 +99,7 @@ LL | unsafe extern "C" fn w(_: Wrapper) {
= 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: 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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:57:8 --> $DIR/simd-abi-checks.rs:57:8
| |
LL | || g() LL | || g()
@ -112,7 +112,7 @@ LL | || g()
warning: 11 warnings emitted warning: 11 warnings emitted
Future incompatibility report: Future breakage diagnostic: Future incompatibility report: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:64:11 --> $DIR/simd-abi-checks.rs:64:11
| |
LL | f(g()); LL | f(g());
@ -124,7 +124,7 @@ LL | f(g());
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:64:9 --> $DIR/simd-abi-checks.rs:64:9
| |
LL | f(g()); LL | f(g());
@ -136,7 +136,7 @@ LL | f(g());
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:72:14 --> $DIR/simd-abi-checks.rs:72:14
| |
LL | gavx(favx()); LL | gavx(favx());
@ -148,7 +148,7 @@ LL | gavx(favx());
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:72:9 --> $DIR/simd-abi-checks.rs:72:9
| |
LL | gavx(favx()); LL | gavx(favx());
@ -160,7 +160,7 @@ LL | gavx(favx());
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:84:19 --> $DIR/simd-abi-checks.rs:84:19
| |
LL | w(Wrapper(g())); LL | w(Wrapper(g()));
@ -172,7 +172,7 @@ LL | w(Wrapper(g()));
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `Wrapper` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:84:9 --> $DIR/simd-abi-checks.rs:84:9
| |
LL | w(Wrapper(g())); LL | w(Wrapper(g()));
@ -184,7 +184,7 @@ LL | w(Wrapper(g()));
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:100:9 --> $DIR/simd-abi-checks.rs:100:9
| |
LL | some_extern(); LL | some_extern();
@ -196,7 +196,7 @@ LL | some_extern();
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled warning: this function definition uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:27:1 --> $DIR/simd-abi-checks.rs:27:1
| |
LL | unsafe extern "C" fn g() -> __m256 { LL | unsafe extern "C" fn g() -> __m256 {
@ -208,7 +208,7 @@ LL | unsafe extern "C" fn g() -> __m256 {
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled warning: this function definition uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:21:1 --> $DIR/simd-abi-checks.rs:21:1
| |
LL | unsafe extern "C" fn f(_: __m256) { LL | unsafe extern "C" fn f(_: __m256) {
@ -220,7 +220,7 @@ LL | unsafe extern "C" fn f(_: __m256) {
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled warning: this function definition uses SIMD vector type `Wrapper` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
--> $DIR/simd-abi-checks.rs:15:1 --> $DIR/simd-abi-checks.rs:15:1
| |
LL | unsafe extern "C" fn w(_: Wrapper) { LL | unsafe extern "C" fn w(_: Wrapper) {
@ -232,7 +232,7 @@ LL | unsafe extern "C" fn w(_: Wrapper) {
= note: `#[warn(abi_unsupported_vector_types)]` on by default = note: `#[warn(abi_unsupported_vector_types)]` on by default
Future breakage diagnostic: Future breakage diagnostic:
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 function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
--> $DIR/simd-abi-checks.rs:57:8 --> $DIR/simd-abi-checks.rs:57:8
| |
LL | || g() LL | || g()

2
tests/ui/sse-abi-checks.rs
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) {
//~^ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `sse` target feature, which is not enabled //~^ this function definition uses SIMD vector type `SseVector` which (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
} }

4
tests/ui/sse-abi-checks.stderr
View File

@ -1,4 +1,4 @@
warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `sse` target feature, which is not enabled warning: this function definition uses SIMD vector type `SseVector` which (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) {
@ -12,7 +12,7 @@ LL | pub unsafe extern "C" fn f(_: SseVector) {
warning: 1 warning emitted warning: 1 warning emitted
Future incompatibility report: Future breakage diagnostic: Future incompatibility report: Future breakage diagnostic:
warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `sse` target feature, which is not enabled warning: this function definition uses SIMD vector type `SseVector` which (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) {