disallow asm! in #[naked] functions

also disallow the `noreturn` option, and infer `naked_asm!` as `!`

Author: folkertdev

compiler/rustc_ast/src/ast.rs

@@ -2278,7 +2278,7 @@ impl InlineAsmOptions {
 pubconstCOUNT:usize = Self::all().bits().count_ones()asusize;
 
 pubconstGLOBAL_OPTIONS:Self = Self::ATT_SYNTAX.union(Self::RAW);
-pubconstNAKED_OPTIONS:Self = Self::ATT_SYNTAX.union(Self::RAW).union(Self::NORETURN);
+pubconstNAKED_OPTIONS:Self = Self::ATT_SYNTAX.union(Self::RAW);
 
 pubfnhuman_readable_names(&self) -> Vec<&'staticstr>{
 letmut options = vec![];
@@ -2434,6 +2434,24 @@ pub enum AsmMacro {
 NakedAsm,
 }
 
+implAsmMacro{
+pubconstfnmacro_name(&self) -> &'staticstr{
+matchself{
+AsmMacro::Asm => "asm",
+AsmMacro::GlobalAsm => "global_asm",
+AsmMacro::NakedAsm => "naked_asm",
+}
+}
+
+pubconstfnis_supported_option(&self,option:InlineAsmOptions) -> bool{
+matchself{
+AsmMacro::Asm => true,
+AsmMacro::GlobalAsm => InlineAsmOptions::GLOBAL_OPTIONS.contains(option),
+AsmMacro::NakedAsm => InlineAsmOptions::NAKED_OPTIONS.contains(option),
+}
+}
+}
+
 /// Inline assembly.
 ///
 /// E.g., `asm!("NOP");`.

compiler/rustc_builtin_macros/src/asm.rs

@@ -60,35 +60,6 @@ fn eat_operand_keyword<'a>(
 }
 }
 
-// Public for rustfmt consumption.
-#[derive(Copy,Clone)]
-pubenumAsmMacro{
-/// The `asm!` macro
-Asm,
-/// The `global_asm!` macro
-GlobalAsm,
-/// The `naked_asm!` macro
-NakedAsm,
-}
-
-implAsmMacro{
-constfnmacro_name(&self) -> &'staticstr{
-matchself{
-AsmMacro::Asm => "asm",
-AsmMacro::GlobalAsm => "global_asm",
-AsmMacro::NakedAsm => "naked_asm",
-}
-}
-
-constfnis_supported_option(&self,option: ast::InlineAsmOptions) -> bool{
-matchself{
-AsmMacro::Asm => true,
-AsmMacro::GlobalAsm => ast::InlineAsmOptions::GLOBAL_OPTIONS.contains(option),
-AsmMacro::NakedAsm => ast::InlineAsmOptions::NAKED_OPTIONS.contains(option),
-}
-}
-}
-
 fnparse_args<'a>(
 ecx:&ExtCtxt<'a>,
 sp:Span,
@@ -529,7 +500,7 @@ fn parse_reg<'a>(
 
 fnexpand_preparsed_asm(
 ecx:&mutExtCtxt<'_>,
-asm_macro:ast::AsmMacro,
+asm_macro:AsmMacro,
 args:AsmArgs,
 ) -> ExpandResult<Result<ast::InlineAsm,ErrorGuaranteed>,()>{
 letmut template = vec![];
@@ -872,7 +843,7 @@ pub(super) fn expand_naked_asm<'cx>(
 sp:Span,
 tts:TokenStream,
 ) -> MacroExpanderResult<'cx>{
-ExpandResult::Ready(matchparse_args(ecx, sp, tts,false){
+ExpandResult::Ready(matchparse_args(ecx, sp, tts,AsmMacro::NakedAsm){
 Ok(args) => {
 letExpandResult::Ready(mac) = expand_preparsed_asm(ecx,AsmMacro::NakedAsm, args)
 else{
@@ -940,32 +911,3 @@ pub(super) fn expand_global_asm<'cx>(
 }
 })
 }
-
-pub(super)fnexpand_naked_asm<'cx>(
-ecx:&'cxmutExtCtxt<'_>,
-sp:Span,
-tts:TokenStream,
-) -> MacroExpanderResult<'cx>{
-ExpandResult::Ready(matchparse_args(ecx, sp, tts,AsmMacro::NakedAsm){
-Ok(args) => {
-letExpandResult::Ready(mac) = expand_preparsed_asm(ecx, args)else{
-returnExpandResult::Retry(());
-};
-let expr = match mac {
-Ok(inline_asm) => P(ast::Expr{
-id: ast::DUMMY_NODE_ID,
-kind: ast::ExprKind::InlineAsm(P(inline_asm)),
-span: sp,
-attrs: ast::AttrVec::new(),
-tokens:None,
-}),
-Err(guar) => DummyResult::raw_expr(sp,Some(guar)),
-};
-MacEager::expr(expr)
-}
-Err(err) => {
-let guar = err.emit();
-DummyResult::any(sp, guar)
-}
-})
-}

