nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-14 02:49:40 +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 =
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
.help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`)
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
.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
this function call uses SIMD vector type `{$ty}` which 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
this function definition uses SIMD vector type `{$ty}` which is not currently supported with the chosen ABI
.label = function defined here
monomorphize_couldnt_dump_mono_stats =

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

@ -1,6 +1,7 @@
use std::path::PathBuf;
use rustc_macros::{Diagnostic, LintDiagnostic};
use rustc_middle::ty::Ty;
use rustc_span::{Span, Symbol};
#[derive(Diagnostic)]
@ -75,6 +76,7 @@ pub(crate) struct AbiErrorDisabledVectorTypeDef<'a> {
#[label]
pub span: Span,
pub required_feature: &'a str,
pub ty: Ty<'a>,
}
#[derive(LintDiagnostic)]
@ -84,18 +86,21 @@ pub(crate) struct AbiErrorDisabledVectorTypeCall<'a> {
#[label]
pub span: Span,
pub required_feature: &'a str,
pub ty: Ty<'a>,
}
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_def)]
pub(crate) struct AbiErrorUnsupportedVectorTypeDef {
pub(crate) struct AbiErrorUnsupportedVectorTypeDef<'a> {
#[label]
pub span: Span,
pub ty: Ty<'a>,
}
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_call)]
pub(crate) struct AbiErrorUnsupportedVectorTypeCall {
pub(crate) struct AbiErrorUnsupportedVectorTypeCall<'a> {
#[label]
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>,
abi: &FnAbi<'tcx, Ty<'tcx>>,
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 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) {
Some((_, feature)) => feature,
None => {
emit_err(None);
emit_err(arg_abi.layout.ty, None);
continue;
}
};
@ -53,7 +53,7 @@ fn do_check_abi<'tcx>(
if !tcx.sess.unstable_target_features.contains(&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.
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());
if let Some(required_feature) = required_feature {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
AbiErrorDisabledVectorTypeDef { span, required_feature },
AbiErrorDisabledVectorTypeDef { span, required_feature, ty },
);
} else {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
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.
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 {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
AbiErrorDisabledVectorTypeCall { span, required_feature },
AbiErrorDisabledVectorTypeCall { span, required_feature, ty },
);
} else {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
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 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

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
|
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
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
|
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]
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
*x
}
#[no_mangle]
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
*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(
x: &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
*x
}
@ -107,7 +107,7 @@ extern "C" fn vector_transparent_wrapper_ret_small(
extern "C" fn vector_transparent_wrapper_ret(
x: &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
*x
}
@ -121,13 +121,13 @@ extern "C" fn vector_transparent_wrapper_ret_large(
#[no_mangle]
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
unsafe { *(&x as *const i8x8 as *const i64) }
}
#[no_mangle]
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
unsafe { *(&x as *const i8x16 as *const i64) }
}
@ -139,13 +139,13 @@ extern "C" fn vector_arg_large(x: i8x32) -> i64 {
#[no_mangle]
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
unsafe { *(&x as *const Wrapper<i8x8> as *const i64) }
}
#[no_mangle]
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
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]
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
unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) }
}
#[no_mangle]
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
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
|
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)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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
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
|
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -126,7 +126,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -142,7 +142,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -160,7 +160,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -178,7 +178,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -194,7 +194,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -210,7 +210,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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:
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
|
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -242,7 +242,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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:
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
|
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
|
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)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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
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
|
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -126,7 +126,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -142,7 +142,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -160,7 +160,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -178,7 +178,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -194,7 +194,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -210,7 +210,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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:
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
|
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -242,7 +242,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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:
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
|
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
|
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)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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
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
|
LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
@ -126,7 +126,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
@ -142,7 +142,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | / extern "C" fn vector_transparent_wrapper_ret_small(
@ -160,7 +160,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | / extern "C" fn vector_transparent_wrapper_ret(
@ -178,7 +178,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
@ -194,7 +194,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
@ -210,7 +210,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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:
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
|
LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
@ -242,7 +242,7 @@ LL | #![deny(abi_unsupported_vector_types)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
|
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:
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
|
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);
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
todo!()
}
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
todo!()
}
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
todo!()
}
@ -55,23 +55,23 @@ unsafe fn test() {
unsafe fn in_closure() -> impl FnOnce() -> __m256 {
#[inline(always)] // this disables target-feature inheritance
|| 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
}
fn main() {
unsafe {
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 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 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
}
unsafe {
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 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 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
}
@ -82,8 +82,8 @@ fn main() {
unsafe {
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 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 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
}
@ -98,7 +98,7 @@ fn main() {
fn some_extern() -> __m256;
}
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
}
}

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
|
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")]`)
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
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>
= 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
|
LL | || g()
@ -112,7 +112,7 @@ LL | || g()
warning: 11 warnings emitted
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
|
LL | f(g());
@ -124,7 +124,7 @@ LL | f(g());
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
LL | f(g());
@ -136,7 +136,7 @@ LL | f(g());
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
LL | gavx(favx());
@ -148,7 +148,7 @@ LL | gavx(favx());
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
LL | gavx(favx());
@ -160,7 +160,7 @@ LL | gavx(favx());
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
LL | w(Wrapper(g()));
@ -172,7 +172,7 @@ LL | w(Wrapper(g()));
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
LL | w(Wrapper(g()));
@ -184,7 +184,7 @@ LL | w(Wrapper(g()));
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
LL | some_extern();
@ -196,7 +196,7 @@ LL | some_extern();
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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
|
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
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
|
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
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
|
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
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
|
LL | || g()

2
tests/ui/sse-abi-checks.rs
View File

@ -19,6 +19,6 @@ pub struct SseVector([i64; 2]);
#[no_mangle]
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
}

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
|
LL | pub unsafe extern "C" fn f(_: SseVector) {
@ -12,7 +12,7 @@ LL | pub unsafe extern "C" fn f(_: SseVector) {
warning: 1 warning emitted
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
|
LL | pub unsafe extern "C" fn f(_: SseVector) {