compiler/rustc_passes/src/naked_functions.rs

   1 //! Checks validity of naked functions.
   2
   3 use rustc_ast::{Attribute, InlineAsmOptions};
   4 use rustc_errors::{struct_span_err, Applicability};
   5 use rustc_hir as hir;
   6 use rustc_hir::def_id::LocalDefId;
   7 use rustc_hir::intravisit::{FnKind, Visitor};
   8 use rustc_hir::{ExprKind, HirId, InlineAsmOperand, StmtKind};
   9 use rustc_middle::ty::query::Providers;
  10 use rustc_middle::ty::TyCtxt;
  11 use rustc_session::lint::builtin::UNDEFINED_NAKED_FUNCTION_ABI;
  12 use rustc_span::symbol::sym;
  13 use rustc_span::Span;
  14 use rustc_target::spec::abi::Abi;
  15
  16 fn check_mod_naked_functions(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
  17     tcx.hir().visit_item_likes_in_module(
  18         module_def_id,
  19         &mut CheckNakedFunctions { tcx }.as_deep_visitor(),
  20     );
  21 }
  22
  23 crate fn provide(providers: &mut Providers) {
  24     *providers = Providers { check_mod_naked_functions, ..*providers };
  25 }
  26
  27 struct CheckNakedFunctions<'tcx> {
  28     tcx: TyCtxt<'tcx>,
  29 }
  30
  31 impl<'tcx> Visitor<'tcx> for CheckNakedFunctions<'tcx> {
  32     fn visit_fn(
  33         &mut self,
  34         fk: FnKind<'_>,
  35         _fd: &'tcx hir::FnDecl<'tcx>,
  36         body_id: hir::BodyId,
  37         span: Span,
  38         hir_id: HirId,
  39     ) {
  40         let ident_span;
  41         let fn_header;
  42
  43         match fk {
  44             FnKind::Closure => {
  45                 // Closures with a naked attribute are rejected during attribute
  46                 // check. Don't validate them any further.
  47                 return;
  48             }
  49             FnKind::ItemFn(ident, _, ref header, ..) => {
  50                 ident_span = ident.span;
  51                 fn_header = header;
  52             }
  53
  54             FnKind::Method(ident, ref sig, ..) => {
  55                 ident_span = ident.span;
  56                 fn_header = &sig.header;
  57             }
  58         }
  59
  60         let attrs = self.tcx.hir().attrs(hir_id);
  61         let naked = attrs.iter().any(|attr| attr.has_name(sym::naked));
  62         if naked {
  63             let body = self.tcx.hir().body(body_id);
  64             check_abi(self.tcx, hir_id, fn_header.abi, ident_span);
  65             check_no_patterns(self.tcx, body.params);
  66             check_no_parameters_use(self.tcx, body);
  67             check_asm(self.tcx, body, span);
  68             check_inline(self.tcx, attrs);
  69         }
  70     }
  71 }
  72
  73 /// Check that the function isn't inlined.
  74 fn check_inline(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
  75     for attr in attrs.iter().filter(|attr| attr.has_name(sym::inline)) {
  76         tcx.sess.struct_span_err(attr.span, "naked functions cannot be inlined").emit();
  77     }
  78 }
  79
  80 /// Checks that function uses non-Rust ABI.
  81 fn check_abi(tcx: TyCtxt<'_>, hir_id: HirId, abi: Abi, fn_ident_span: Span) {
  82     if abi == Abi::Rust {
  83         tcx.struct_span_lint_hir(UNDEFINED_NAKED_FUNCTION_ABI, hir_id, fn_ident_span, |lint| {
  84             lint.build("Rust ABI is unsupported in naked functions").emit();
  85         });
  86     }
  87 }
  88
  89 /// Checks that parameters don't use patterns. Mirrors the checks for function declarations.
  90 fn check_no_patterns(tcx: TyCtxt<'_>, params: &[hir::Param<'_>]) {
  91     for param in params {
  92         match param.pat.kind {
  93             hir::PatKind::Wild
  94             | hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, _, None) => {}
  95             _ => {
  96                 tcx.sess
  97                     .struct_span_err(
  98                         param.pat.span,
  99                         "patterns not allowed in naked function parameters",
 100                     )
 101                     .emit();
 102             }
 103         }
 104     }
 105 }
 106
 107 /// Checks that function parameters aren't used in the function body.
 108 fn check_no_parameters_use<'tcx>(tcx: TyCtxt<'tcx>, body: &'tcx hir::Body<'tcx>) {
 109     let mut params = hir::HirIdSet::default();
 110     for param in body.params {
 111         param.pat.each_binding(|_binding_mode, hir_id, _span, _ident| {
 112             params.insert(hir_id);
 113         });
 114     }
 115     CheckParameters { tcx, params }.visit_body(body);
 116 }
 117
 118 struct CheckParameters<'tcx> {
 119     tcx: TyCtxt<'tcx>,
 120     params: hir::HirIdSet,
 121 }
 122
 123 impl<'tcx> Visitor<'tcx> for CheckParameters<'tcx> {
 124     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
 125         if let hir::ExprKind::Path(hir::QPath::Resolved(
 126             _,
 127             hir::Path { res: hir::def::Res::Local(var_hir_id), .. },
 128         )) = expr.kind
 129         {
 130             if self.params.contains(var_hir_id) {
 131                 self.tcx
 132                     .sess
 133                     .struct_span_err(
 134                         expr.span,
 135                         "referencing function parameters is not allowed in naked functions",
 136                     )
 137                     .help("follow the calling convention in asm block to use parameters")
 138                     .emit();
 139                 return;
 140             }
 141         }
 142         hir::intravisit::walk_expr(self, expr);
 143     }
 144 }
 145
 146 /// Checks that function body contains a single inline assembly block.
 147 fn check_asm<'tcx>(tcx: TyCtxt<'tcx>, body: &'tcx hir::Body<'tcx>, fn_span: Span) {
 148     let mut this = CheckInlineAssembly { tcx, items: Vec::new() };
 149     this.visit_body(body);
 150     if let [(ItemKind::Asm | ItemKind::Err, _)] = this.items[..] {
 151         // Ok.
 152     } else {
 153         let mut diag = struct_span_err!(
 154             tcx.sess,
 155             fn_span,
 156             E0787,
 157             "naked functions must contain a single asm block"
 158         );
 159
 160         let mut must_show_error = false;
 161         let mut has_asm = false;
 162         let mut has_err = false;
 163         for &(kind, span) in &this.items {
 164             match kind {
 165                 ItemKind::Asm if has_asm => {
 166                     must_show_error = true;
 167                     diag.span_label(span, "multiple asm blocks are unsupported in naked functions");
 168                 }
 169                 ItemKind::Asm => has_asm = true,
 170                 ItemKind::NonAsm => {
 171                     must_show_error = true;
 172                     diag.span_label(span, "non-asm is unsupported in naked functions");
 173                 }
 174                 ItemKind::Err => has_err = true,
 175             }
 176         }
 177
 178         // If the naked function only contains a single asm block and a non-zero number of
 179         // errors, then don't show an additional error. This allows for appending/prepending
 180         // `compile_error!("...")` statements and reduces error noise.
 181         if must_show_error || !has_err {
 182             diag.emit();
 183         } else {
 184             diag.cancel();
 185         }
 186     }
 187 }
 188
 189 struct CheckInlineAssembly<'tcx> {
 190     tcx: TyCtxt<'tcx>,
 191     items: Vec<(ItemKind, Span)>,
 192 }
 193
 194 #[derive(Copy, Clone)]
 195 enum ItemKind {
 196     Asm,
 197     NonAsm,
 198     Err,
 199 }
 200
 201 impl<'tcx> CheckInlineAssembly<'tcx> {
 202     fn check_expr(&mut self, expr: &'tcx hir::Expr<'tcx>, span: Span) {
 203         match expr.kind {
 204             ExprKind::Box(..)
 205             | ExprKind::ConstBlock(..)
 206             | ExprKind::Array(..)
 207             | ExprKind::Call(..)
 208             | ExprKind::MethodCall(..)
 209             | ExprKind::Tup(..)
 210             | ExprKind::Binary(..)
 211             | ExprKind::Unary(..)
 212             | ExprKind::Lit(..)
 213             | ExprKind::Cast(..)
 214             | ExprKind::Type(..)
 215             | ExprKind::Loop(..)
 216             | ExprKind::Match(..)
 217             | ExprKind::If(..)
 218             | ExprKind::Closure(..)
 219             | ExprKind::Assign(..)
 220             | ExprKind::AssignOp(..)
 221             | ExprKind::Field(..)
 222             | ExprKind::Index(..)
 223             | ExprKind::Path(..)
 224             | ExprKind::AddrOf(..)
 225             | ExprKind::Let(..)
 226             | ExprKind::Break(..)
 227             | ExprKind::Continue(..)
 228             | ExprKind::Ret(..)
 229             | ExprKind::Struct(..)
 230             | ExprKind::Repeat(..)
 231             | ExprKind::Yield(..) => {
 232                 self.items.push((ItemKind::NonAsm, span));
 233             }
 234
 235             ExprKind::InlineAsm(ref asm) => {
 236                 self.items.push((ItemKind::Asm, span));
 237                 self.check_inline_asm(asm, span);
 238             }
 239
 240             ExprKind::DropTemps(..) | ExprKind::Block(..) => {
 241                 hir::intravisit::walk_expr(self, expr);
 242             }
 243
 244             ExprKind::Err => {
 245                 self.items.push((ItemKind::Err, span));
 246             }
 247         }
 248     }
 249
 250     fn check_inline_asm(&self, asm: &'tcx hir::InlineAsm<'tcx>, span: Span) {
 251         let unsupported_operands: Vec<Span> = asm
 252             .operands
 253             .iter()
 254             .filter_map(|&(ref op, op_sp)| match op {
 255                 InlineAsmOperand::Const { .. }
 256                 | InlineAsmOperand::SymFn { .. }
 257                 | InlineAsmOperand::SymStatic { .. } => None,
 258                 InlineAsmOperand::In { .. }
 259                 | InlineAsmOperand::Out { .. }
 260                 | InlineAsmOperand::InOut { .. }
 261                 | InlineAsmOperand::SplitInOut { .. } => Some(op_sp),
 262             })
 263             .collect();
 264         if !unsupported_operands.is_empty() {
 265             struct_span_err!(
 266                 self.tcx.sess,
 267                 unsupported_operands,
 268                 E0787,
 269                 "only `const` and `sym` operands are supported in naked functions",
 270             )
 271             .emit();
 272         }
 273
 274         let unsupported_options: Vec<&'static str> = [
 275             (InlineAsmOptions::MAY_UNWIND, "`may_unwind`"),
 276             (InlineAsmOptions::NOMEM, "`nomem`"),
 277             (InlineAsmOptions::NOSTACK, "`nostack`"),
 278             (InlineAsmOptions::PRESERVES_FLAGS, "`preserves_flags`"),
 279             (InlineAsmOptions::PURE, "`pure`"),
 280             (InlineAsmOptions::READONLY, "`readonly`"),
 281         ]
 282         .iter()
 283         .filter_map(|&(option, name)| if asm.options.contains(option) { Some(name) } else { None })
 284         .collect();
 285
 286         if !unsupported_options.is_empty() {
 287             struct_span_err!(
 288                 self.tcx.sess,
 289                 span,
 290                 E0787,
 291                 "asm options unsupported in naked functions: {}",
 292                 unsupported_options.join(", ")
 293             )
 294             .emit();
 295         }
 296
 297         if !asm.options.contains(InlineAsmOptions::NORETURN) {
 298             let last_span = asm
 299                 .operands
 300                 .last()
 301                 .map_or_else(|| asm.template_strs.last().unwrap().2, |op| op.1)
 302                 .shrink_to_hi();
 303
 304             struct_span_err!(
 305                 self.tcx.sess,
 306                 span,
 307                 E0787,
 308                 "asm in naked functions must use `noreturn` option"
 309             )
 310             .span_suggestion(
 311                 last_span,
 312                 "consider specifying that the asm block is responsible \
 313                 for returning from the function",
 314                 String::from(", options(noreturn)"),
 315                 Applicability::MachineApplicable,
 316             )
 317             .emit();
 318         }
 319     }
 320 }
 321
 322 impl<'tcx> Visitor<'tcx> for CheckInlineAssembly<'tcx> {
 323     fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
 324         match stmt.kind {
 325             StmtKind::Item(..) => {}
 326             StmtKind::Local(..) => {
 327                 self.items.push((ItemKind::NonAsm, stmt.span));
 328             }
 329             StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
 330                 self.check_expr(expr, stmt.span);
 331             }
 332         }
 333     }
 334
 335     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
 336         self.check_expr(&expr, expr.span);
 337     }
 338 }