compiler/rustc_error_codes/src/error_codes/E0787.md

@@ -11,11 +11,10 @@ pub extern "C" fn f() -> u32 {
 }
 ```
 
-The naked functions must be defined using a single inline assembly
-block.
+The naked function must be defined using a single `naked_asm!` assembly block.
 
 The execution must never fall through past the end of the assembly
-code so the block must use `noreturn` option. The asm block can also
+code, so it must either return or diverge. The asm block can also
 use `att_syntax` and `raw` options, but others options are not allowed.
 
 The asm block must not contain any operands other than `const` and

compiler/rustc_hir_typeck/src/expr.rs

@@ -3507,7 +3507,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 fncheck_expr_asm(&self,asm:&'tcx hir::InlineAsm<'tcx>) -> Ty<'tcx>{
-letmut diverge = asm.options.contains(ast::InlineAsmOptions::NORETURN);
+letmut diverge = match asm.asm_macro{
+ rustc_ast::AsmMacro::Asm => asm.options.contains(ast::InlineAsmOptions::NORETURN),
+ rustc_ast::AsmMacro::GlobalAsm => true,
+ rustc_ast::AsmMacro::NakedAsm => true,
+};
 
 for(op, _op_sp)in asm.operands{
 match op {

compiler/rustc_passes/messages.ftl

@@ -488,9 +488,9 @@ passes_naked_asm_outside_naked_fn =
  the `naked_asm!` macro can only be used in functions marked with `#[naked]`
 
 passes_naked_functions_asm_block =
- naked functions must contain a single asm block
-.label_multiple_asm = multiple asm blocks are unsupported in naked functions
-.label_non_asm = non-asm is unsupported in naked functions
+ naked functions must contain a single `naked_asm!` invocation
+.label_multiple_asm = multiple `naked_asm!` invocations are not allowed in naked functions
+.label_non_asm = not allowed in naked functions
 
 passes_naked_functions_asm_options =
  asm options unsupported in naked functions: {$unsupported_options}
@@ -500,9 +500,9 @@ passes_naked_functions_incompatible_attribute =
 .label = the `{$attr}` attribute is incompatible with `#[naked]`
 .naked_attribute = function marked with `#[naked]` here
 
-passes_naked_functions_must_use_noreturn =
- asm in naked functions must use `noreturn` option
-.suggestion = consider specifying that the asm block is responsible for returning from the function
+passes_naked_functions_must_naked_asm =
+the `asm!` macro is not allowed in naked functions
+.suggestion = consider using the `naked_asm!` macro instead
 
 passes_naked_functions_operands =
  only `const` and `sym` operands are supported in naked functions

compiler/rustc_passes/src/errors.rs

@@ -1202,12 +1202,12 @@ pub(crate) struct NakedFunctionsAsmOptions {
 }
 
 #[derive(Diagnostic)]
