user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #143026 - jdonszelmann:rollup-z7mkuyt, r=jdonszelmann

Browse source 
Rollup of 7 pull requests

Successful merges:

 - rust-lang/rust#142146 (Withdraw the claim `extern "C-cmse-nonsecure-*"` always matches `extern "C"`)
 - rust-lang/rust#142200 (`tests/ui`: A New Order [8/N])
 - rust-lang/rust#142724 (Add runtime check to avoid overwrite arg in `Diag`)
 - rust-lang/rust#142809 (Add PrintTAFn flag for targeted type analysis printing)
 - rust-lang/rust#142976 (Check CoerceUnsized impl validity before coercing)
 - rust-lang/rust#142992 (Convert some ABI tests to use `extern "rust-invalid"`)
 - rust-lang/rust#143000 (Make `Sub`, `Mul`, `Div` and `Rem`  `const_traits`)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2025-06-25 23:33:23 +00:00
commit bc4376fa73
118 changed files with 966 additions and 944 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_abi/src/canon_abi.rs
View file

@ -63,8 +63,8 @@ impl fmt::Display for CanonAbi {
CanonAbi::Custom => ExternAbi::Custom,
CanonAbi::Arm(arm_call) => match arm_call {
ArmCall::Aapcs => ExternAbi::Aapcs { unwind: false },
ArmCall::CCmseNonSecureCall => ExternAbi::CCmseNonSecureCall,
ArmCall::CCmseNonSecureEntry => ExternAbi::CCmseNonSecureEntry,
ArmCall::CCmseNonSecureCall => ExternAbi::CmseNonSecureCall,
ArmCall::CCmseNonSecureEntry => ExternAbi::CmseNonSecureEntry,
},
CanonAbi::GpuKernel => ExternAbi::GpuKernel,
CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {

8
compiler/rustc_abi/src/extern_abi.rs
View file

@ -59,9 +59,9 @@ pub enum ExternAbi {
unwind: bool,
},
/// extremely constrained barely-C ABI for TrustZone
CCmseNonSecureCall,
CmseNonSecureCall,
/// extremely constrained barely-C ABI for TrustZone
CCmseNonSecureEntry,
CmseNonSecureEntry,
/* gpu */
/// An entry-point function called by the GPU's host
@ -140,8 +140,6 @@ macro_rules! abi_impls {
abi_impls! {
ExternAbi = {
C { unwind: false } =><= "C",
CCmseNonSecureCall =><= "C-cmse-nonsecure-call",
CCmseNonSecureEntry =><= "C-cmse-nonsecure-entry",
C { unwind: true } =><= "C-unwind",
Rust =><= "Rust",
Aapcs { unwind: false } =><= "aapcs",
@ -150,6 +148,8 @@ abi_impls! {
AvrNonBlockingInterrupt =><= "avr-non-blocking-interrupt",
Cdecl { unwind: false } =><= "cdecl",
Cdecl { unwind: true } =><= "cdecl-unwind",
CmseNonSecureCall =><= "cmse-nonsecure-call",
CmseNonSecureEntry =><= "cmse-nonsecure-entry",
Custom =><= "custom",
EfiApi =><= "efiapi",
Fastcall { unwind: false } =><= "fastcall",

6
compiler/rustc_ast_lowering/src/stability.rs
View file

@ -127,12 +127,12 @@ pub fn extern_abi_stability(abi: ExternAbi) -> Result<(), UnstableAbi> {
feature: sym::abi_riscv_interrupt,
explain: GateReason::Experimental,
}),
ExternAbi::CCmseNonSecureCall => Err(UnstableAbi {
ExternAbi::CmseNonSecureCall => Err(UnstableAbi {
abi,
feature: sym::abi_c_cmse_nonsecure_call,
feature: sym::abi_cmse_nonsecure_call,
explain: GateReason::Experimental,
}),
ExternAbi::CCmseNonSecureEntry => Err(UnstableAbi {
ExternAbi::CmseNonSecureEntry => Err(UnstableAbi {
abi,
feature: sym::cmse_nonsecure_entry,
explain: GateReason::Experimental,

8
compiler/rustc_borrowck/src/diagnostics/mod.rs
View file

@ -1284,8 +1284,14 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
&& !spans.is_empty()
{
let mut span: MultiSpan = spans.clone().into();
err.arg("ty", param_ty.to_string());
let msg = err.dcx.eagerly_translate_to_string(
fluent::borrowck_moved_a_fn_once_in_call_def,
err.args.iter(),
);
err.remove_arg("ty");
for sp in spans {
span.push_span_label(sp, fluent::borrowck_moved_a_fn_once_in_call_def);
span.push_span_label(sp, msg.clone());
}
span.push_span_label(
fn_call_span,

1
compiler/rustc_builtin_macros/src/errors.rs
View file

@ -660,6 +660,7 @@ impl Subdiagnostic for FormatUnusedArg {
fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
diag.arg("named", self.named);
let msg = diag.eagerly_translate(crate::fluent_generated::builtin_macros_format_unused_arg);
diag.remove_arg("named");
diag.span_label(self.span, msg);
}
}

6
compiler/rustc_codegen_llvm/src/back/lto.rs
View file

@ -587,7 +587,7 @@ fn thin_lto(
}
fn enable_autodiff_settings(ad: &[config::AutoDiff]) {
for &val in ad {
for val in ad {
// We intentionally don't use a wildcard, to not forget handling anything new.
match val {
config::AutoDiff::PrintPerf => {
@ -599,6 +599,10 @@ fn enable_autodiff_settings(ad: &[config::AutoDiff]) {
config::AutoDiff::PrintTA => {
llvm::set_print_type(true);
}
config::AutoDiff::PrintTAFn(fun) => {
llvm::set_print_type(true); // Enable general type printing
llvm::set_print_type_fun(&fun); // Set specific function to analyze
}
config::AutoDiff::Inline => {
llvm::set_inline(true);
}

17
compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
View file

@ -57,14 +57,19 @@ pub(crate) use self::Enzyme_AD::*;
#[cfg(llvm_enzyme)]
pub(crate) mod Enzyme_AD {
use std::ffi::{CString, c_char};
use libc::c_void;
unsafe extern "C" {
pub(crate) fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);
pub(crate) fn EnzymeSetCLString(arg1: *mut ::std::os::raw::c_void, arg2: *const c_char);
}
unsafe extern "C" {
static mut EnzymePrintPerf: c_void;
static mut EnzymePrintActivity: c_void;
static mut EnzymePrintType: c_void;
static mut EnzymeFunctionToAnalyze: c_void;
static mut EnzymePrint: c_void;
static mut EnzymeStrictAliasing: c_void;
static mut looseTypeAnalysis: c_void;
@ -86,6 +91,15 @@ pub(crate) mod Enzyme_AD {
EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintType), print as u8);
}
}
pub(crate) fn set_print_type_fun(fun_name: &str) {
let c_fun_name = CString::new(fun_name).unwrap();
unsafe {
EnzymeSetCLString(
std::ptr::addr_of_mut!(EnzymeFunctionToAnalyze),
c_fun_name.as_ptr() as *const c_char,
);
}
}
pub(crate) fn set_print(print: bool) {
unsafe {
EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrint), print as u8);
@ -132,6 +146,9 @@ pub(crate) mod Fallback_AD {
pub(crate) fn set_print_type(print: bool) {
unimplemented!()
}
pub(crate) fn set_print_type_fun(fun_name: &str) {
unimplemented!()
}
pub(crate) fn set_print(print: bool) {
unimplemented!()
}

3
compiler/rustc_const_eval/src/errors.rs
View file

@ -291,6 +291,9 @@ impl Subdiagnostic for FrameNote {
span.push_span_label(self.span, fluent::const_eval_frame_note_last);
}
let msg = diag.eagerly_translate(fluent::const_eval_frame_note);
diag.remove_arg("times");
diag.remove_arg("where_");
diag.remove_arg("instance");
diag.span_note(span, msg);
}
}

2
compiler/rustc_error_codes/src/error_codes/E0775.md
View file

@ -8,7 +8,7 @@ Erroneous code example:
```ignore (no longer emitted)
#![feature(cmse_nonsecure_entry)]
pub extern "C-cmse-nonsecure-entry" fn entry_function() {}
pub extern "cmse-nonsecure-entry" fn entry_function() {}
```
To fix this error, compile your code for a Rust target that supports the

8
compiler/rustc_error_codes/src/error_codes/E0781.md
View file

@ -1,12 +1,12 @@
The `C-cmse-nonsecure-call` ABI can only be used with function pointers.
The `cmse-nonsecure-call` ABI can only be used with function pointers.
Erroneous code example:
```compile_fail,E0781
#![feature(abi_c_cmse_nonsecure_call)]
#![feature(abi_cmse_nonsecure_call)]
pub extern "C-cmse-nonsecure-call" fn test() {}
pub extern "cmse-nonsecure-call" fn test() {}
```
The `C-cmse-nonsecure-call` ABI should be used by casting function pointers to
The `cmse-nonsecure-call` ABI should be used by casting function pointers to
specific addresses.

14
compiler/rustc_error_codes/src/error_codes/E0798.md
View file

@ -1,4 +1,4 @@
Functions marked as `C-cmse-nonsecure-call` place restrictions on their
Functions marked as `cmse-nonsecure-call` place restrictions on their
inputs and outputs.
- inputs must fit in the 4 available 32-bit argument registers. Alignment
@ -12,12 +12,12 @@ see [arm's aapcs32](https://github.com/ARM-software/abi-aa/releases).
Erroneous code example:
```ignore (only fails on supported targets)
#![feature(abi_c_cmse_nonsecure_call)]
```ignore (host errors will not match for target)
#![feature(abi_cmse_nonsecure_call)]
#[no_mangle]
pub fn test(
f: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32, u32) -> u32,
f: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32, u32) -> u32,
) -> u32 {
f(1, 2, 3, 4, 5)
}
@ -27,12 +27,12 @@ Arguments' alignment is respected. In the example below, padding is inserted
so that the `u64` argument is passed in registers r2 and r3. There is then no
room left for the final `f32` argument
```ignore (only fails on supported targets)
#![feature(abi_c_cmse_nonsecure_call)]
```ignore (host errors will not match for target)
#![feature(abi_cmse_nonsecure_call)]
#[no_mangle]
pub fn test(
f: extern "C-cmse-nonsecure-call" fn(u32, u64, f32) -> u32,
f: extern "cmse-nonsecure-call" fn(u32, u64, f32) -> u32,
) -> u32 {
f(1, 2, 3.0)
}

2
compiler/rustc_error_codes/src/lib.rs
View file

@ -690,5 +690,5 @@ E0805: 0805,
// E0723, // unstable feature in `const` context
// E0738, // Removed; errored on `#[track_caller] fn`s in `extern "Rust" { ... }`.
// E0744, // merged into E0728
// E0776, // Removed; cmse_nonsecure_entry is now `C-cmse-nonsecure-entry`
// E0776, // Removed; `#[cmse_nonsecure_entry]` is now `extern "cmse-nonsecure-entry"`
// E0796, // unused error code. We use `static_mut_refs` lint instead.

32
compiler/rustc_errors/src/diagnostic.rs
View file

@ -289,6 +289,9 @@ pub struct DiagInner {
pub suggestions: Suggestions,
pub args: DiagArgMap,
// This is used to store args and restore them after a subdiagnostic is rendered.
pub reserved_args: DiagArgMap,
/// This is not used for highlighting or rendering any error message. Rather, it can be used
/// as a sort key to sort a buffer of diagnostics. By default, it is the primary span of
/// `span` if there is one. Otherwise, it is `DUMMY_SP`.
@ -319,6 +322,7 @@ impl DiagInner {
children: vec![],
suggestions: Suggestions::Enabled(vec![]),
args: Default::default(),
reserved_args: Default::default(),
sort_span: DUMMY_SP,
is_lint: None,
long_ty_path: None,
@ -390,7 +394,27 @@ impl DiagInner {
}
pub(crate) fn arg(&mut self, name: impl Into<DiagArgName>, arg: impl IntoDiagArg) {
self.args.insert(name.into(), arg.into_diag_arg(&mut self.long_ty_path));
let name = name.into();
let value = arg.into_diag_arg(&mut self.long_ty_path);
// This assertion is to avoid subdiagnostics overwriting an existing diagnostic arg.
debug_assert!(
!self.args.contains_key(&name) || self.args.get(&name) == Some(&value),
"arg {} already exists",
name
);
self.args.insert(name, value);
}
pub fn remove_arg(&mut self, name: &str) {
self.args.swap_remove(name);
}
pub fn store_args(&mut self) {
self.reserved_args = self.args.clone();
}
pub fn restore_args(&mut self) {
self.args = std::mem::take(&mut self.reserved_args);
}
/// Fields used for Hash, and PartialEq trait.
@ -1423,6 +1447,12 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
self.downgrade_to_delayed_bug();
self.emit()
}
pub fn remove_arg(&mut self, name: &str) {
if let Some(diag) = self.diag.as_mut() {
diag.remove_arg(name);
}
}
}
/// Destructor bomb: every `Diag` must be consumed (emitted, cancelled, etc.)

1
compiler/rustc_feature/src/removed.rs
View file

@ -54,6 +54,7 @@ declare_features! (
/// Allows using the `amdgpu-kernel` ABI.
(removed, abi_amdgpu_kernel, "1.77.0", Some(51575), None, 120495),
(removed, abi_c_cmse_nonsecure_call, "CURRENT_RUSTC_VERSION", Some(81391), Some("renamed to abi_cmse_nonsecure_call"), 142146),
(removed, advanced_slice_patterns, "1.42.0", Some(62254),
Some("merged into `#![feature(slice_patterns)]`"), 67712),
(removed, allocator, "1.0.0", None, None),

6
compiler/rustc_feature/src/unstable.rs
View file

@ -353,8 +353,8 @@ declare_features! (
/// Allows `extern "avr-interrupt" fn()` and `extern "avr-non-blocking-interrupt" fn()`.
(unstable, abi_avr_interrupt, "1.45.0", Some(69664)),
/// Allows `extern "C-cmse-nonsecure-call" fn()`.
(unstable, abi_c_cmse_nonsecure_call, "1.51.0", Some(81391)),
/// Allows `extern "cmse-nonsecure-call" fn()`.
(unstable, abi_cmse_nonsecure_call, "CURRENT_RUSTC_VERSION", Some(81391)),
/// Allows `extern "custom" fn()`.
(unstable, abi_custom, "CURRENT_RUSTC_VERSION", Some(140829)),
/// Allows `extern "gpu-kernel" fn()`.
@ -431,7 +431,7 @@ declare_features! (
(unstable, closure_lifetime_binder, "1.64.0", Some(97362)),
/// Allows `#[track_caller]` on closures and coroutines.
(unstable, closure_track_caller, "1.57.0", Some(87417)),
/// Allows `extern "C-cmse-nonsecure-entry" fn()`.
/// Allows `extern "cmse-nonsecure-entry" fn()`.
(unstable, cmse_nonsecure_entry, "1.48.0", Some(75835)),
/// Allows `async {}` expressions in const contexts.
(unstable, const_async_blocks, "1.53.0", Some(85368)),

4
compiler/rustc_hir_analysis/messages.ftl
View file

@ -73,10 +73,10 @@ hir_analysis_closure_implicit_hrtb = implicit types in closure signatures are fo
.label = `for<...>` is here
hir_analysis_cmse_call_generic =
function pointers with the `"C-cmse-nonsecure-call"` ABI cannot contain generics in their type
function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
hir_analysis_cmse_entry_generic =
functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
hir_analysis_cmse_inputs_stack_spill =
arguments for `{$abi}` function too large to pass via registers

1
compiler/rustc_hir_analysis/src/errors.rs
View file

@ -127,6 +127,7 @@ pub(crate) enum AssocItemNotFoundSugg<'a> {
SimilarInOtherTrait {
#[primary_span]
span: Span,
trait_name: &'a str,
assoc_kind: &'static str,
suggested_name: Symbol,
},

10
compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
View file

@ -18,7 +18,7 @@ pub(crate) fn validate_cmse_abi<'tcx>(
fn_sig: ty::PolyFnSig<'tcx>,
) {
match abi {
ExternAbi::CCmseNonSecureCall => {
ExternAbi::CmseNonSecureCall => {
let hir_node = tcx.hir_node(hir_id);
let hir::Node::Ty(hir::Ty {
span: bare_fn_span,
@ -38,7 +38,7 @@ pub(crate) fn validate_cmse_abi<'tcx>(
dcx,
span,
E0781,
"the `\"C-cmse-nonsecure-call\"` ABI is only allowed on function pointers"
"the `\"cmse-nonsecure-call\"` ABI is only allowed on function pointers"
)
.emit();
return;
@ -78,7 +78,7 @@ pub(crate) fn validate_cmse_abi<'tcx>(
}
};
}
ExternAbi::CCmseNonSecureEntry => {
ExternAbi::CmseNonSecureEntry => {
let hir_node = tcx.hir_node(hir_id);
let Some(hir::FnSig { decl, span: fn_sig_span, .. }) = hir_node.fn_sig() else {
// might happen when this ABI is used incorrectly. That will be handled elsewhere
@ -203,11 +203,11 @@ fn should_emit_generic_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError
match layout_err {
TooGeneric(ty) => {
match abi {
ExternAbi::CCmseNonSecureCall => {
ExternAbi::CmseNonSecureCall => {
// prevent double reporting of this error
!ty.is_impl_trait()
}
ExternAbi::CCmseNonSecureEntry => true,
ExternAbi::CmseNonSecureEntry => true,
_ => bug!("invalid ABI: {abi}"),
}
}

1
compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
View file

@ -309,6 +309,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
// change the associated item.
err.sugg = Some(errors::AssocItemNotFoundSugg::SimilarInOtherTrait {
span: assoc_ident.span,
trait_name: &trait_name,
assoc_kind: assoc_kind_str,
suggested_name,
});

15
compiler/rustc_hir_typeck/src/coercion.rs
View file

@ -46,7 +46,7 @@ use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
use rustc_infer::infer::relate::RelateResult;
use rustc_infer::infer::{Coercion, DefineOpaqueTypes, InferOk, InferResult};
use rustc_infer::traits::{
IfExpressionCause, MatchExpressionArmCause, Obligation, PredicateObligation,
IfExpressionCause, ImplSource, MatchExpressionArmCause, Obligation, PredicateObligation,
PredicateObligations, SelectionError,
};
use rustc_middle::span_bug;
@ -704,6 +704,19 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
// be silent, as it causes a type mismatch later.
}
Ok(Some(ImplSource::UserDefined(impl_source))) => {
queue.extend(impl_source.nested);
// Certain incoherent `CoerceUnsized` implementations may cause ICEs,
// so check the impl's validity. Taint the body so that we don't try
// to evaluate these invalid coercions in CTFE. We only need to do this
// for local impls, since upstream impls should be valid.
if impl_source.impl_def_id.is_local()
&& let Err(guar) =
self.tcx.ensure_ok().coerce_unsized_info(impl_source.impl_def_id)
{
self.fcx.set_tainted_by_errors(guar);
}
}
Ok(Some(impl_source)) => queue.extend(impl_source.nested_obligations()),
}
}

5
compiler/rustc_lint/src/levels.rs
View file

@ -482,7 +482,8 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
let name = lint_name.as_str();
let suggestion = RenamedLintSuggestion::WithoutSpan { replace };
let requested_level = RequestedLevel { level, lint_name };
let lint = RenamedLintFromCommandLine { name, suggestion, requested_level };
let lint =
RenamedLintFromCommandLine { name, replace, suggestion, requested_level };
self.emit_lint(RENAMED_AND_REMOVED_LINTS, lint);
}
CheckLintNameResult::Removed(ref reason) => {
@ -824,7 +825,7 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
RenamedLintSuggestion::WithSpan { suggestion: sp, replace };
let name =
tool_ident.map(|tool| format!("{tool}::{name}")).unwrap_or(name);
let lint = RenamedLint { name: name.as_str(), suggestion };
let lint = RenamedLint { name: name.as_str(), replace, suggestion };
self.emit_span_lint(RENAMED_AND_REMOVED_LINTS, sp.into(), lint);
}

4
compiler/rustc_lint/src/lifetime_syntax.rs
View file

@ -422,12 +422,12 @@ fn build_mismatch_suggestion(
lifetime_name: &str,
infos: &[&Info<'_>],
) -> lints::MismatchedLifetimeSyntaxesSuggestion {
let lifetime_name = lifetime_name.to_owned();
let lifetime_name_sugg = lifetime_name.to_owned();
let suggestions = infos.iter().map(|info| info.suggestion(&lifetime_name)).collect();
lints::MismatchedLifetimeSyntaxesSuggestion::Explicit {
lifetime_name,
lifetime_name_sugg,
suggestions,
tool_only: false,
}

11
compiler/rustc_lint/src/lints.rs
View file

@ -1089,6 +1089,7 @@ pub(crate) struct DeprecatedLintNameFromCommandLine<'a> {
#[diag(lint_renamed_lint)]
pub(crate) struct RenamedLint<'a> {
pub name: &'a str,
pub replace: &'a str,
#[subdiagnostic]
pub suggestion: RenamedLintSuggestion<'a>,
}
@ -1109,6 +1110,7 @@ pub(crate) enum RenamedLintSuggestion<'a> {
#[diag(lint_renamed_lint)]
pub(crate) struct RenamedLintFromCommandLine<'a> {
pub name: &'a str,
pub replace: &'a str,
#[subdiagnostic]
pub suggestion: RenamedLintSuggestion<'a>,
#[subdiagnostic]
@ -3244,7 +3246,7 @@ pub(crate) enum MismatchedLifetimeSyntaxesSuggestion {
},
Explicit {
lifetime_name: String,
lifetime_name_sugg: String,
suggestions: Vec<(Span, String)>,
tool_only: bool,
},
@ -3298,13 +3300,12 @@ impl Subdiagnostic for MismatchedLifetimeSyntaxesSuggestion {
);
}
Explicit { lifetime_name, suggestions, tool_only } => {
diag.arg("lifetime_name", lifetime_name);
Explicit { lifetime_name_sugg, suggestions, tool_only } => {
diag.arg("lifetime_name_sugg", lifetime_name_sugg);
let msg = diag.eagerly_translate(
fluent::lint_mismatched_lifetime_syntaxes_suggestion_explicit,
);
diag.remove_arg("lifetime_name_sugg");
diag.multipart_suggestion_with_style(
msg,
suggestions,

30
compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
View file

@ -220,7 +220,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
}
/// Generates the code for a field with no attributes.
fn generate_field_arg(&mut self, binding_info: &BindingInfo<'_>) -> TokenStream {
fn generate_field_arg(&mut self, binding_info: &BindingInfo<'_>) -> (TokenStream, TokenStream) {
let diag = &self.parent.diag;
let field = binding_info.ast();
@ -230,12 +230,16 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
let ident = field.ident.as_ref().unwrap();
let ident = format_ident!("{}", ident); // strip `r#` prefix, if present
quote! {
let args = quote! {
#diag.arg(
stringify!(#ident),
#field_binding
);
}
};
let remove_args = quote! {
#diag.remove_arg(stringify!(#ident));
};
(args, remove_args)
}
/// Generates the necessary code for all attributes on a field.
@ -600,8 +604,13 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
calls.extend(call);
}
let plain_args: TokenStream = self
let store_args = quote! {
#diag.store_args();
};
let restore_args = quote! {
#diag.restore_args();
};
let (plain_args, remove_args): (TokenStream, TokenStream) = self
.variant
.bindings()
.iter()
@ -610,12 +619,23 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
.collect();
let formatting_init = &self.formatting_init;
// For #[derive(Subdiagnostic)]
//
// - Store args of the main diagnostic for later restore.
// - add args of subdiagnostic.
// - Generate the calls, such as note, label, etc.
// - Remove the arguments for allowing Vec<Subdiagnostic> to be used.
// - Restore the arguments for allowing main and subdiagnostic share the same fields.
Ok(quote! {
#init
#formatting_init
#attr_args
#store_args
#plain_args
#calls
#remove_args
#restore_args
})
}
}

2
compiler/rustc_metadata/src/dependency_format.rs
View file

@ -314,7 +314,7 @@ fn add_library(
crate_name: tcx.crate_name(cnum),
non_static_deps: unavailable_as_static
.drain(..)
.map(|cnum| NonStaticCrateDep { crate_name: tcx.crate_name(cnum) })
.map(|cnum| NonStaticCrateDep { crate_name_: tcx.crate_name(cnum) })
.collect(),
rustc_driver_help: linking_to_rustc_driver.then_some(RustcDriverHelp),
});

3
compiler/rustc_metadata/src/errors.rs
View file

@ -45,7 +45,8 @@ pub struct CrateDepMultiple {
#[derive(Subdiagnostic)]
#[note(metadata_crate_dep_not_static)]
pub struct NonStaticCrateDep {
pub crate_name: Symbol,
/// It's different from `crate_name` in main Diagnostic.
pub crate_name_: Symbol,
}
#[derive(Subdiagnostic)]

10
compiler/rustc_middle/src/ty/layout.rs
View file

@ -1248,13 +1248,13 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: ExternAbi)
| EfiApi
| AvrInterrupt
| AvrNonBlockingInterrupt
| CmseNonSecureCall
| CmseNonSecureEntry
| Custom
| RiscvInterruptM
| RiscvInterruptS
| CCmseNonSecureCall
| CCmseNonSecureEntry
| Custom
| Unadjusted
| RustInvalid => false,
| RustInvalid
| Unadjusted => false,
Rust | RustCall | RustCold => tcx.sess.panic_strategy() == PanicStrategy::Unwind,
}
}

17
compiler/rustc_mir_build/src/errors.rs
View file

@ -994,14 +994,15 @@ pub(crate) struct PatternNotCovered<'s, 'tcx> {
pub(crate) uncovered: Uncovered,
#[subdiagnostic]
pub(crate) inform: Option<Inform>,
#[label(mir_build_confused)]
pub(crate) interpreted_as_const: Option<Span>,
#[subdiagnostic]
pub(crate) interpreted_as_const_sugg: Option<InterpretedAsConst>,
pub(crate) interpreted_as_const: Option<InterpretedAsConst>,
#[subdiagnostic]
pub(crate) interpreted_as_const_sugg: Option<InterpretedAsConstSugg>,
#[subdiagnostic]
pub(crate) adt_defined_here: Option<AdtDefinedHere<'tcx>>,
#[note(mir_build_privately_uninhabited)]
pub(crate) witness_1_is_privately_uninhabited: bool,
pub(crate) witness_1: String,
#[note(mir_build_pattern_ty)]
pub(crate) _p: (),
pub(crate) pattern_ty: Ty<'tcx>,
@ -1016,6 +1017,14 @@ pub(crate) struct PatternNotCovered<'s, 'tcx> {
#[note(mir_build_more_information)]
pub(crate) struct Inform;
#[derive(Subdiagnostic)]
#[label(mir_build_confused)]
pub(crate) struct InterpretedAsConst {
#[primary_span]
pub(crate) span: Span,
pub(crate) variable: String,
}
pub(crate) struct AdtDefinedHere<'tcx> {
pub(crate) adt_def_span: Span,
pub(crate) ty: Ty<'tcx>,
@ -1046,7 +1055,7 @@ impl<'tcx> Subdiagnostic for AdtDefinedHere<'tcx> {
applicability = "maybe-incorrect",
style = "verbose"
)]
pub(crate) struct InterpretedAsConst {
pub(crate) struct InterpretedAsConstSugg {
#[primary_span]
pub(crate) span: Span,
pub(crate) variable: String,

7
compiler/rustc_mir_build/src/thir/pattern/check_match.rs
View file

@ -690,8 +690,8 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
let span = self.tcx.def_span(def_id);
let variable = self.tcx.item_name(def_id).to_string();
// When we encounter a constant as the binding name, point at the `const` definition.
interpreted_as_const = Some(span);
interpreted_as_const_sugg = Some(InterpretedAsConst { span: pat.span, variable });
interpreted_as_const = Some(InterpretedAsConst { span, variable: variable.clone() });
interpreted_as_const_sugg = Some(InterpretedAsConstSugg { span: pat.span, variable });
} else if let PatKind::Constant { .. } = unpeeled_pat.kind
&& let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(pat.span)
{
@ -743,6 +743,8 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
false
};
let witness_1 = cx.print_witness_pat(witnesses.get(0).unwrap());
self.error = Err(self.tcx.dcx().emit_err(PatternNotCovered {
span: pat.span,
origin,
@ -751,6 +753,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
interpreted_as_const,
interpreted_as_const_sugg,
witness_1_is_privately_uninhabited,
witness_1,
_p: (),
pattern_ty,
let_suggestion,

4
compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
View file

@ -516,8 +516,12 @@ struct LocalLabel<'a> {
/// A custom `Subdiagnostic` implementation so that the notes are delivered in a specific order
impl Subdiagnostic for LocalLabel<'_> {
fn add_to_diag<G: rustc_errors::EmissionGuarantee>(self, diag: &mut rustc_errors::Diag<'_, G>) {
// Becuase parent uses this field , we need to remove it delay before adding it.
diag.remove_arg("name");
diag.arg("name", self.name);
diag.remove_arg("is_generated_name");
diag.arg("is_generated_name", self.is_generated_name);
diag.remove_arg("is_dropped_first_edition_2024");
diag.arg("is_dropped_first_edition_2024", self.is_dropped_first_edition_2024);
let msg = diag.eagerly_translate(crate::fluent_generated::mir_transform_tail_expr_local);
diag.span_label(self.span, msg);

2
compiler/rustc_passes/messages.ftl
View file

@ -294,7 +294,7 @@ passes_duplicate_lang_item_crate_depends =
.second_definition_path = second definition in `{$crate_name}` loaded from {$path}
passes_enum_variant_same_name =
it is impossible to refer to the {$descr} `{$dead_name}` because it is shadowed by this enum variant with the same name
it is impossible to refer to the {$dead_descr} `{$dead_name}` because it is shadowed by this enum variant with the same name
passes_export_name =
attribute should be applied to a free function, impl method or static

2
compiler/rustc_passes/src/dead.rs
View file

@ -1056,7 +1056,7 @@ impl<'tcx> DeadVisitor<'tcx> {
maybe_enum.variants().iter().find(|i| i.name == dead_item.name)
{
Some(crate::errors::EnumVariantSameName {
descr: tcx.def_descr(dead_item.def_id.to_def_id()),
dead_descr: tcx.def_descr(dead_item.def_id.to_def_id()),
dead_name: dead_item.name,
variant_span: tcx.def_span(variant.def_id),
})

3
compiler/rustc_passes/src/errors.rs
View file

@ -1516,7 +1516,7 @@ pub(crate) struct EnumVariantSameName<'tcx> {
#[primary_span]
pub variant_span: Span,
pub dead_name: Symbol,
pub descr: &'tcx str,
pub dead_descr: &'tcx str,
}
#[derive(Subdiagnostic)]
@ -1714,6 +1714,7 @@ impl Subdiagnostic for UnusedVariableStringInterp {
#[derive(LintDiagnostic)]
#[diag(passes_unused_variable_try_ignore)]
pub(crate) struct UnusedVarTryIgnore {
pub name: String,
#[subdiagnostic]
pub sugg: UnusedVarTryIgnoreSugg,
}

1
compiler/rustc_passes/src/liveness.rs
View file

@ -1744,6 +1744,7 @@ impl<'tcx> Liveness<'_, 'tcx> {
.map(|(_, pat_span, _)| *pat_span)
.collect::<Vec<_>>(),
errors::UnusedVarTryIgnore {
name: name.clone(),
sugg: errors::UnusedVarTryIgnoreSugg {
shorthands,
non_shorthands,

14
compiler/rustc_resolve/src/diagnostics.rs
View file

@ -256,22 +256,19 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
};
let label = match new_binding.is_import_user_facing() {
true => errors::NameDefinedMultipleTimeLabel::Reimported { span, name },
false => errors::NameDefinedMultipleTimeLabel::Redefined { span, name },
true => errors::NameDefinedMultipleTimeLabel::Reimported { span },
false => errors::NameDefinedMultipleTimeLabel::Redefined { span },
};
let old_binding_label =
(!old_binding.span.is_dummy() && old_binding.span != span).then(|| {
let span = self.tcx.sess.source_map().guess_head_span(old_binding.span);
match old_binding.is_import_user_facing() {
true => errors::NameDefinedMultipleTimeOldBindingLabel::Import {
span,
name,
old_kind,
},
true => {
errors::NameDefinedMultipleTimeOldBindingLabel::Import { span, old_kind }
}
false => errors::NameDefinedMultipleTimeOldBindingLabel::Definition {
span,
name,
old_kind,
},
}
@ -281,6 +278,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
.dcx()
.create_err(errors::NameDefinedMultipleTime {
span,
name,
descr: ns.descr(),
container,
label,

5
compiler/rustc_resolve/src/errors.rs
View file

@ -978,6 +978,7 @@ pub(crate) struct VariableNotInAllPatterns {
pub(crate) struct NameDefinedMultipleTime {
#[primary_span]
pub(crate) span: Span,
pub(crate) name: Symbol,
pub(crate) descr: &'static str,
pub(crate) container: &'static str,
#[subdiagnostic]
@ -992,13 +993,11 @@ pub(crate) enum NameDefinedMultipleTimeLabel {
Reimported {
#[primary_span]
span: Span,
name: Symbol,
},
#[label(resolve_name_defined_multiple_time_redefined)]
Redefined {
#[primary_span]
span: Span,
name: Symbol,
},
}
@ -1008,14 +1007,12 @@ pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
Import {
#[primary_span]
span: Span,
name: Symbol,
old_kind: &'static str,
},
#[label(resolve_name_defined_multiple_time_old_binding_definition)]
Definition {
#[primary_span]
span: Span,
name: Symbol,
old_kind: &'static str,
},
}

4
compiler/rustc_session/src/config.rs
View file

@ -227,13 +227,15 @@ pub enum CoverageLevel {
}
/// The different settings that the `-Z autodiff` flag can have.
#[derive(Clone, Copy, PartialEq, Hash, Debug)]
#[derive(Clone, PartialEq, Hash, Debug)]
pub enum AutoDiff {
/// Enable the autodiff opt pipeline
Enable,
/// Print TypeAnalysis information
PrintTA,
/// Print TypeAnalysis information for a specific function
PrintTAFn(String),
/// Print ActivityAnalysis Information
PrintAA,
/// Print Performance Warnings from Enzyme

17
compiler/rustc_session/src/options.rs
View file

@ -725,7 +725,7 @@ mod desc {
pub(crate) const parse_list: &str = "a space-separated list of strings";
pub(crate) const parse_list_with_polarity: &str =
"a comma-separated list of strings, with elements beginning with + or -";
pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`";
pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintTAFn`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`";
pub(crate) const parse_comma_list: &str = "a comma-separated list of strings";
pub(crate) const parse_opt_comma_list: &str = parse_comma_list;
pub(crate) const parse_number: &str = "a number";
@ -1365,9 +1365,22 @@ pub mod parse {
let mut v: Vec<&str> = v.split(",").collect();
v.sort_unstable();
for &val in v.iter() {
let variant = match val {
// Split each entry on '=' if it has an argument
let (key, arg) = match val.split_once('=') {
Some((k, a)) => (k, Some(a)),
None => (val, None),
};
let variant = match key {
"Enable" => AutoDiff::Enable,
"PrintTA" => AutoDiff::PrintTA,
"PrintTAFn" => {
if let Some(fun) = arg {
AutoDiff::PrintTAFn(fun.to_string())
} else {
return false;
}
}
"PrintAA" => AutoDiff::PrintAA,
"PrintPerf" => AutoDiff::PrintPerf,
"PrintSteps" => AutoDiff::PrintSteps,

4
compiler/rustc_smir/src/rustc_internal/internal.rs
View file

@ -479,6 +479,8 @@ impl RustcInternal for Abi {
Abi::Vectorcall { unwind } => rustc_abi::ExternAbi::Vectorcall { unwind },
Abi::Thiscall { unwind } => rustc_abi::ExternAbi::Thiscall { unwind },
Abi::Aapcs { unwind } => rustc_abi::ExternAbi::Aapcs { unwind },
Abi::CCmseNonSecureCall => rustc_abi::ExternAbi::CmseNonSecureCall,
Abi::CCmseNonSecureEntry => rustc_abi::ExternAbi::CmseNonSecureEntry,
Abi::Win64 { unwind } => rustc_abi::ExternAbi::Win64 { unwind },
Abi::SysV64 { unwind } => rustc_abi::ExternAbi::SysV64 { unwind },
Abi::PtxKernel => rustc_abi::ExternAbi::PtxKernel,
@ -488,8 +490,6 @@ impl RustcInternal for Abi {
Abi::EfiApi => rustc_abi::ExternAbi::EfiApi,
Abi::AvrInterrupt => rustc_abi::ExternAbi::AvrInterrupt,
Abi::AvrNonBlockingInterrupt => rustc_abi::ExternAbi::AvrNonBlockingInterrupt,
Abi::CCmseNonSecureCall => rustc_abi::ExternAbi::CCmseNonSecureCall,
Abi::CCmseNonSecureEntry => rustc_abi::ExternAbi::CCmseNonSecureEntry,
Abi::System { unwind } => rustc_abi::ExternAbi::System { unwind },
Abi::RustCall => rustc_abi::ExternAbi::RustCall,
Abi::Unadjusted => rustc_abi::ExternAbi::Unadjusted,

4
compiler/rustc_smir/src/rustc_smir/convert/ty.rs
View file

@ -871,8 +871,8 @@ impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi {
ExternAbi::EfiApi => Abi::EfiApi,
ExternAbi::AvrInterrupt => Abi::AvrInterrupt,
ExternAbi::AvrNonBlockingInterrupt => Abi::AvrNonBlockingInterrupt,
ExternAbi::CCmseNonSecureCall => Abi::CCmseNonSecureCall,
ExternAbi::CCmseNonSecureEntry => Abi::CCmseNonSecureEntry,
ExternAbi::CmseNonSecureCall => Abi::CCmseNonSecureCall,
ExternAbi::CmseNonSecureEntry => Abi::CCmseNonSecureEntry,
ExternAbi::System { unwind } => Abi::System { unwind },
ExternAbi::RustCall => Abi::RustCall,
ExternAbi::Unadjusted => Abi::Unadjusted,

1
compiler/rustc_span/src/symbol.rs
View file

@ -406,6 +406,7 @@ symbols! {
abi_amdgpu_kernel,
abi_avr_interrupt,
abi_c_cmse_nonsecure_call,
abi_cmse_nonsecure_call,
abi_custom,
abi_efiapi,
abi_gpu_kernel,

25
compiler/rustc_target/src/spec/abi_map.rs
View file

@ -85,24 +85,35 @@ impl AbiMap {
(ExternAbi::System { .. }, _) => CanonAbi::C,
// fallible lowerings
/* multi-platform */
// always and forever
(ExternAbi::RustInvalid, _) => return AbiMapping::Invalid,
(ExternAbi::EfiApi, Arch::Arm(..)) => CanonAbi::Arm(ArmCall::Aapcs),
(ExternAbi::EfiApi, Arch::X86_64) => CanonAbi::X86(X86Call::Win64),
(ExternAbi::EfiApi, Arch::Aarch64 | Arch::Riscv | Arch::X86) => CanonAbi::C,
(ExternAbi::EfiApi, _) => return AbiMapping::Invalid,
/* arm */
(ExternAbi::Aapcs { .. }, Arch::Arm(..)) => CanonAbi::Arm(ArmCall::Aapcs),
(ExternAbi::Aapcs { .. }, _) => return AbiMapping::Invalid,
(ExternAbi::CCmseNonSecureCall, Arch::Arm(ArmVer::ThumbV8M)) => {
(ExternAbi::CmseNonSecureCall, Arch::Arm(ArmVer::ThumbV8M)) => {
CanonAbi::Arm(ArmCall::CCmseNonSecureCall)
}
(ExternAbi::CCmseNonSecureEntry, Arch::Arm(ArmVer::ThumbV8M)) => {
(ExternAbi::CmseNonSecureEntry, Arch::Arm(ArmVer::ThumbV8M)) => {
CanonAbi::Arm(ArmCall::CCmseNonSecureEntry)
}
(ExternAbi::CCmseNonSecureCall | ExternAbi::CCmseNonSecureEntry, ..) => {
(ExternAbi::CmseNonSecureCall | ExternAbi::CmseNonSecureEntry, ..) => {
return AbiMapping::Invalid;
}
/* gpu */
(ExternAbi::PtxKernel, Arch::Nvptx) => CanonAbi::GpuKernel,
(ExternAbi::GpuKernel, Arch::Amdgpu | Arch::Nvptx) => CanonAbi::GpuKernel,
(ExternAbi::PtxKernel | ExternAbi::GpuKernel, _) => return AbiMapping::Invalid,
/* x86 */
(ExternAbi::Cdecl { .. }, Arch::X86) => CanonAbi::C,
(ExternAbi::Cdecl { .. }, _) => return AbiMapping::Deprecated(CanonAbi::C),
@ -130,10 +141,7 @@ impl AbiMap {
(ExternAbi::Win64 { .. }, Arch::X86_64) => CanonAbi::X86(X86Call::Win64),
(ExternAbi::SysV64 { .. } | ExternAbi::Win64 { .. }, _) => return AbiMapping::Invalid,
(ExternAbi::PtxKernel, Arch::Nvptx) => CanonAbi::GpuKernel,
(ExternAbi::GpuKernel, Arch::Amdgpu | Arch::Nvptx) => CanonAbi::GpuKernel,
(ExternAbi::PtxKernel | ExternAbi::GpuKernel, _) => return AbiMapping::Invalid,
/* interrupts */
(ExternAbi::AvrInterrupt, Arch::Avr) => CanonAbi::Interrupt(InterruptKind::Avr),
(ExternAbi::AvrNonBlockingInterrupt, Arch::Avr) => {
CanonAbi::Interrupt(InterruptKind::AvrNonBlocking)
@ -156,8 +164,7 @@ impl AbiMap {
| ExternAbi::Msp430Interrupt
| ExternAbi::RiscvInterruptM
| ExternAbi::RiscvInterruptS
| ExternAbi::X86Interrupt
| ExternAbi::RustInvalid,
| ExternAbi::X86Interrupt,
_,
) => return AbiMapping::Invalid,
};

2
compiler/rustc_trait_selection/src/errors/note_and_explain.rs
View file

@ -163,12 +163,14 @@ impl RegionExplanation<'_> {
impl Subdiagnostic for RegionExplanation<'_> {
fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
diag.store_args();
diag.arg("pref_kind", self.prefix);
diag.arg("suff_kind", self.suffix);
diag.arg("desc_kind", self.desc.kind);
diag.arg("desc_arg", self.desc.arg);
let msg = diag.eagerly_translate(fluent::trait_selection_region_explanation);
diag.restore_args();
if let Some(span) = self.desc.span {
diag.span_note(span, msg);
} else {

24
library/core/src/ops/arith.rs
View file

@ -179,12 +179,14 @@ add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
/// ```
#[lang = "sub"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
#[rustc_on_unimplemented(
message = "cannot subtract `{Rhs}` from `{Self}`",
label = "no implementation for `{Self} - {Rhs}`",
append_const_msg
)]
#[doc(alias = "-")]
#[const_trait]
pub trait Sub<Rhs = Self> {
/// The resulting type after applying the `-` operator.
#[stable(feature = "rust1", since = "1.0.0")]
@ -206,7 +208,8 @@ pub trait Sub<Rhs = Self> {
macro_rules! sub_impl {
($($t:ty)*) => ($(
#[stable(feature = "rust1", since = "1.0.0")]
impl Sub for $t {
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
impl const Sub for $t {
type Output = $t;
#[inline]
@ -310,11 +313,13 @@ sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
/// ```
#[lang = "mul"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
#[diagnostic::on_unimplemented(
message = "cannot multiply `{Self}` by `{Rhs}`",
label = "no implementation for `{Self} * {Rhs}`"
)]
#[doc(alias = "*")]
#[const_trait]
pub trait Mul<Rhs = Self> {
/// The resulting type after applying the `*` operator.
#[stable(feature = "rust1", since = "1.0.0")]
@ -336,7 +341,8 @@ pub trait Mul<Rhs = Self> {
macro_rules! mul_impl {
($($t:ty)*) => ($(
#[stable(feature = "rust1", since = "1.0.0")]
impl Mul for $t {
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
impl const Mul for $t {
type Output = $t;
#[inline]
@ -444,11 +450,13 @@ mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
/// ```
#[lang = "div"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
#[diagnostic::on_unimplemented(
message = "cannot divide `{Self}` by `{Rhs}`",
label = "no implementation for `{Self} / {Rhs}`"
)]
#[doc(alias = "/")]
#[const_trait]
pub trait Div<Rhs = Self> {
/// The resulting type after applying the `/` operator.
#[stable(feature = "rust1", since = "1.0.0")]
@ -476,7 +484,8 @@ macro_rules! div_impl_integer {
///
#[doc = $panic]
#[stable(feature = "rust1", since = "1.0.0")]
impl Div for $t {
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
impl const Div for $t {
type Output = $t;
#[inline]
@ -496,7 +505,8 @@ div_impl_integer! {
macro_rules! div_impl_float {
($($t:ty)*) => ($(
#[stable(feature = "rust1", since = "1.0.0")]
impl Div for $t {
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
impl const Div for $t {
type Output = $t;
#[inline]
@ -546,11 +556,13 @@ div_impl_float! { f16 f32 f64 f128 }
/// ```
#[lang = "rem"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
#[diagnostic::on_unimplemented(
message = "cannot calculate the remainder of `{Self}` divided by `{Rhs}`",
label = "no implementation for `{Self} % {Rhs}`"
)]
#[doc(alias = "%")]
#[const_trait]
pub trait Rem<Rhs = Self> {
/// The resulting type after applying the `%` operator.
#[stable(feature = "rust1", since = "1.0.0")]
@ -578,7 +590,8 @@ macro_rules! rem_impl_integer {
///
#[doc = $panic]
#[stable(feature = "rust1", since = "1.0.0")]
impl Rem for $t {
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
impl const Rem for $t {
type Output = $t;
#[inline]
@ -613,6 +626,7 @@ macro_rules! rem_impl_float {
/// assert_eq!(x % y, remainder);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
impl Rem for $t {
type Output = $t;

1
src/doc/rustc-dev-guide/src/autodiff/flags.md
View file

@ -6,6 +6,7 @@ To support you while debugging or profiling, we have added support for an experi
```text
PrintTA // Print TypeAnalysis information
PrintTAFn // Print TypeAnalysis information for a specific function
PrintAA // Print ActivityAnalysis information
Print // Print differentiated functions while they are being generated and optimized
PrintPerf // Print AD related Performance warnings

5
src/doc/rustc-dev-guide/src/tests/ui.md
View file

@ -59,6 +59,11 @@ The output is normalized to ignore unwanted differences, see the
[Normalization](#normalization) section. If the file is missing, then
compiletest expects the corresponding output to be empty.
A common reason to use normalization, revisions, and most of the other following tools,
is to account for platform differences. Consider alternatives to these tools, like
e.g. using the `extern "rust-invalid"` ABI that is invalid on every platform
instead of fixing the test to use cross-compilation and testing every possibly-invalid ABI.
There can be multiple stdout/stderr files. The general form is:
```text

1
src/doc/unstable-book/src/compiler-flags/autodiff.md
View file

@ -10,6 +10,7 @@ Multiple options can be separated with a comma. Valid options are:
`Enable` - Required flag to enable autodiff
`PrintTA` - print Type Analysis Information
`PrintTAFn` - print Type Analysis Information for a specific function
`PrintAA` - print Activity Analysis Information
`PrintPerf` - print Performance Warnings from Enzyme
`PrintSteps` - prints all intermediate transformations

16
src/doc/unstable-book/src/language-features/abi-c-cmse-nonsecure-call.md → src/doc/unstable-book/src/language-features/abi-cmse-nonsecure-call.md
View file

@ -1,4 +1,4 @@
# `abi_c_cmse_nonsecure_call`
# `abi_cmse_nonsecure_call`
The tracking issue for this feature is: [#81391]
@ -14,10 +14,9 @@ LLVM, the Rust compiler and the linker are providing
[support](https://developer.arm.com/documentation/ecm0359818/latest/) for the
TrustZone-M feature.
One of the things provided, with this unstable feature, is the
`C-cmse-nonsecure-call` function ABI. This ABI is used on function pointers to
non-secure code to mark a non-secure function call (see [section
5.5](https://developer.arm.com/documentation/ecm0359818/latest/) for details).
One of the things provided with this unstable feature is the "cmse-nonsecure-call" function ABI.
This ABI is used on function pointers to non-secure code to mark a non-secure function call
(see [section 5.5](https://developer.arm.com/documentation/ecm0359818/latest/) for details).
With this ABI, the compiler will do the following to perform the call:
* save registers needed after the call to Secure memory
@ -28,19 +27,16 @@ With this ABI, the compiler will do the following to perform the call:
To avoid using the non-secure stack, the compiler will constrain the number and
type of parameters/return value.
The `extern "C-cmse-nonsecure-call"` ABI is otherwise equivalent to the
`extern "C"` ABI.
<!-- NOTE(ignore) this example is specific to thumbv8m targets -->
``` rust,ignore
#![no_std]
#![feature(abi_c_cmse_nonsecure_call)]
#![feature(abi_cmse_nonsecure_call)]
#[no_mangle]
pub fn call_nonsecure_function(addr: usize) -> u32 {
let non_secure_function =
unsafe { core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn() -> u32>(addr) };
unsafe { core::mem::transmute::<usize, extern "cmse-nonsecure-call" fn() -> u32>(addr) };
non_secure_function()
}
```

13
src/doc/unstable-book/src/language-features/cmse-nonsecure-entry.md
View file

@ -14,10 +14,9 @@ LLVM, the Rust compiler and the linker are providing
[support](https://developer.arm.com/documentation/ecm0359818/latest/) for the
TrustZone-M feature.
One of the things provided, with this unstable feature, is the
`C-cmse-nonsecure-entry` ABI. This ABI marks a Secure function as an
entry function (see [section
5.4](https://developer.arm.com/documentation/ecm0359818/latest/) for details).
One of the things provided with this unstable feature is the "cmse-nonsecure-entry" ABI.
This ABI marks a Secure function as an entry function (see
[section 5.4](https://developer.arm.com/documentation/ecm0359818/latest/) for details).
With this ABI, the compiler will do the following:
* add a special symbol on the function which is the `__acle_se_` prefix and the
standard function name
@ -28,9 +27,7 @@ With this ABI, the compiler will do the following:
Because the stack can not be used to pass parameters, there will be compilation
errors if:
* the total size of all parameters is too big (for example more than four 32
bits integers)
* the entry function is not using a C ABI
* the total size of all parameters is too big (for example, more than four 32-bit integers)
The special symbol `__acle_se_` will be used by the linker to generate a secure
gateway veneer.
@ -42,7 +39,7 @@ gateway veneer.
#![feature(cmse_nonsecure_entry)]
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
input + 6
}
```

2
src/tools/enzyme

@ -1 +1 @@
Subproject commit a35f4f773118ccfbd8d05102eb12a34097b1ee55
Subproject commit b5098d515d5e1bd0f5470553bc0d18da9794ca8b

8
tests/assembly/cmse.rs
View file

@ -6,7 +6,7 @@
//@ [hard] needs-llvm-components: arm
//@ [soft] needs-llvm-components: arm
#![crate_type = "lib"]
#![feature(abi_c_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items)]
#![feature(abi_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items)]
#![no_core]
extern crate minicore;
@ -53,7 +53,7 @@ use minicore::*;
// Branch back to non-secure side
// CHECK: bxns lr
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn entry_point() -> i64 {
pub extern "cmse-nonsecure-entry" fn entry_point() -> i64 {
0
}
@ -95,8 +95,6 @@ pub extern "C-cmse-nonsecure-entry" fn entry_point() -> i64 {
// Call to non-secure
// CHECK: blxns r12
#[no_mangle]
pub fn call_nonsecure(
f: unsafe extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32) -> u64,
) -> u64 {
pub fn call_nonsecure(f: unsafe extern "cmse-nonsecure-call" fn(u32, u32, u32, u32) -> u64) -> u64 {
unsafe { f(0, 1, 2, 3) }
}

12
tests/crashes/126269.rs
View file

@ -1,12 +0,0 @@
//@ known-bug: rust-lang/rust#126269
#![feature(coerce_unsized)]
pub enum Foo<T> {
Bar([T; usize::MAX]),
}
use std::ops::CoerceUnsized;
impl<T, U> CoerceUnsized<U> for T {}
fn main() {}

18
tests/crashes/126982.rs
View file

@ -1,18 +0,0 @@
//@ known-bug: rust-lang/rust#126982
#![feature(coerce_unsized)]
use std::ops::CoerceUnsized;
struct Foo<T: ?Sized> {
a: T,
}
impl<T, U> CoerceUnsized<U> for Foo<T> {}
union U {
a: usize,
}
const C: U = Foo { a: 10 };
fn main() {}

2
tests/crashes/130104.rs
View file

@ -2,5 +2,5 @@
fn main() {
let non_secure_function =
core::mem::transmute::<fn() -> _, extern "C-cmse-nonsecure-call" fn() -> _>;
core::mem::transmute::<fn() -> _, extern "cmse-nonsecure-call" fn() -> _>;
}

7
tests/crashes/131048.rs
View file

@ -1,7 +0,0 @@
//@ known-bug: #131048
impl<A> std::ops::CoerceUnsized<A> for A {}
fn main() {
format_args!("Hello, world!");
}

2
tests/crashes/132142.rs
View file

@ -1,3 +1,3 @@
//@ known-bug: #132142
async extern "C-cmse-nonsecure-entry" fn fun(...) {}
async extern "cmse-nonsecure-entry" fn fun(...) {}

9
tests/crashes/134217.rs
View file

@ -1,9 +0,0 @@
//@ known-bug: #134217
impl<A> std::ops::CoerceUnsized<A> for A {}
fn main() {
if let _ = true
&& true
{}
}

12
tests/crashes/138265.rs
View file

@ -1,12 +0,0 @@
//@ known-bug: #138265
#![feature(coerce_unsized)]
#![crate_type = "lib"]
impl<A> std::ops::CoerceUnsized<A> for A {}
pub fn f() {
[0; {
let mut c = &0;
c = &0;
0
}]
}

10
tests/ui/SUMMARY.md
View file

@ -8,6 +8,8 @@ For now, only immediate subdirectories under `tests/ui/` are described, but thes
These tests deal with *Application Binary Interfaces* (ABI), mostly relating to function name mangling (and the `#[no_mangle]` attribute), calling conventions, or compiler flags which affect ABI.
Tests for unsupported ABIs can be made cross-platform by using the `extern "rust-invalid"` ABI, which is considered unsupported on every platform.
## `tests/ui/allocator`
These tests exercise `#![feature(allocator_api)]` and the `#[global_allocator]` attribute.
@ -208,14 +210,14 @@ Tests targeted at how we deduce the types of closure arguments. This process is
Any closure-focused tests that does not fit in the other more specific closure subdirectories belong here. E.g. syntax, `move`, lifetimes.
## `tests/ui/cmse-nonsecure/`: `C-cmse-nonsecure` ABIs
## `tests/ui/cmse-nonsecure/`: `cmse-nonsecure` ABIs
Tests for `cmse_nonsecure_entry` and `abi_c_cmse_nonsecure_call` ABIs. Used specifically for the Armv8-M architecture, the former marks Secure functions with additional behaviours, such as adding a special symbol and constraining the number of parameters, while the latter alters function pointers to indicate they are non-secure and to handle them differently than usual.
Tests for `extern "cmse-nonsecure-call"` and `extern "cmse-nonsecure-entry"` functions. Used specifically for the Armv8-M architecture, the former marks Secure functions with additional behaviours, such as adding a special symbol and constraining the number of parameters, while the latter alters function pointers to indicate they are non-secure and to handle them differently than usual.
See:
- [`cmse_nonsecure_entry` | The Unstable book](https://doc.rust-lang.org/unstable-book/language-features/cmse-nonsecure-entry.html)
- [`abi_c_cmse_nonsecure_call` | The Unstable book](https://doc.rust-lang.org/beta/unstable-book/language-features/abi-c-cmse-nonsecure-call.html)
- [`cmse_nonsecure_entry` | The Unstable book](https://doc.rust-lang.org/nightly/unstable-book/language-features/cmse-nonsecure-entry.html)
- [`abi_cmse_nonsecure_call` | The Unstable book](https://doc.rust-lang.org/nightly/unstable-book/language-features/abi-cmse-nonsecure-call.html)
## `tests/ui/codegen/`: Code Generation

17
tests/ui/abi/unsupported-abi-transmute.rs
View file

@ -1,15 +1,12 @@
//@ add-core-stubs
//@ compile-flags: --crate-type=lib --target x86_64-unknown-none
//@ needs-llvm-components: x86
//@ edition: 2018
#![no_core]
#![feature(no_core, lang_items)]
extern crate minicore;
use minicore::*;
// Check we error before unsupported ABIs reach codegen stages.
//@ edition: 2018
//@ compile-flags: --crate-type=lib
#![feature(rustc_attrs)]
use core::mem;
fn anything() {
let a = unsafe { mem::transmute::<usize, extern "thiscall" fn(i32)>(4) }(2);
let a = unsafe { mem::transmute::<usize, extern "rust-invalid" fn(i32)>(4) }(2);
//~^ ERROR: is not a supported ABI for the current target [E0570]
}

8
tests/ui/abi/unsupported-abi-transmute.stderr
View file

@ -1,8 +1,8 @@
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported-abi-transmute.rs:13:53
error[E0570]: "rust-invalid" is not a supported ABI for the current target
--> $DIR/unsupported-abi-transmute.rs:10:53
|
LL | let a = unsafe { mem::transmute::<usize, extern "thiscall" fn(i32)>(4) }(2);
| ^^^^^^^^^^
LL | let a = unsafe { mem::transmute::<usize, extern "rust-invalid" fn(i32)>(4) }(2);
| ^^^^^^^^^^^^^^
error: aborting due to 1 previous error

36
tests/ui/abi/unsupported-in-impls.rs Normal file
View file

@ -0,0 +1,36 @@
// Test for https://github.com/rust-lang/rust/issues/86232
// Due to AST-to-HIR lowering nuances, we used to allow unsupported ABIs to "leak" into the HIR
// without being checked, as we would check after generating the ExternAbi.
// Checking afterwards only works if we examine every HIR construct that contains an ExternAbi,
// and those may be very different in HIR, even if they read the same in source.
// This made it very easy to make mistakes.
//
// Here we test that an unsupported ABI in various impl-related positions will be rejected,
// both in the original declarations and the actual implementations.
#![feature(rustc_attrs)]
//@ compile-flags: --crate-type lib
pub struct FnPtrBearer {
pub ptr: extern "rust-invalid" fn(),
//~^ ERROR: is not a supported ABI
}
impl FnPtrBearer {
pub extern "rust-invalid" fn inherent_fn(self) {
//~^ ERROR: is not a supported ABI
(self.ptr)()
}
}
pub trait Trait {
extern "rust-invalid" fn trait_fn(self);
//~^ ERROR: is not a supported ABI
}
impl Trait for FnPtrBearer {
extern "rust-invalid" fn trait_fn(self) {
//~^ ERROR: is not a supported ABI
self.inherent_fn()
}
}

27
tests/ui/abi/unsupported-in-impls.stderr Normal file
View file

@ -0,0 +1,27 @@
error[E0570]: "rust-invalid" is not a supported ABI for the current target
--> $DIR/unsupported-in-impls.rs:15:21
|
LL | pub ptr: extern "rust-invalid" fn(),
| ^^^^^^^^^^^^^^
error[E0570]: "rust-invalid" is not a supported ABI for the current target
--> $DIR/unsupported-in-impls.rs:20:16
|
LL | pub extern "rust-invalid" fn inherent_fn(self) {
| ^^^^^^^^^^^^^^
error[E0570]: "rust-invalid" is not a supported ABI for the current target
--> $DIR/unsupported-in-impls.rs:27:12
|
LL | extern "rust-invalid" fn trait_fn(self);
| ^^^^^^^^^^^^^^
error[E0570]: "rust-invalid" is not a supported ABI for the current target
--> $DIR/unsupported-in-impls.rs:32:12
|
LL | extern "rust-invalid" fn trait_fn(self) {
| ^^^^^^^^^^^^^^
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0570`.

1
tests/ui/abi/unsupported-varargs-fnptr.rs
View file

@ -1,5 +1,6 @@
// FIXME(workingjubilee): add revisions and generalize to other platform-specific varargs ABIs,
// preferably after the only-arch directive is enhanced with an "or pattern" syntax
// NOTE: This deliberately tests an ABI that supports varargs, so no `extern "rust-invalid"`
//@ only-x86_64
// We have to use this flag to force ABI computation of an invalid ABI

2
tests/ui/abi/unsupported-varargs-fnptr.stderr
View file

@ -1,5 +1,5 @@
error[E0570]: "aapcs" is not a supported ABI for the current target
--> $DIR/unsupported-varargs-fnptr.rs:13:20
--> $DIR/unsupported-varargs-fnptr.rs:14:20
|
LL | fn aapcs(f: extern "aapcs" fn(usize, ...)) {
| ^^^^^^^

50
tests/ui/abi/unsupported.aarch64.stderr
View file

@ -132,53 +132,29 @@ error[E0570]: "vectorcall" is not a supported ABI for the current target
LL | extern "vectorcall" {}
| ^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:141:17
|
LL | ptr: extern "thiscall" fn(),
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:146:16
|
LL | pub extern "thiscall" fn inherent_fn(self) {
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:153:12
|
LL | extern "thiscall" fn trait_fn(self);
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:158:12
|
LL | extern "thiscall" fn trait_fn(self) {
| ^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
warning: "cdecl" is not a supported ABI for the current target
--> $DIR/unsupported.rs:99:17
@ -221,6 +197,6 @@ LL | extern "cdecl" fn cdecl() {}
= note: for more information, see issue #137018 <https://github.com/rust-lang/rust/issues/137018>
= help: use `extern "C"` instead
error: aborting due to 29 previous errors; 4 warnings emitted
error: aborting due to 25 previous errors; 4 warnings emitted
For more information about this error, try `rustc --explain E0570`.

50
tests/ui/abi/unsupported.arm.stderr
View file

@ -114,53 +114,29 @@ error[E0570]: "vectorcall" is not a supported ABI for the current target
LL | extern "vectorcall" {}
| ^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:141:17
|
LL | ptr: extern "thiscall" fn(),
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:146:16
|
LL | pub extern "thiscall" fn inherent_fn(self) {
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:153:12
|
LL | extern "thiscall" fn trait_fn(self);
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:158:12
|
LL | extern "thiscall" fn trait_fn(self) {
| ^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
warning: "cdecl" is not a supported ABI for the current target
--> $DIR/unsupported.rs:99:17
@ -203,6 +179,6 @@ LL | extern "cdecl" fn cdecl() {}
= note: for more information, see issue #137018 <https://github.com/rust-lang/rust/issues/137018>
= help: use `extern "C"` instead
error: aborting due to 26 previous errors; 4 warnings emitted
error: aborting due to 22 previous errors; 4 warnings emitted
For more information about this error, try `rustc --explain E0570`.

24
tests/ui/abi/unsupported.i686.stderr
View file

@ -58,29 +58,29 @@ error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
LL | extern "riscv-interrupt-m" {}
| ^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 14 previous errors

50
tests/ui/abi/unsupported.riscv32.stderr
View file

@ -126,53 +126,29 @@ error[E0570]: "vectorcall" is not a supported ABI for the current target
LL | extern "vectorcall" {}
| ^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:141:17
|
LL | ptr: extern "thiscall" fn(),
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:146:16
|
LL | pub extern "thiscall" fn inherent_fn(self) {
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:153:12
|
LL | extern "thiscall" fn trait_fn(self);
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:158:12
|
LL | extern "thiscall" fn trait_fn(self) {
| ^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
warning: "cdecl" is not a supported ABI for the current target
--> $DIR/unsupported.rs:99:17
@ -215,6 +191,6 @@ LL | extern "cdecl" fn cdecl() {}
= note: for more information, see issue #137018 <https://github.com/rust-lang/rust/issues/137018>
= help: use `extern "C"` instead
error: aborting due to 28 previous errors; 4 warnings emitted
error: aborting due to 24 previous errors; 4 warnings emitted
For more information about this error, try `rustc --explain E0570`.

50
tests/ui/abi/unsupported.riscv64.stderr
View file

@ -126,53 +126,29 @@ error[E0570]: "vectorcall" is not a supported ABI for the current target
LL | extern "vectorcall" {}
| ^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:141:17
|
LL | ptr: extern "thiscall" fn(),
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:146:16
|
LL | pub extern "thiscall" fn inherent_fn(self) {
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:153:12
|
LL | extern "thiscall" fn trait_fn(self);
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:158:12
|
LL | extern "thiscall" fn trait_fn(self) {
| ^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
warning: "cdecl" is not a supported ABI for the current target
--> $DIR/unsupported.rs:99:17
@ -215,6 +191,6 @@ LL | extern "cdecl" fn cdecl() {}
= note: for more information, see issue #137018 <https://github.com/rust-lang/rust/issues/137018>
= help: use `extern "C"` instead
error: aborting due to 28 previous errors; 4 warnings emitted
error: aborting due to 24 previous errors; 4 warnings emitted
For more information about this error, try `rustc --explain E0570`.

34
tests/ui/abi/unsupported.rs
View file

@ -25,7 +25,7 @@
abi_gpu_kernel,
abi_x86_interrupt,
abi_riscv_interrupt,
abi_c_cmse_nonsecure_call,
abi_cmse_nonsecure_call,
abi_vectorcall,
cmse_nonsecure_entry
)]
@ -117,18 +117,18 @@ fn vectorcall_ptr(f: extern "vectorcall" fn()) {
extern "vectorcall" {}
//[arm,aarch64,riscv32,riscv64]~^ ERROR is not a supported ABI
fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
//~^ ERROR is not a supported ABI
f()
}
extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
extern "cmse-nonsecure-entry" fn cmse_entry() {}
//~^ ERROR is not a supported ABI
fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
//~^ ERROR is not a supported ABI
f()
}
extern "C-cmse-nonsecure-entry" {}
extern "cmse-nonsecure-entry" {}
//~^ ERROR is not a supported ABI
#[cfg(windows)]
@ -136,27 +136,3 @@ extern "C-cmse-nonsecure-entry" {}
extern "cdecl" {}
//[x64_win]~^ WARN unsupported_calling_conventions
//[x64_win]~^^ WARN this was previously accepted
struct FnPtrBearer {
ptr: extern "thiscall" fn(),
//[x64,x64_win,arm,aarch64,riscv32,riscv64]~^ ERROR: is not a supported ABI
}
impl FnPtrBearer {
pub extern "thiscall" fn inherent_fn(self) {
//[x64,x64_win,arm,aarch64,riscv32,riscv64]~^ ERROR: is not a supported ABI
(self.ptr)()
}
}
trait Trait {
extern "thiscall" fn trait_fn(self);
//[x64,x64_win,arm,aarch64,riscv32,riscv64]~^ ERROR: is not a supported ABI
}
impl Trait for FnPtrBearer {
extern "thiscall" fn trait_fn(self) {
//[x64,x64_win,arm,aarch64,riscv32,riscv64]~^ ERROR: is not a supported ABI
self.inherent_fn()
}
}

50
tests/ui/abi/unsupported.x64.stderr
View file

@ -108,53 +108,29 @@ LL | extern "stdcall-unwind" {}
|
= help: if you need `extern "stdcall-unwind"` on win32 and `extern "C-unwind"` everywhere else, use `extern "system-unwind"`
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:141:17
|
LL | ptr: extern "thiscall" fn(),
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:146:16
|
LL | pub extern "thiscall" fn inherent_fn(self) {
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:153:12
|
LL | extern "thiscall" fn trait_fn(self);
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:158:12
|
LL | extern "thiscall" fn trait_fn(self) {
| ^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
warning: "cdecl" is not a supported ABI for the current target
--> $DIR/unsupported.rs:99:17
@ -197,6 +173,6 @@ LL | extern "cdecl" fn cdecl() {}
= note: for more information, see issue #137018 <https://github.com/rust-lang/rust/issues/137018>
= help: use `extern "C"` instead
error: aborting due to 25 previous errors; 4 warnings emitted
error: aborting due to 21 previous errors; 4 warnings emitted
For more information about this error, try `rustc --explain E0570`.

50
tests/ui/abi/unsupported.x64_win.stderr
View file

@ -76,53 +76,29 @@ error[E0570]: "thiscall" is not a supported ABI for the current target
LL | extern "thiscall" {}
| ^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/unsupported.rs:120:28
|
LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_call_ptr(f: extern "cmse-nonsecure-call" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:125:8
|
LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn cmse_entry() {}
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:127:29
|
LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn cmse_entry_ptr(f: extern "cmse-nonsecure-entry" fn()) {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/unsupported.rs:131:8
|
LL | extern "C-cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:141:17
|
LL | ptr: extern "thiscall" fn(),
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:146:16
|
LL | pub extern "thiscall" fn inherent_fn(self) {
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:153:12
|
LL | extern "thiscall" fn trait_fn(self);
| ^^^^^^^^^^
error[E0570]: "thiscall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:158:12
|
LL | extern "thiscall" fn trait_fn(self) {
| ^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" {}
| ^^^^^^^^^^^^^^^^^^^^^^
warning: "stdcall" is not a supported ABI for the current target
--> $DIR/unsupported.rs:81:19
@ -215,6 +191,6 @@ LL | extern "cdecl" fn cdecl() {}
= note: for more information, see issue #137018 <https://github.com/rust-lang/rust/issues/137018>
= help: use `extern "C"` instead
error: aborting due to 21 previous errors; 9 warnings emitted
error: aborting due to 17 previous errors; 9 warnings emitted
For more information about this error, try `rustc --explain E0570`.

6
tests/ui/cmse-nonsecure/cmse-nonsecure-call/callback-as-argument.rs
View file

@ -2,15 +2,15 @@
//@ build-pass
//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
//@ needs-llvm-components: arm
#![feature(abi_c_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items, intrinsics)]
#![feature(abi_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items, intrinsics)]
#![no_core]
extern crate minicore;
use minicore::*;
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn test(
f: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32) -> u32,
pub extern "cmse-nonsecure-entry" fn test(
f: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32) -> u32,
a: u32,
b: u32,
c: u32,

4
tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.rs
View file

@ -1,7 +1,7 @@
// gate-test-abi_c_cmse_nonsecure_call
// gate-test-abi_cmse_nonsecure_call
fn main() {
let non_secure_function = unsafe {
core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
core::mem::transmute::<usize, extern "cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
//~^ ERROR: is not a supported ABI for the current target [E0570]
//~| ERROR: ABI is experimental and subject to change [E0658]
0x10000004,

14
tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
View file

@ -1,17 +1,17 @@
error[E0570]: "C-cmse-nonsecure-call" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-call" is not a supported ABI for the current target
--> $DIR/gate_test.rs:4:46
|
LL | core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | core::mem::transmute::<usize, extern "cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
| ^^^^^^^^^^^^^^^^^^^^^
error[E0658]: the extern "C-cmse-nonsecure-call" ABI is experimental and subject to change
error[E0658]: the extern "cmse-nonsecure-call" ABI is experimental and subject to change
--> $DIR/gate_test.rs:4:46
|
LL | core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | core::mem::transmute::<usize, extern "cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
| ^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #81391 <https://github.com/rust-lang/rust/issues/81391> for more information
= help: add `#![feature(abi_c_cmse_nonsecure_call)]` to the crate attributes to enable
= help: add `#![feature(abi_cmse_nonsecure_call)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: aborting due to 2 previous errors

28
tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
View file

@ -1,7 +1,7 @@
//@ add-core-stubs
//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
//@ needs-llvm-components: arm
#![feature(abi_c_cmse_nonsecure_call, no_core, lang_items)]
#![feature(abi_cmse_nonsecure_call, no_core, lang_items)]
#![no_core]
extern crate minicore;
@ -11,31 +11,31 @@ use minicore::*;
struct Wrapper<T>(T);
struct Test<T: Copy> {
f1: extern "C-cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
f1: extern "cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
//~^ ERROR cannot find type `U` in this scope
//~| ERROR function pointer types may not have generic parameters
f2: extern "C-cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
//~^ ERROR `impl Trait` is not allowed in `fn` pointer parameters
f3: extern "C-cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64, //~ ERROR [E0798]
f4: extern "C-cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64, //~ ERROR [E0798]
f3: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64, //~ ERROR [E0798]
f4: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64, //~ ERROR [E0798]
}
type WithReference = extern "C-cmse-nonsecure-call" fn(&usize);
type WithReference = extern "cmse-nonsecure-call" fn(&usize);
trait Trait {}
type WithTraitObject = extern "C-cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
//~^ ERROR return value of `"C-cmse-nonsecure-call"` function too large to pass via registers [E0798]
type WithTraitObject = extern "cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
//~^ ERROR return value of `"cmse-nonsecure-call"` function too large to pass via registers [E0798]
type WithStaticTraitObject =
extern "C-cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
//~^ ERROR return value of `"C-cmse-nonsecure-call"` function too large to pass via registers [E0798]
extern "cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
//~^ ERROR return value of `"cmse-nonsecure-call"` function too large to pass via registers [E0798]
#[repr(transparent)]
struct WrapperTransparent<'a>(&'a dyn Trait);
type WithTransparentTraitObject =
extern "C-cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
//~^ ERROR return value of `"C-cmse-nonsecure-call"` function too large to pass via registers [E0798]
extern "cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
//~^ ERROR return value of `"cmse-nonsecure-call"` function too large to pass via registers [E0798]
type WithVarArgs = extern "C-cmse-nonsecure-call" fn(u32, ...);
//~^ ERROR C-variadic functions with the "C-cmse-nonsecure-call" calling convention are not supported
type WithVarArgs = extern "cmse-nonsecure-call" fn(u32, ...);
//~^ ERROR C-variadic functions with the "cmse-nonsecure-call" calling convention are not supported

70
tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
View file

@ -1,21 +1,21 @@
error: function pointer types may not have generic parameters
--> $DIR/generics.rs:14:42
--> $DIR/generics.rs:14:40
|
LL | f1: extern "C-cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
| ^^^^^^^^^
LL | f1: extern "cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
| ^^^^^^^^^
error[E0412]: cannot find type `U` in this scope
--> $DIR/generics.rs:14:52
--> $DIR/generics.rs:14:50
|
LL | struct Test<T: Copy> {
| - similarly named type parameter `T` defined here
LL | f1: extern "C-cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
| ^
LL | f1: extern "cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
| ^
|
help: a type parameter with a similar name exists
|
LL - f1: extern "C-cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
LL + f1: extern "C-cmse-nonsecure-call" fn<U: Copy>(T, u32, u32, u32) -> u64,
LL - f1: extern "cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
LL + f1: extern "cmse-nonsecure-call" fn<U: Copy>(T, u32, u32, u32) -> u64,
|
help: you might be missing a type parameter
|
@ -23,57 +23,57 @@ LL | struct Test<T: Copy, U> {
| +++
error[E0562]: `impl Trait` is not allowed in `fn` pointer parameters
--> $DIR/generics.rs:17:43
--> $DIR/generics.rs:17:41
|
LL | f2: extern "C-cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
| ^^^^^^^^^
LL | f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
| ^^^^^^^^^
|
= note: `impl Trait` is only allowed in arguments and return types of functions and methods
error[E0798]: function pointers with the `"C-cmse-nonsecure-call"` ABI cannot contain generics in their type
error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
--> $DIR/generics.rs:19:9
|
LL | f3: extern "C-cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | f3: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0798]: function pointers with the `"C-cmse-nonsecure-call"` ABI cannot contain generics in their type
error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
--> $DIR/generics.rs:20:9
|
LL | f4: extern "C-cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | f4: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/generics.rs:26:73
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/generics.rs:26:71
|
LL | type WithTraitObject = extern "C-cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
| ^^^^^^^^^^ this type doesn't fit in the available registers
LL | type WithTraitObject = extern "cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
| ^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/generics.rs:30:62
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/generics.rs:30:60
|
LL | extern "C-cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
| ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | extern "cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
| ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/generics.rs:37:62
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/generics.rs:37:60
|
LL | extern "C-cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
| ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | extern "cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
| ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0045]: C-variadic functions with the "C-cmse-nonsecure-call" calling convention are not supported
error[E0045]: C-variadic functions with the "cmse-nonsecure-call" calling convention are not supported
--> $DIR/generics.rs:40:20
|
LL | type WithVarArgs = extern "C-cmse-nonsecure-call" fn(u32, ...);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
LL | type WithVarArgs = extern "cmse-nonsecure-call" fn(u32, ...);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
error: aborting due to 9 previous errors

12
tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.rs
View file

@ -1,7 +1,7 @@
//@ add-core-stubs
//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
//@ needs-llvm-components: arm
#![feature(abi_c_cmse_nonsecure_call, no_core, lang_items)]
#![feature(abi_cmse_nonsecure_call, no_core, lang_items)]
#![no_core]
extern crate minicore;
@ -13,10 +13,10 @@ pub struct AlignRelevant(u32);
#[no_mangle]
pub fn test(
f1: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32), //~ ERROR [E0798]
f2: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u16, u16), //~ ERROR [E0798]
f3: extern "C-cmse-nonsecure-call" fn(u32, u64, u32), //~ ERROR [E0798]
f4: extern "C-cmse-nonsecure-call" fn(AlignRelevant, u32), //~ ERROR [E0798]
f5: extern "C-cmse-nonsecure-call" fn([u32; 5]), //~ ERROR [E0798]
f1: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32), //~ ERROR [E0798]
f2: extern "cmse-nonsecure-call" fn(u32, u32, u32, u16, u16), //~ ERROR [E0798]
f3: extern "cmse-nonsecure-call" fn(u32, u64, u32), //~ ERROR [E0798]
f4: extern "cmse-nonsecure-call" fn(AlignRelevant, u32), //~ ERROR [E0798]
f5: extern "cmse-nonsecure-call" fn([u32; 5]), //~ ERROR [E0798]
) {
}

50
tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
View file

@ -1,42 +1,42 @@
error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:16:63
error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:16:61
|
LL | f1: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32),
| ^^^^^^^^^^^^^^ these arguments don't fit in the available registers
LL | f1: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32),
| ^^^^^^^^^^^^^^ these arguments don't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:17:63
error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:17:61
|
LL | f2: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u16, u16),
| ^^^ this argument doesn't fit in the available registers
LL | f2: extern "cmse-nonsecure-call" fn(u32, u32, u32, u16, u16),
| ^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:18:53
error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:18:51
|
LL | f3: extern "C-cmse-nonsecure-call" fn(u32, u64, u32),
| ^^^ this argument doesn't fit in the available registers
LL | f3: extern "cmse-nonsecure-call" fn(u32, u64, u32),
| ^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:19:58
error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:19:56
|
LL | f4: extern "C-cmse-nonsecure-call" fn(AlignRelevant, u32),
| ^^^ this argument doesn't fit in the available registers
LL | f4: extern "cmse-nonsecure-call" fn(AlignRelevant, u32),
| ^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:20:43
error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/params-via-stack.rs:20:41
|
LL | f5: extern "C-cmse-nonsecure-call" fn([u32; 5]),
| ^^^^^^^^ this argument doesn't fit in the available registers
LL | f5: extern "cmse-nonsecure-call" fn([u32; 5]),
| ^^^^^^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
error: aborting due to 5 previous errors

20
tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs
View file

@ -3,7 +3,7 @@
//@ needs-llvm-components: arm
//@ add-core-stubs
#![feature(abi_c_cmse_nonsecure_call, no_core, lang_items)]
#![feature(abi_cmse_nonsecure_call, no_core, lang_items)]
#![no_core]
extern crate minicore;
@ -23,18 +23,18 @@ pub struct ReprCAlign16(u16);
#[no_mangle]
pub fn test(
f1: extern "C-cmse-nonsecure-call" fn() -> ReprCU64, //~ ERROR [E0798]
f2: extern "C-cmse-nonsecure-call" fn() -> ReprCBytes, //~ ERROR [E0798]
f3: extern "C-cmse-nonsecure-call" fn() -> U64Compound, //~ ERROR [E0798]
f4: extern "C-cmse-nonsecure-call" fn() -> ReprCAlign16, //~ ERROR [E0798]
f5: extern "C-cmse-nonsecure-call" fn() -> [u8; 5], //~ ERROR [E0798]
f1: extern "cmse-nonsecure-call" fn() -> ReprCU64, //~ ERROR [E0798]
f2: extern "cmse-nonsecure-call" fn() -> ReprCBytes, //~ ERROR [E0798]
f3: extern "cmse-nonsecure-call" fn() -> U64Compound, //~ ERROR [E0798]
f4: extern "cmse-nonsecure-call" fn() -> ReprCAlign16, //~ ERROR [E0798]
f5: extern "cmse-nonsecure-call" fn() -> [u8; 5], //~ ERROR [E0798]
) {
}
#[allow(improper_ctypes_definitions)]
struct Test {
u128: extern "C-cmse-nonsecure-call" fn() -> u128, //~ ERROR [E0798]
i128: extern "C-cmse-nonsecure-call" fn() -> i128, //~ ERROR [E0798]
u128: extern "cmse-nonsecure-call" fn() -> u128, //~ ERROR [E0798]
i128: extern "cmse-nonsecure-call" fn() -> i128, //~ ERROR [E0798]
}
#[repr(C)]
@ -49,7 +49,7 @@ pub union ReprRustUnionU64 {
#[no_mangle]
pub fn test_union(
f1: extern "C-cmse-nonsecure-call" fn() -> ReprRustUnionU64, //~ ERROR [E0798]
f2: extern "C-cmse-nonsecure-call" fn() -> ReprCUnionU64, //~ ERROR [E0798]
f1: extern "cmse-nonsecure-call" fn() -> ReprRustUnionU64, //~ ERROR [E0798]
f2: extern "cmse-nonsecure-call" fn() -> ReprCUnionU64, //~ ERROR [E0798]
) {
}

90
tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr
View file

@ -1,82 +1,82 @@
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:36:50
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:36:48
|
LL | u128: extern "C-cmse-nonsecure-call" fn() -> u128,
| ^^^^ this type doesn't fit in the available registers
LL | u128: extern "cmse-nonsecure-call" fn() -> u128,
| ^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:37:50
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:37:48
|
LL | i128: extern "C-cmse-nonsecure-call" fn() -> i128,
| ^^^^ this type doesn't fit in the available registers
LL | i128: extern "cmse-nonsecure-call" fn() -> i128,
| ^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:26:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:26:46
|
LL | f1: extern "C-cmse-nonsecure-call" fn() -> ReprCU64,
| ^^^^^^^^ this type doesn't fit in the available registers
LL | f1: extern "cmse-nonsecure-call" fn() -> ReprCU64,
| ^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:27:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:27:46
|
LL | f2: extern "C-cmse-nonsecure-call" fn() -> ReprCBytes,
| ^^^^^^^^^^ this type doesn't fit in the available registers
LL | f2: extern "cmse-nonsecure-call" fn() -> ReprCBytes,
| ^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:28:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:28:46
|
LL | f3: extern "C-cmse-nonsecure-call" fn() -> U64Compound,
| ^^^^^^^^^^^ this type doesn't fit in the available registers
LL | f3: extern "cmse-nonsecure-call" fn() -> U64Compound,
| ^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:29:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:29:46
|
LL | f4: extern "C-cmse-nonsecure-call" fn() -> ReprCAlign16,
| ^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | f4: extern "cmse-nonsecure-call" fn() -> ReprCAlign16,
| ^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:30:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:30:46
|
LL | f5: extern "C-cmse-nonsecure-call" fn() -> [u8; 5],
| ^^^^^^^ this type doesn't fit in the available registers
LL | f5: extern "cmse-nonsecure-call" fn() -> [u8; 5],
| ^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:52:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:52:46
|
LL | f1: extern "C-cmse-nonsecure-call" fn() -> ReprRustUnionU64,
| ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | f1: extern "cmse-nonsecure-call" fn() -> ReprRustUnionU64,
| ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:53:48
error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
--> $DIR/return-via-stack.rs:53:46
|
LL | f2: extern "C-cmse-nonsecure-call" fn() -> ReprCUnionU64,
| ^^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | f2: extern "cmse-nonsecure-call" fn() -> ReprCUnionU64,
| ^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error: aborting due to 9 previous errors

34
tests/ui/cmse-nonsecure/cmse-nonsecure-call/via-registers.rs
View file

@ -2,7 +2,7 @@
//@ build-pass
//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
//@ needs-llvm-components: arm
#![feature(abi_c_cmse_nonsecure_call, no_core, lang_items, intrinsics)]
#![feature(abi_cmse_nonsecure_call, no_core, lang_items, intrinsics)]
#![no_core]
extern crate minicore;
@ -27,26 +27,26 @@ pub struct U32Compound(u16, u16);
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub fn params(
f1: extern "C-cmse-nonsecure-call" fn(),
f2: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32),
f3: extern "C-cmse-nonsecure-call" fn(u64, u64),
f4: extern "C-cmse-nonsecure-call" fn(u128),
f5: extern "C-cmse-nonsecure-call" fn(f64, f32, f32),
f6: extern "C-cmse-nonsecure-call" fn(ReprTransparentStruct<u64>, U32Compound),
f7: extern "C-cmse-nonsecure-call" fn([u32; 4]),
f1: extern "cmse-nonsecure-call" fn(),
f2: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32),
f3: extern "cmse-nonsecure-call" fn(u64, u64),
f4: extern "cmse-nonsecure-call" fn(u128),
f5: extern "cmse-nonsecure-call" fn(f64, f32, f32),
f6: extern "cmse-nonsecure-call" fn(ReprTransparentStruct<u64>, U32Compound),
f7: extern "cmse-nonsecure-call" fn([u32; 4]),
) {
}
#[no_mangle]
pub fn returns(
f1: extern "C-cmse-nonsecure-call" fn() -> u32,
f2: extern "C-cmse-nonsecure-call" fn() -> u64,
f3: extern "C-cmse-nonsecure-call" fn() -> i64,
f4: extern "C-cmse-nonsecure-call" fn() -> f64,
f5: extern "C-cmse-nonsecure-call" fn() -> [u8; 4],
f6: extern "C-cmse-nonsecure-call" fn() -> ReprTransparentStruct<u64>,
f7: extern "C-cmse-nonsecure-call" fn() -> ReprTransparentStruct<ReprTransparentStruct<u64>>,
f8: extern "C-cmse-nonsecure-call" fn() -> ReprTransparentEnumU64,
f9: extern "C-cmse-nonsecure-call" fn() -> U32Compound,
f1: extern "cmse-nonsecure-call" fn() -> u32,
f2: extern "cmse-nonsecure-call" fn() -> u64,
f3: extern "cmse-nonsecure-call" fn() -> i64,
f4: extern "cmse-nonsecure-call" fn() -> f64,
f5: extern "cmse-nonsecure-call" fn() -> [u8; 4],
f6: extern "cmse-nonsecure-call" fn() -> ReprTransparentStruct<u64>,
f7: extern "cmse-nonsecure-call" fn() -> ReprTransparentStruct<ReprTransparentStruct<u64>>,
f8: extern "cmse-nonsecure-call" fn() -> ReprTransparentEnumU64,
f9: extern "cmse-nonsecure-call" fn() -> U32Compound,
) {
}

4
tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.rs
View file

@ -1,10 +1,10 @@
//@ add-core-stubs
//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
//@ needs-llvm-components: arm
#![feature(abi_c_cmse_nonsecure_call, lang_items, no_core)]
#![feature(abi_cmse_nonsecure_call, lang_items, no_core)]
#![no_core]
extern crate minicore;
use minicore::*;
pub extern "C-cmse-nonsecure-call" fn test() {} //~ ERROR [E0781]
pub extern "cmse-nonsecure-call" fn test() {} //~ ERROR [E0781]

6
tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
View file

@ -1,8 +1,8 @@
error[E0781]: the `"C-cmse-nonsecure-call"` ABI is only allowed on function pointers
error[E0781]: the `"cmse-nonsecure-call"` ABI is only allowed on function pointers
--> $DIR/wrong-abi-location-1.rs:10:1
|
LL | pub extern "C-cmse-nonsecure-call" fn test() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "cmse-nonsecure-call" fn test() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error

4
tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.rs
View file

@ -1,12 +1,12 @@
//@ add-core-stubs
//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
//@ needs-llvm-components: arm
#![feature(abi_c_cmse_nonsecure_call, lang_items, no_core)]
#![feature(abi_cmse_nonsecure_call, lang_items, no_core)]
#![no_core]
extern crate minicore;
use minicore::*;
extern "C-cmse-nonsecure-call" { //~ ERROR [E0781]
extern "cmse-nonsecure-call" { //~ ERROR [E0781]
fn test();
}

4
tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
View file

@ -1,7 +1,7 @@
error[E0781]: the `"C-cmse-nonsecure-call"` ABI is only allowed on function pointers
error[E0781]: the `"cmse-nonsecure-call"` ABI is only allowed on function pointers
--> $DIR/wrong-abi-location-2.rs:10:1
|
LL | / extern "C-cmse-nonsecure-call" {
LL | / extern "cmse-nonsecure-call" {
LL | | fn test();
LL | | }
| |_^

2
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/gate_test.rs
View file

@ -1,7 +1,7 @@
// gate-test-cmse_nonsecure_entry
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
//~^ ERROR: is not a supported ABI for the current target [E0570]
//~| ERROR: ABI is experimental and subject to change [E0658]
input + 6

12
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/gate_test.stderr
View file

@ -1,14 +1,14 @@
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/gate_test.rs:4:12
|
LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0658]: the extern "C-cmse-nonsecure-entry" ABI is experimental and subject to change
error[E0658]: the extern "cmse-nonsecure-entry" ABI is experimental and subject to change
--> $DIR/gate_test.rs:4:12
|
LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #75835 <https://github.com/rust-lang/rust/issues/75835> for more information
= help: add `#![feature(cmse_nonsecure_entry)]` to the crate attributes to enable

24
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
View file

@ -11,12 +11,12 @@ use minicore::*;
struct Wrapper<T>(T);
impl<T: Copy> Wrapper<T> {
extern "C-cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
extern "cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
//~^ ERROR [E0798]
0
}
extern "C-cmse-nonsecure-entry" fn ambient_generic_nested(
extern "cmse-nonsecure-entry" fn ambient_generic_nested(
//~^ ERROR [E0798]
_: Wrapper<T>,
_: u32,
@ -27,7 +27,7 @@ impl<T: Copy> Wrapper<T> {
}
}
extern "C-cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
extern "cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
//~^ ERROR [E0798]
_: U,
_: u32,
@ -37,40 +37,40 @@ extern "C-cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
0
}
extern "C-cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
//~^ ERROR [E0798]
0
}
extern "C-cmse-nonsecure-entry" fn reference(x: &usize) -> usize {
extern "cmse-nonsecure-entry" fn reference(x: &usize) -> usize {
*x
}
trait Trait {}
extern "C-cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
//~^ ERROR return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers [E0798]
extern "cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
//~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
x
}
extern "C-cmse-nonsecure-entry" fn static_trait_object(
extern "cmse-nonsecure-entry" fn static_trait_object(
x: &'static dyn Trait,
) -> &'static dyn Trait {
//~^ ERROR return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers [E0798]
//~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
x
}
#[repr(transparent)]
struct WrapperTransparent<'a>(&'a dyn Trait);
extern "C-cmse-nonsecure-entry" fn wrapped_trait_object(
extern "cmse-nonsecure-entry" fn wrapped_trait_object(
x: WrapperTransparent,
) -> WrapperTransparent {
//~^ ERROR return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers [E0798]
//~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
x
}
extern "C-cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
//~| ERROR requires `va_list` lang_item
}

50
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
View file

@ -1,13 +1,13 @@
error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
--> $DIR/generics.rs:73:55
--> $DIR/generics.rs:73:53
|
LL | extern "C-cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
| ^^^^^^
LL | extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
| ^^^^^^
error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
--> $DIR/generics.rs:30:1
|
LL | / extern "C-cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
LL | / extern "cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
LL | |
LL | | _: U,
LL | | _: u32,
@ -16,22 +16,22 @@ LL | | _: u32,
LL | | ) -> u64 {
| |________^
error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
--> $DIR/generics.rs:40:1
|
LL | extern "C-cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
--> $DIR/generics.rs:14:5
|
LL | extern "C-cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | extern "cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
--> $DIR/generics.rs:19:5
|
LL | / extern "C-cmse-nonsecure-entry" fn ambient_generic_nested(
LL | / extern "cmse-nonsecure-entry" fn ambient_generic_nested(
LL | |
LL | | _: Wrapper<T>,
LL | | _: u32,
@ -40,38 +40,38 @@ LL | | _: u32,
LL | | ) -> u64 {
| |____________^
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/generics.rs:51:67
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/generics.rs:51:65
|
LL | extern "C-cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
| ^^^^^^^^^^ this type doesn't fit in the available registers
LL | extern "cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
| ^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/generics.rs:58:6
|
LL | ) -> &'static dyn Trait {
| ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/generics.rs:68:6
|
LL | ) -> WrapperTransparent {
| ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error: requires `va_list` lang_item
--> $DIR/generics.rs:73:55
--> $DIR/generics.rs:73:53
|
LL | extern "C-cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
| ^^^^^^
LL | extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
| ^^^^^^
error: aborting due to 9 previous errors

10
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs
View file

@ -12,14 +12,14 @@ use minicore::*;
pub struct AlignRelevant(u32);
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {} //~ ERROR [E0798]
pub extern "cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {} //~ ERROR [E0798]
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _: u16) {} //~ ERROR [E0798]
pub extern "cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _: u16) {} //~ ERROR [E0798]
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {} //~ ERROR [E0798]
pub extern "cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {} //~ ERROR [E0798]
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {} //~ ERROR [E0798]
pub extern "cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {} //~ ERROR [E0798]
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn f5(_: [u32; 5]) {} //~ ERROR [E0798]
pub extern "cmse-nonsecure-entry" fn f5(_: [u32; 5]) {} //~ ERROR [E0798]

54
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
View file

@ -1,42 +1,42 @@
error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:15:78
error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:15:76
|
LL | pub extern "C-cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {}
| ^^^^^^^^^^^ these arguments don't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {}
| ^^^^^^^^^^^ these arguments don't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:17:78
error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:17:76
|
LL | pub extern "C-cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _: u16) {}
| ^^^ this argument doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _: u16) {}
| ^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:19:62
error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:19:60
|
LL | pub extern "C-cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {}
LL | pub extern "cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {}
| ^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:21:62
|
LL | pub extern "cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {}
| ^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:21:64
error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:25:44
|
LL | pub extern "C-cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {}
| ^^^ this argument doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f5(_: [u32; 5]) {}
| ^^^^^^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/params-via-stack.rs:25:46
|
LL | pub extern "C-cmse-nonsecure-entry" fn f5(_: [u32; 5]) {}
| ^^^^^^^^ this argument doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
error: aborting due to 5 previous errors

18
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.rs
View file

@ -22,41 +22,41 @@ pub struct U64Compound(u32, u32);
pub struct ReprCAlign16(u16);
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f1() -> ReprCU64 {
pub extern "cmse-nonsecure-entry" fn f1() -> ReprCU64 {
//~^ ERROR [E0798]
ReprCU64(0)
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f2() -> ReprCBytes {
pub extern "cmse-nonsecure-entry" fn f2() -> ReprCBytes {
//~^ ERROR [E0798]
ReprCBytes(0, 1, 2, 3, 4)
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f3() -> U64Compound {
pub extern "cmse-nonsecure-entry" fn f3() -> U64Compound {
//~^ ERROR [E0798]
U64Compound(2, 3)
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn f4() -> ReprCAlign16 {
pub extern "cmse-nonsecure-entry" fn f4() -> ReprCAlign16 {
//~^ ERROR [E0798]
ReprCAlign16(4)
}
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn f5() -> [u8; 5] {
pub extern "cmse-nonsecure-entry" fn f5() -> [u8; 5] {
//~^ ERROR [E0798]
[0xAA; 5]
}
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn u128() -> u128 {
pub extern "cmse-nonsecure-entry" fn u128() -> u128 {
//~^ ERROR [E0798]
123
}
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn i128() -> i128 {
pub extern "cmse-nonsecure-entry" fn i128() -> i128 {
//~^ ERROR [E0798]
456
}
@ -73,12 +73,12 @@ pub union ReprCUnionU64 {
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn union_rust() -> ReprRustUnionU64 {
pub extern "cmse-nonsecure-entry" fn union_rust() -> ReprRustUnionU64 {
//~^ ERROR [E0798]
ReprRustUnionU64 { _unused: 1 }
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn union_c() -> ReprCUnionU64 {
pub extern "cmse-nonsecure-entry" fn union_c() -> ReprCUnionU64 {
//~^ ERROR [E0798]
ReprCUnionU64 { _unused: 2 }
}

90
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.stderr
View file

@ -1,82 +1,82 @@
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:25:48
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:25:46
|
LL | pub extern "C-cmse-nonsecure-entry" fn f1() -> ReprCU64 {
| ^^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f1() -> ReprCU64 {
| ^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:30:48
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:30:46
|
LL | pub extern "C-cmse-nonsecure-entry" fn f2() -> ReprCBytes {
| ^^^^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f2() -> ReprCBytes {
| ^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:35:48
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:35:46
|
LL | pub extern "C-cmse-nonsecure-entry" fn f3() -> U64Compound {
| ^^^^^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f3() -> U64Compound {
| ^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:40:48
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:40:46
|
LL | pub extern "C-cmse-nonsecure-entry" fn f4() -> ReprCAlign16 {
| ^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f4() -> ReprCAlign16 {
| ^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:47:48
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:47:46
|
LL | pub extern "C-cmse-nonsecure-entry" fn f5() -> [u8; 5] {
| ^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn f5() -> [u8; 5] {
| ^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:53:50
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:53:48
|
LL | pub extern "C-cmse-nonsecure-entry" fn u128() -> u128 {
| ^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn u128() -> u128 {
| ^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:59:50
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:59:48
|
LL | pub extern "C-cmse-nonsecure-entry" fn i128() -> i128 {
| ^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn i128() -> i128 {
| ^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:76:56
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:76:54
|
LL | pub extern "C-cmse-nonsecure-entry" fn union_rust() -> ReprRustUnionU64 {
| ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn union_rust() -> ReprRustUnionU64 {
| ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:81:53
error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
--> $DIR/return-via-stack.rs:81:51
|
LL | pub extern "C-cmse-nonsecure-entry" fn union_c() -> ReprCUnionU64 {
| ^^^^^^^^^^^^^ this type doesn't fit in the available registers
LL | pub extern "cmse-nonsecure-entry" fn union_c() -> ReprCUnionU64 {
| ^^^^^^^^^^^^^ this type doesn't fit in the available registers
|
= note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
= note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
error: aborting due to 9 previous errors

6
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.aarch64.stderr
View file

@ -1,8 +1,8 @@
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/trustzone-only.rs:17:12
|
LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error

2
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.rs
View file

@ -14,7 +14,7 @@ extern crate minicore;
use minicore::*;
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
//~^ ERROR [E0570]
input
}

6
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.thumb7.stderr
View file

@ -1,8 +1,8 @@
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/trustzone-only.rs:17:12
|
LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error

6
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.x86.stderr
View file

@ -1,8 +1,8 @@
error[E0570]: "C-cmse-nonsecure-entry" is not a supported ABI for the current target
error[E0570]: "cmse-nonsecure-entry" is not a supported ABI for the current target
--> $DIR/trustzone-only.rs:17:12
|
LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error

32
tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs
View file

@ -26,49 +26,49 @@ pub enum ReprTransparentEnumU64 {
pub struct U32Compound(u16, u16);
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn inputs1() {}
pub extern "cmse-nonsecure-entry" fn inputs1() {}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn inputs2(_: u32, _: u32, _: u32, _: u32) {}
pub extern "cmse-nonsecure-entry" fn inputs2(_: u32, _: u32, _: u32, _: u32) {}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn inputs3(_: u64, _: u64) {}
pub extern "cmse-nonsecure-entry" fn inputs3(_: u64, _: u64) {}
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn inputs4(_: u128) {}
pub extern "cmse-nonsecure-entry" fn inputs4(_: u128) {}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn inputs5(_: f64, _: f32, _: f32) {}
pub extern "cmse-nonsecure-entry" fn inputs5(_: f64, _: f32, _: f32) {}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn inputs6(_: ReprTransparentStruct<u64>, _: U32Compound) {}
pub extern "cmse-nonsecure-entry" fn inputs6(_: ReprTransparentStruct<u64>, _: U32Compound) {}
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn inputs7(_: [u32; 4]) {}
pub extern "cmse-nonsecure-entry" fn inputs7(_: [u32; 4]) {}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs1() -> u32 {
pub extern "cmse-nonsecure-entry" fn outputs1() -> u32 {
0
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs2() -> u64 {
pub extern "cmse-nonsecure-entry" fn outputs2() -> u64 {
0
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs3() -> i64 {
pub extern "cmse-nonsecure-entry" fn outputs3() -> i64 {
0
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs4() -> f64 {
pub extern "cmse-nonsecure-entry" fn outputs4() -> f64 {
0.0
}
#[no_mangle]
#[allow(improper_ctypes_definitions)]
pub extern "C-cmse-nonsecure-entry" fn outputs5() -> [u8; 4] {
pub extern "cmse-nonsecure-entry" fn outputs5() -> [u8; 4] {
[0xAA; 4]
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs6() -> ReprTransparentStruct<u64> {
pub extern "cmse-nonsecure-entry" fn outputs6() -> ReprTransparentStruct<u64> {
ReprTransparentStruct { _marker1: (), _marker2: (), field: 0xAA, _marker3: () }
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs7(
pub extern "cmse-nonsecure-entry" fn outputs7(
) -> ReprTransparentStruct<ReprTransparentStruct<u64>> {
ReprTransparentStruct {
_marker1: (),
@ -78,10 +78,10 @@ pub extern "C-cmse-nonsecure-entry" fn outputs7(
}
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs8() -> ReprTransparentEnumU64 {
pub extern "cmse-nonsecure-entry" fn outputs8() -> ReprTransparentEnumU64 {
ReprTransparentEnumU64::A(0)
}
#[no_mangle]
pub extern "C-cmse-nonsecure-entry" fn outputs9() -> U32Compound {
pub extern "cmse-nonsecure-entry" fn outputs9() -> U32Compound {
U32Compound(1, 2)
}

Some files were not shown because too many files have changed in this diff Show more