[rustc.git] / compiler / rustc_passes / src / naked_functions.rs

//! Checks validity of naked functions.

use rustc_ast::{Attribute, InlineAsmOptions};
use rustc_hir as hir;
use rustc_hir::def_id::LocalDefId;
use rustc_hir::intravisit::{ErasedMap, FnKind, NestedVisitorMap, Visitor};
use rustc_hir::{ExprKind, HirId, InlineAsmOperand, StmtKind};
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::TyCtxt;
use rustc_session::lint::builtin::UNDEFINED_NAKED_FUNCTION_ABI;
use rustc_session::lint::builtin::UNSUPPORTED_NAKED_FUNCTIONS;
use rustc_span::symbol::sym;
use rustc_span::Span;
use rustc_target::spec::abi::Abi;

fn check_mod_naked_functions(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
    tcx.hir().visit_item_likes_in_module(
        module_def_id,
        &mut CheckNakedFunctions { tcx }.as_deep_visitor(),
    );
}

crate fn provide(providers: &mut Providers) {
    *providers = Providers { check_mod_naked_functions, ..*providers };
}

struct CheckNakedFunctions<'tcx> {
    tcx: TyCtxt<'tcx>,
}

impl<'tcx> Visitor<'tcx> for CheckNakedFunctions<'tcx> {
    type Map = ErasedMap<'tcx>;

    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
        NestedVisitorMap::None
    }

    fn visit_fn(
        &mut self,
        fk: FnKind<'v>,
        _fd: &'tcx hir::FnDecl<'tcx>,
        body_id: hir::BodyId,
        span: Span,
        hir_id: HirId,
    ) {
        let ident_span;
        let fn_header;

        match fk {
            FnKind::Closure => {
                // Closures with a naked attribute are rejected during attribute
                // check. Don't validate them any further.
                return;
            }
            FnKind::ItemFn(ident, _, ref header, ..) => {
                ident_span = ident.span;
                fn_header = header;
            }

            FnKind::Method(ident, ref sig, ..) => {
                ident_span = ident.span;
                fn_header = &sig.header;
            }
        }

        let attrs = self.tcx.hir().attrs(hir_id);
        let naked = attrs.iter().any(|attr| attr.has_name(sym::naked));
        if naked {
            let body = self.tcx.hir().body(body_id);
            check_abi(self.tcx, hir_id, fn_header.abi, ident_span);
            check_no_patterns(self.tcx, body.params);
            check_no_parameters_use(self.tcx, body);
            check_asm(self.tcx, hir_id, body, span);
            check_inline(self.tcx, hir_id, attrs);
        }
    }
}

/// Check that the function isn't inlined.
fn check_inline(tcx: TyCtxt<'_>, hir_id: HirId, attrs: &[Attribute]) {
    for attr in attrs.iter().filter(|attr| attr.has_name(sym::inline)) {
        tcx.struct_span_lint_hir(UNSUPPORTED_NAKED_FUNCTIONS, hir_id, attr.span, |lint| {
            lint.build("naked functions cannot be inlined").emit();
        });
    }
}

/// Checks that function uses non-Rust ABI.
fn check_abi(tcx: TyCtxt<'_>, hir_id: HirId, abi: Abi, fn_ident_span: Span) {
    if abi == Abi::Rust {
        tcx.struct_span_lint_hir(UNDEFINED_NAKED_FUNCTION_ABI, hir_id, fn_ident_span, |lint| {
            lint.build("Rust ABI is unsupported in naked functions").emit();
        });
    }
}

/// Checks that parameters don't use patterns. Mirrors the checks for function declarations.
fn check_no_patterns(tcx: TyCtxt<'_>, params: &[hir::Param<'_>]) {
    for param in params {
        match param.pat.kind {
            hir::PatKind::Wild
            | hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, _, None) => {}
            _ => {
                tcx.sess
                    .struct_span_err(
                        param.pat.span,
                        "patterns not allowed in naked function parameters",
                    )
                    .emit();
            }
        }
    }
}

/// Checks that function parameters aren't used in the function body.
fn check_no_parameters_use<'tcx>(tcx: TyCtxt<'tcx>, body: &'tcx hir::Body<'tcx>) {
    let mut params = hir::HirIdSet::default();
    for param in body.params {
        param.pat.each_binding(|_binding_mode, hir_id, _span, _ident| {
            params.insert(hir_id);
        });
    }
    CheckParameters { tcx, params }.visit_body(body);
}

struct CheckParameters<'tcx> {
    tcx: TyCtxt<'tcx>,
    params: hir::HirIdSet,
}

impl<'tcx> Visitor<'tcx> for CheckParameters<'tcx> {
    type Map = ErasedMap<'tcx>;

    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
        NestedVisitorMap::None
    }

    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
        if let hir::ExprKind::Path(hir::QPath::Resolved(
            _,
            hir::Path { res: hir::def::Res::Local(var_hir_id), .. },
        )) = expr.kind
        {
            if self.params.contains(var_hir_id) {
                self.tcx
                    .sess
                    .struct_span_err(
                        expr.span,
                        "referencing function parameters is not allowed in naked functions",
                    )
                    .help("follow the calling convention in asm block to use parameters")
                    .emit();
                return;
            }
        }
        hir::intravisit::walk_expr(self, expr);
    }
}