-#[diag(passes_naked_functions_must_use_noreturn, code = E0787)]
-pub(crate)structNakedFunctionsMustUseNoreturn{
+#[diag(passes_naked_functions_must_naked_asm, code = E0787)]
+pub(crate)structNakedFunctionsMustNakedAsm{
 #[primary_span]
 pubspan:Span,
-#[suggestion(code = ", options(noreturn)", applicability = "machine-applicable")]
-publast_span:Span,
+#[suggestion(code = "naked_asm!", applicability = "machine-applicable")]
+pubmacro_span:Span,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_passes/src/naked_functions.rs

@@ -10,13 +10,13 @@ use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint::builtin::UNDEFINED_NAKED_FUNCTION_ABI;
-use rustc_span::Span;
 use rustc_span::symbol::sym;
+use rustc_span::{BytePos,Span};
 use rustc_target::spec::abi::Abi;
 
 usecrate::errors::{
 NakedAsmOutsideNakedFn,NakedFunctionsAsmBlock,NakedFunctionsAsmOptions,
-NakedFunctionsMustUseNoreturn,NakedFunctionsOperands,NoPatterns,ParamsNotAllowed,
+NakedFunctionsMustNakedAsm,NakedFunctionsOperands,NoPatterns,ParamsNotAllowed,
 UndefinedNakedFunctionAbi,
 };
 
@@ -121,21 +121,29 @@ impl<'tcx> Visitor<'tcx> for CheckParameters<'tcx> {
 fncheck_asm<'tcx>(tcx:TyCtxt<'tcx>,def_id:LocalDefId,body:&'tcx hir::Body<'tcx>){
 letmut this = CheckInlineAssembly{ tcx,items:Vec::new()};
  this.visit_body(body);
-iflet[(ItemKind::Asm | ItemKind::Err, _)] = this.items[..]{
+iflet[(ItemKind::NakedAsm | ItemKind::Err, _)] = this.items[..]{
 // Ok.
 }else{
 letmut must_show_error = false;
-letmuthas_asm = false;
+letmuthas_naked_asm = false;
 letmut has_err = false;
 letmut multiple_asms = vec![];
 letmut non_asms = vec![];
 for&(kind, span)in&this.items{
 match kind {
-ItemKind::Asmifhas_asm => {
+ItemKind::NakedAsmifhas_naked_asm => {
  must_show_error = true;
  multiple_asms.push(span);
 }
-ItemKind::Asm => has_asm = true,
+ItemKind::NakedAsm => has_naked_asm = true,
+ItemKind::InlineAsm => {
+ has_err = true;
+
+// the span that contains the `asm!` call,
+// so tooling can replace it with `naked_asm!`
+let macro_span = span.with_hi(span.lo() + BytePos("asm!".len()asu32));
+ tcx.dcx().emit_err(NakedFunctionsMustNakedAsm{ span, macro_span });
+}
 ItemKind::NonAsm => {
  must_show_error = true;
  non_asms.push(span);
@@ -164,7 +172,8 @@ struct CheckInlineAssembly<'tcx> {
 
 #[derive(Copy,Clone)]
 enumItemKind{
-Asm,
+NakedAsm,
+InlineAsm,
 NonAsm,
 Err,
 }
@@ -205,8 +214,18 @@ impl<'tcx> CheckInlineAssembly<'tcx> {
 }
 
 ExprKind::InlineAsm(asm) => {
-self.items.push((ItemKind::Asm, span));
-self.check_inline_asm(asm, span);
+match asm.asm_macro{
+ rustc_ast::AsmMacro::Asm => {
+self.items.push((ItemKind::InlineAsm, span));
+}
+ rustc_ast::AsmMacro::NakedAsm => {
+self.items.push((ItemKind::NakedAsm, span));
+self.check_inline_asm(asm, span);
+}
+ rustc_ast::AsmMacro::GlobalAsm => {
+// not allowed in this position
+}
+}
 }
 
 ExprKind::DropTemps(..) | ExprKind::Block(..) => {
@@ -250,16 +269,6 @@ impl<'tcx> CheckInlineAssembly<'tcx> {
 .join(", "),
 });
 }
-
-if !asm.options.contains(InlineAsmOptions::NORETURN){
-let last_span = asm
-.operands
-.last()
-.map_or_else(|| asm.template_strs.last().unwrap().2, |op| op.1)
-.shrink_to_hi();
-
-self.tcx.dcx().emit_err(NakedFunctionsMustUseNoreturn{ span, last_span });
-}
 }
 }
 

library/core/src/arch.rs

@@ -77,17 +77,3 @@ pub macro naked_asm("assembly template", $(operands,)* $(options($(option),*))?)
 pub macro global_asm("assembly template", $(operands,)* $(options($(option),*))?){
 /* compiler built-in */
 }
-
-/// Inline assembly used in combination with `#[naked]` functions.
-///
-/// Refer to [Rust By Example] for a usage guide and the [reference] for
-/// detailed information about the syntax and available options.
-///
-/// [Rust By Example]: https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html
-/// [reference]: https://doc.rust-lang.org/nightly/reference/inline-assembly.html
-#[unstable(feature = "naked_functions", issue = "90957")]
-#[rustc_builtin_macro]
-#[cfg(not(bootstrap))]
-pub macro naked_asm("assembly template", $(operands,)* $(options($(option),*))?){
-/* compiler built-in */
-}

src/tools/rustfmt/src/parse/macros/asm.rs

@@ -1,11 +1,11 @@
 use rustc_ast::ast;
-use rustc_builtin_macros::asm::{parse_asm_args,AsmArgs,AsmMacro};
+use rustc_builtin_macros::asm::{parse_asm_args,AsmArgs};
 
 usecrate::rewrite::RewriteContext;
 
 #[allow(dead_code)]
 pub(crate)fnparse_asm(context:&RewriteContext<'_>,mac:&ast::MacCall) -> Option<AsmArgs>{
 let ts = mac.args.tokens.clone();
 letmut parser = super::build_parser(context, ts);
-parse_asm_args(&mut parser, mac.span(),AsmMacro::Asm).ok()
+parse_asm_args(&mut parser, mac.span(),ast::AsmMacro::Asm).ok()
 }

tests/codegen/naked-fn/aligned.rs

@@ -4,7 +4,7 @@
 
 #![crate_type = "lib"]
 #![feature(naked_functions, fn_align)]
-use std::arch::asm;
+use std::arch::naked_asm;
 
 // CHECK: Function Attrs: naked
 // CHECK-NEXT: define{{.*}}void @naked_empty()
@@ -16,5 +16,5 @@ pub unsafe extern "C" fn naked_empty() {
 // CHECK-NEXT: start:
 // CHECK-NEXT: call void asm
 // CHECK-NEXT: unreachable
-asm!("ret", options(noreturn));
+naked_asm!("ret");
 }