mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #137225 - RalfJung:vectorcall, r=nnethercote

Browse Source 
vectorcall ABI: require SSE2

According to the official docs at https://learn.microsoft.com/en-us/cpp/cpp/vectorcall, SSE2 is required for this ABI. Add a check that enforces this.

I put this together with the other checks ensuring the target features required for a function are present... however, since the ABI is known pre-monomorphization, it would be possible to do this check earlier, which would have the advantage of checking even in `cargo check`. It would have the disadvantage of spreading this code in yet more places.

The first commit just does a little refactoring of the mono-time ABI check to make it easier to add the new check.

Cc `@workingjubilee`

try-job: dist-i586-gnu-i586-i686-musl
This commit is contained in:
bors 2025-02-23 14:12:38 +00:00
commit b522e7c5ea
16 changed files with 175 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
compiler/rustc_monomorphize/messages.ftl
View File

@ -1,18 +1,40 @@
monomorphize_abi_error_disabled_vector_type_call =
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 SIMD vector type `{$ty}` which (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled
.label = function defined here
monomorphize_abi_error_disabled_vector_type =
this function {$is_call ->
[true] call
*[false] definition
} uses SIMD vector type `{$ty}` which (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled{$is_call ->
[true] {" "}in the caller
*[false] {""}
}
.label = function {$is_call ->
[true] called
*[false] 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 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 SIMD vector type `{$ty}` which is not currently supported with the chosen ABI
.label = function defined here
monomorphize_abi_error_unsupported_vector_type =
this function {$is_call ->
[true] call
*[false] definition
} uses SIMD vector type `{$ty}` which is not currently supported with the chosen ABI
.label = function {$is_call ->
[true] called
*[false] defined
} here
monomorphize_abi_required_target_feature =
this function {$is_call ->
[true] call
*[false] definition
} uses ABI "{$abi}" which requires the `{$required_feature}` target feature, which is not enabled{$is_call ->
[true] {" "}in the caller
*[false] {""}
}
.label = function {$is_call ->
[true] called
*[false] defined
} here
.help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`)
monomorphize_couldnt_dump_mono_stats =
unexpected error occurred while dumping monomorphization stats: {$error}

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

@ -70,37 +70,36 @@ pub(crate) struct UnknownCguCollectionMode<'a> {
}
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_disabled_vector_type_def)]
#[diag(monomorphize_abi_error_disabled_vector_type)]
#[help]
pub(crate) struct AbiErrorDisabledVectorTypeDef<'a> {
pub(crate) struct AbiErrorDisabledVectorType<'a> {
#[label]
pub span: Span,
pub required_feature: &'a str,
pub ty: Ty<'a>,
/// Whether this is a problem at a call site or at a declaration.
pub is_call: bool,
}
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_disabled_vector_type_call)]
#[diag(monomorphize_abi_error_unsupported_vector_type)]
pub(crate) struct AbiErrorUnsupportedVectorType<'a> {
#[label]
pub span: Span,
pub ty: Ty<'a>,
/// Whether this is a problem at a call site or at a declaration.
pub is_call: bool,
}
#[derive(Diagnostic)]
#[diag(monomorphize_abi_required_target_feature)]
#[help]
pub(crate) struct AbiErrorDisabledVectorTypeCall<'a> {
pub(crate) struct AbiRequiredTargetFeature<'a> {
#[primary_span]
#[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<'a> {
#[label]
pub span: Span,
pub ty: Ty<'a>,
}
#[derive(LintDiagnostic)]
#[diag(monomorphize_abi_error_unsupported_vector_type_call)]
pub(crate) struct AbiErrorUnsupportedVectorTypeCall<'a> {
#[label]
pub span: Span,
pub ty: Ty<'a>,
pub abi: &'a str,
/// Whether this is a problem at a call site or at a declaration.
pub is_call: bool,
}

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

@ -6,13 +6,10 @@ use rustc_middle::mir::{self, traversal};
use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt};
use rustc_session::lint::builtin::ABI_UNSUPPORTED_VECTOR_TYPES;
use rustc_span::def_id::DefId;
use rustc_span::{DUMMY_SP, Span, Symbol};
use rustc_target::callconv::{FnAbi, PassMode};
use rustc_span::{DUMMY_SP, Span, Symbol, sym};
use rustc_target::callconv::{Conv, FnAbi, PassMode};
use crate::errors::{
AbiErrorDisabledVectorTypeCall, AbiErrorDisabledVectorTypeDef,
AbiErrorUnsupportedVectorTypeCall, AbiErrorUnsupportedVectorTypeDef,
};
use crate::errors;
fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
match mode {
@ -27,16 +24,21 @@ fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
/// Checks whether a certain function ABI is compatible with the target features currently enabled
/// for a certain function.
/// If not, `emit_err` is called, with `Some(feature)` if a certain feature should be enabled and
/// with `None` if no feature is known that would make the ABI compatible.
/// `is_call` indicates whether this is a call-site check or a definition-site check;
/// this is only relevant for the wording in the emitted error.
fn do_check_abi<'tcx>(
tcx: TyCtxt<'tcx>,
abi: &FnAbi<'tcx, Ty<'tcx>>,
target_feature_def: DefId,
mut emit_err: impl FnMut(Ty<'tcx>, Option<&'static str>),
def_id: DefId,
is_call: bool,
span: impl Fn() -> Span,
) {
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(def_id);
let have_feature = |feat: Symbol| {
tcx.sess.unstable_target_features.contains(&feat)
|| codegen_attrs.target_features.iter().any(|x| x.name == feat)
};
for arg_abi in abi.args.iter().chain(std::iter::once(&abi.ret)) {
let size = arg_abi.layout.size;
if uses_vector_registers(&arg_abi.mode, &arg_abi.layout.backend_repr) {
@ -44,18 +46,46 @@ fn do_check_abi<'tcx>(
let feature = match feature_def.iter().find(|(bits, _)| size.bits() <= *bits) {
Some((_, feature)) => feature,
None => {
emit_err(arg_abi.layout.ty, None);
let span = span();
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
errors::AbiErrorUnsupportedVectorType {
span,
ty: arg_abi.layout.ty,
is_call,
},
);
continue;
}
};
let feature_sym = Symbol::intern(feature);
if !tcx.sess.unstable_target_features.contains(&feature_sym)
&& !codegen_attrs.target_features.iter().any(|x| x.name == feature_sym)
{
emit_err(arg_abi.layout.ty, Some(&feature));
if !have_feature(Symbol::intern(feature)) {
// Emit error.
let span = span();
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
errors::AbiErrorDisabledVectorType {
span,
required_feature: feature,
ty: arg_abi.layout.ty,
is_call,
},
);
}
}
}
// The `vectorcall` ABI is special in that it requires SSE2 no matter which types are being passed.
if abi.conv == Conv::X86VectorCall && !have_feature(sym::sse2) {
tcx.dcx().emit_err(errors::AbiRequiredTargetFeature {
span: span(),
required_feature: "sse2",
abi: "vectorcall",
is_call,
});
}
}
/// Checks that the ABI of a given instance of a function does not contain vector-passed arguments
@ -68,24 +98,13 @@ fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
// function.
return;
};
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, ty },
);
} else {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
AbiErrorUnsupportedVectorTypeDef { span, ty },
);
}
})
do_check_abi(
tcx,
abi,
instance.def_id(),
/*is_call*/ false,
|| tcx.def_span(instance.def_id()),
)
}
/// Checks that a call expression does not try to pass a vector-passed argument which requires a
@ -122,23 +141,7 @@ 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(), |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, ty },
);
} else {
tcx.emit_node_span_lint(
ABI_UNSUPPORTED_VECTOR_TYPES,
CRATE_HIR_ID,
span,
AbiErrorUnsupportedVectorTypeCall { span, ty },
);
}
});
do_check_abi(tcx, callee_abi, caller.def_id(), /*is_call*/ true, || span);
}
fn check_callees_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>, body: &mir::Body<'tcx>) {

0
tests/ui/simd-abi-checks.rs → tests/ui/abi/simd-abi-checks-avx.rs
View File

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

@ -1,5 +1,5 @@
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-avx.rs:64:11
|
LL | f(g());
| ^^^ function called here
@ -10,7 +10,7 @@ LL | f(g());
= note: `#[warn(abi_unsupported_vector_types)]` on by default
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-avx.rs:64:9
|
LL | f(g());
| ^^^^^^ function called here
@ -20,7 +20,7 @@ LL | f(g());
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:72:14
|
LL | gavx(favx());
| ^^^^^^ function called here
@ -30,7 +30,7 @@ LL | gavx(favx());
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:72:9
|
LL | gavx(favx());
| ^^^^^^^^^^^^ function called here
@ -40,7 +40,7 @@ LL | gavx(favx());
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:84:19
|
LL | w(Wrapper(g()));
| ^^^ function called here
@ -50,7 +50,7 @@ LL | w(Wrapper(g()));
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:84:9
|
LL | w(Wrapper(g()));
| ^^^^^^^^^^^^^^^ function called here
@ -60,7 +60,7 @@ LL | w(Wrapper(g()));
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:100:9
|
LL | some_extern();
| ^^^^^^^^^^^^^ function called here
@ -70,7 +70,7 @@ LL | some_extern();
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:27:1
|
LL | unsafe extern "C" fn g() -> __m256 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -80,7 +80,7 @@ LL | unsafe extern "C" fn g() -> __m256 {
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:21:1
|
LL | unsafe extern "C" fn f(_: __m256) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -90,7 +90,7 @@ LL | unsafe extern "C" fn f(_: __m256) {
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:15:1
|
LL | unsafe extern "C" fn w(_: Wrapper) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -100,7 +100,7 @@ LL | unsafe extern "C" fn w(_: Wrapper) {
= help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
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-avx.rs:57:8
|
LL | || g()
| ^^^ function called here
@ -113,7 +113,7 @@ warning: 11 warnings emitted
Future incompatibility report: Future breakage diagnostic:
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-avx.rs:64:11
|
LL | f(g());
| ^^^ function called here
@ -125,7 +125,7 @@ LL | f(g());
Future breakage diagnostic:
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-avx.rs:64:9
|
LL | f(g());
| ^^^^^^ function called here
@ -137,7 +137,7 @@ LL | f(g());
Future breakage diagnostic:
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-avx.rs:72:14
|
LL | gavx(favx());
| ^^^^^^ function called here
@ -149,7 +149,7 @@ LL | gavx(favx());
Future breakage diagnostic:
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-avx.rs:72:9
|
LL | gavx(favx());
| ^^^^^^^^^^^^ function called here
@ -161,7 +161,7 @@ LL | gavx(favx());
Future breakage diagnostic:
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-avx.rs:84:19
|
LL | w(Wrapper(g()));
| ^^^ function called here
@ -173,7 +173,7 @@ LL | w(Wrapper(g()));
Future breakage diagnostic:
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-avx.rs:84:9
|
LL | w(Wrapper(g()));
| ^^^^^^^^^^^^^^^ function called here
@ -185,7 +185,7 @@ LL | w(Wrapper(g()));
Future breakage diagnostic:
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-avx.rs:100:9
|
LL | some_extern();
| ^^^^^^^^^^^^^ function called here
@ -197,7 +197,7 @@ LL | some_extern();
Future breakage diagnostic:
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-avx.rs:27:1
|
LL | unsafe extern "C" fn g() -> __m256 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -209,7 +209,7 @@ LL | unsafe extern "C" fn g() -> __m256 {
Future breakage diagnostic:
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-avx.rs:21:1
|
LL | unsafe extern "C" fn f(_: __m256) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -221,7 +221,7 @@ LL | unsafe extern "C" fn f(_: __m256) {
Future breakage diagnostic:
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-avx.rs:15:1
|
LL | unsafe extern "C" fn w(_: Wrapper) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -233,7 +233,7 @@ LL | unsafe extern "C" fn w(_: Wrapper) {
Future breakage diagnostic:
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-avx.rs:57:8
|
LL | || g()
| ^^^ function called here

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

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

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

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

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

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

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

@ -6,7 +6,7 @@
//@ build-pass
//@ ignore-pass (test emits codegen-time warnings)
//@ needs-llvm-components: x86
#![feature(no_core, lang_items, repr_simd)]
#![feature(no_core, repr_simd)]
#![no_core]
#![allow(improper_ctypes_definitions)]

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

@ -1,5 +1,5 @@
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-simd-abi-checks.rs:20:1
--> $DIR/simd-abi-checks-sse.rs:20:1
|
LL | pub unsafe extern "C" fn f(_: SseVector) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@ -13,7 +13,7 @@ warning: 1 warning emitted
Future incompatibility report: Future breakage diagnostic:
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-simd-abi-checks.rs:20:1
--> $DIR/simd-abi-checks-sse.rs:20:1
|
LL | pub unsafe extern "C" fn f(_: SseVector) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here

21
tests/ui/abi/vectorcall-abi-checks.rs Normal file
View File

@ -0,0 +1,21 @@
//@ add-core-stubs
//@ compile-flags: --crate-type=rlib --target=i586-unknown-linux-gnu -C target-feature=-sse,-sse2
//@ build-fail
//@ ignore-pass (test emits codegen-time errors)
//@ needs-llvm-components: x86
#![feature(no_core, abi_vectorcall)]
#![no_core]
extern crate minicore;
use minicore::*;
#[no_mangle]
pub extern "vectorcall" fn f() {
//~^ ABI "vectorcall" which requires the `sse2` target feature
}
#[no_mangle]
pub fn call_site() {
f();
//~^ ABI "vectorcall" which requires the `sse2` target feature
}

18
tests/ui/abi/vectorcall-abi-checks.stderr Normal file
View File

@ -0,0 +1,18 @@
error: this function definition uses ABI "vectorcall" which requires the `sse2` target feature, which is not enabled
--> $DIR/vectorcall-abi-checks.rs:13:1
|
LL | pub extern "vectorcall" fn f() {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
|
= help: consider enabling it globally (`-C target-feature=+sse2`) or locally (`#[target_feature(enable="sse2")]`)
error: this function call uses ABI "vectorcall" which requires the `sse2` target feature, which is not enabled in the caller
--> $DIR/vectorcall-abi-checks.rs:19:5
|
LL | f();
| ^^^ function called here
|
= help: consider enabling it globally (`-C target-feature=+sse2`) or locally (`#[target_feature(enable="sse2")]`)
error: aborting due to 2 previous errors

1
tests/ui/extern/extern-vectorcall.rs vendored
View File

@ -2,6 +2,7 @@
//@ revisions: x64 x32
//@ [x64]only-x86_64
//@ [x32]only-x86
//@ [x32]compile-flags: -Ctarget-feature=+sse2
#![feature(abi_vectorcall)]