/// Checks that function body contains a single inline assembly block.
fn check_asm<'tcx>(tcx: TyCtxt<'tcx>, hir_id: HirId, body: &'tcx hir::Body<'tcx>, fn_span: Span) {
    let mut this = CheckInlineAssembly { tcx, items: Vec::new() };
    this.visit_body(body);
    if let [(ItemKind::Asm, _)] = this.items[..] {
        // Ok.
    } else {
        tcx.struct_span_lint_hir(UNSUPPORTED_NAKED_FUNCTIONS, hir_id, fn_span, |lint| {
            let mut diag = lint.build("naked functions must contain a single asm block");
            let mut has_asm = false;
            for &(kind, span) in &this.items {
                match kind {
                    ItemKind::Asm if has_asm => {
                        diag.span_label(
                            span,
                            "multiple asm blocks are unsupported in naked functions",
                        );
                    }
                    ItemKind::Asm => has_asm = true,
                    ItemKind::NonAsm => {
                        diag.span_label(span, "non-asm is unsupported in naked functions");
                    }
                }
            }
            diag.emit();
        });
    }
}

struct CheckInlineAssembly<'tcx> {
    tcx: TyCtxt<'tcx>,
    items: Vec<(ItemKind, Span)>,
}

#[derive(Copy, Clone)]
enum ItemKind {
    Asm,
    NonAsm,
}

impl<'tcx> CheckInlineAssembly<'tcx> {
    fn check_expr(&mut self, expr: &'tcx hir::Expr<'tcx>, span: Span) {
        match expr.kind {
            ExprKind::Box(..)
            | ExprKind::ConstBlock(..)
            | ExprKind::Array(..)
            | ExprKind::Call(..)
            | ExprKind::MethodCall(..)
            | ExprKind::Tup(..)
            | ExprKind::Binary(..)
            | ExprKind::Unary(..)
            | ExprKind::Lit(..)
            | ExprKind::Cast(..)
            | ExprKind::Type(..)
            | ExprKind::Loop(..)
            | ExprKind::Match(..)
            | ExprKind::If(..)
            | ExprKind::Closure(..)
            | ExprKind::Assign(..)
            | ExprKind::AssignOp(..)
            | ExprKind::Field(..)
            | ExprKind::Index(..)
            | ExprKind::Path(..)
            | ExprKind::AddrOf(..)
            | ExprKind::Let(..)
            | ExprKind::Break(..)
            | ExprKind::Continue(..)
            | ExprKind::Ret(..)
            | ExprKind::Struct(..)
            | ExprKind::Repeat(..)
            | ExprKind::Yield(..) => {
                self.items.push((ItemKind::NonAsm, span));
            }

            ExprKind::InlineAsm(ref asm) => {
                self.items.push((ItemKind::Asm, span));
                self.check_inline_asm(expr.hir_id, asm, span);
            }

            ExprKind::LlvmInlineAsm(..) => {
                self.items.push((ItemKind::Asm, span));
                self.tcx.struct_span_lint_hir(
                    UNSUPPORTED_NAKED_FUNCTIONS,
                    expr.hir_id,
                    span,
                    |lint| {
                        lint.build(
                            "the LLVM-style inline assembly is unsupported in naked functions",
                        )
                        .help("use the new asm! syntax specified in RFC 2873")
                        .emit();
                    },
                );
            }

            ExprKind::DropTemps(..) | ExprKind::Block(..) | ExprKind::Err => {
                hir::intravisit::walk_expr(self, expr);
            }
        }
    }

    fn check_inline_asm(&self, hir_id: HirId, asm: &'tcx hir::InlineAsm<'tcx>, span: Span) {
        let unsupported_operands: Vec<Span> = asm
            .operands
            .iter()
            .filter_map(|&(ref op, op_sp)| match op {
                InlineAsmOperand::Const { .. } | InlineAsmOperand::Sym { .. } => None,
                InlineAsmOperand::In { .. }
                | InlineAsmOperand::Out { .. }
                | InlineAsmOperand::InOut { .. }
                | InlineAsmOperand::SplitInOut { .. } => Some(op_sp),
            })
            .collect();
        if !unsupported_operands.is_empty() {
            self.tcx.struct_span_lint_hir(
                UNSUPPORTED_NAKED_FUNCTIONS,
                hir_id,
                unsupported_operands,
                |lint| {
                    lint.build("only `const` and `sym` operands are supported in naked functions")
                        .emit();
                },
            );
        }

        let unsupported_options: Vec<&'static str> = [
            (InlineAsmOptions::NOMEM, "`nomem`"),
            (InlineAsmOptions::NOSTACK, "`nostack`"),
            (InlineAsmOptions::PRESERVES_FLAGS, "`preserves_flags`"),
            (InlineAsmOptions::PURE, "`pure`"),
            (InlineAsmOptions::READONLY, "`readonly`"),
        ]
        .iter()
        .filter_map(|&(option, name)| if asm.options.contains(option) { Some(name) } else { None })
        .collect();

        if !unsupported_options.is_empty() {
            self.tcx.struct_span_lint_hir(UNSUPPORTED_NAKED_FUNCTIONS, hir_id, span, |lint| {
                lint.build(&format!(
                    "asm options unsupported in naked functions: {}",
                    unsupported_options.join(", ")
                ))
                .emit();
            });
        }

        if !asm.options.contains(InlineAsmOptions::NORETURN) {
            self.tcx.struct_span_lint_hir(UNSUPPORTED_NAKED_FUNCTIONS, hir_id, span, |lint| {
                lint.build("asm in naked functions must use `noreturn` option").emit();
            });
        }
    }
}

impl<'tcx> Visitor<'tcx> for CheckInlineAssembly<'tcx> {
    type Map = ErasedMap<'tcx>;

    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
        NestedVisitorMap::None
    }

    fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
        match stmt.kind {
            StmtKind::Item(..) => {}
            StmtKind::Local(..) => {
                self.items.push((ItemKind::NonAsm, stmt.span));
            }
            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
                self.check_expr(expr, stmt.span);
            }
        }
    }

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