add lint for suspicious asm options

Author: Soveu

CHANGELOG.md

@@ -5714,6 +5714,7 @@ Released 2018-09-13
 [`path_ends_with_ext`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_ends_with_ext
 [`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
 [`permissions_set_readonly_false`]: https://rust-lang.github.io/rust-clippy/master/index.html#permissions_set_readonly_false
+[`pointer_in_nomem_asm_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#pointer_in_nomem_asm_block
 [`positional_named_format_parameters`]: https://rust-lang.github.io/rust-clippy/master/index.html#positional_named_format_parameters
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
 [`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence

clippy_lints/src/declared_lints.rs

@@ -600,6 +600,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF_INFO,
     crate::pattern_type_mismatch::PATTERN_TYPE_MISMATCH_INFO,
     crate::permissions_set_readonly_false::PERMISSIONS_SET_READONLY_FALSE_INFO,
+    crate::pointer_in_nomem_asm_block::POINTER_IN_NOMEM_ASM_BLOCK_INFO,
     crate::precedence::PRECEDENCE_INFO,
     crate::ptr::CMP_NULL_INFO,
     crate::ptr::INVALID_NULL_PTR_USAGE_INFO,

clippy_lints/src/lib.rs

@@ -289,6 +289,7 @@ mod partialeq_to_none;
 mod pass_by_ref_or_value;
 mod pattern_type_mismatch;
 mod permissions_set_readonly_false;
+mod pointer_in_nomem_asm_block;
 mod precedence;
 mod ptr;
 mod ptr_offset_with_cast;
@@ -1176,6 +1177,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(set_contains_or_insert::HashsetInsertAfterContains));
     store.register_early_pass(|| Box::new(byte_char_slices::ByteCharSlice));
     store.register_early_pass(|| Box::new(cfg_not_test::CfgNotTest));
+    store.register_late_pass(|_| Box::new(pointer_in_nomem_asm_block::PointerInNomemAsmBlock));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/pointer_in_nomem_asm_block.rs

@@ -0,0 +1,90 @@
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_ast::InlineAsmOptions;
+use clippy_utils::diagnostics::span_lint;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum AsmMemoryOptions {
+    NoMem,
+    Readonly,
+}
+
+fn has_in_operand_pointer(cx: &LateContext<'_>, asm_op: &InlineAsmOperand<'_>) -> Option<Mutability> {
+    let asm_in_expr = match asm_op {
+        InlineAsmOperand::In { expr, .. } => expr,
+        InlineAsmOperand::InOut { expr, .. } => expr,
+        InlineAsmOperand::SplitInOut { in_expr, ..} => in_expr,
+        InlineAsmOperand::SymStatic { .. } => return Some(Mutability::Not),
+        InlineAsmOperand::Out { .. } => return None,
+        InlineAsmOperand::Const { .. } => return None,
+        InlineAsmOperand::SymFn { .. } => return None,
+        InlineAsmOperand::Label { .. } => return None,
+    };
+
+    return match cx.typeck_results().expr_ty(asm_in_expr).kind() {
+        rustc_middle::ty::TyKind::RawPtr(_, mutbl) => Some(*mutbl),
+        rustc_middle::ty::TyKind::Ref(_, _, mutbl) => Some(*mutbl),
+        _ => None,
+    };
+}
+
+fn yeet_lint(cx: &LateContext<'_>, span: rustc_span::Span, msg: &'static str) {
+    span_lint(cx, POINTER_IN_NOMEM_ASM_BLOCK, span, msg);
+}
+
+fn check_asm(cx: &LateContext<'_>, asm: &InlineAsm<'_>) {
+    let nomem = asm.options.contains(InlineAsmOptions::NOMEM);
+    let rdonly = asm.options.contains(InlineAsmOptions::READONLY);
+    let memopt = match (nomem, rdonly) {
+        (false, false) => return, // nothing to check
+        (false, true) => AsmMemoryOptions::Readonly,
+        (true, false) => AsmMemoryOptions::NoMem,
+        (true, true) => return, // just return, rustc should fail anyway
+    };
+
+    for (asm_op, asm_op_span) in asm.operands {
+        let p = match has_in_operand_pointer(cx, asm_op) {
+            Some(p) => p,
+            None => continue,
+        };
+
+        let msg = match (p, memopt) {
+            (Mutability::Not, AsmMemoryOptions::Readonly) => continue,
+            (Mutability::Not, AsmMemoryOptions::NoMem) => "const pointer in nomem",
+            (Mutability::Mut, AsmMemoryOptions::Readonly) => "mut pointer in readonly",
+            (Mutability::Mut, AsmMemoryOptions::NoMem) => "mut pointer in nomem",
+        };
+
+        yeet_lint(cx, *asm_op_span, msg);
+    }
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub POINTER_IN_NOMEM_ASM_BLOCK,
+    suspicious,
+    "default lint description"
+}
+
+declare_lint_pass!(PointerInNomemAsmBlock => [POINTER_IN_NOMEM_ASM_BLOCK]);
+
+impl<'tcx> LateLintPass<'tcx> for PointerInNomemAsmBlock {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if let ExprKind::InlineAsm(asm) = &expr.kind {
+            check_asm(cx, asm);
+        }
+    }
+}

tests/ui/pointer_in_nomem_asm_block.rs

@@ -0,0 +1,28 @@
+#![warn(clippy::pointer_in_nomem_asm_block)]
+#![crate_type = "lib"]
+#![no_std]
+
+unsafe fn nomem_bad(p: &i32) {
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags));
+}
+
+unsafe fn readonly_bad(p: &mut i32) {
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(readonly, nostack, preserves_flags));
+}
+
+unsafe fn nomem_good(p: &i32) {
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(readonly, nostack, preserves_flags));
+    let p = p as *const i32 as usize;
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags));
+}
+
+unsafe fn readonly_good(p: &mut i32) {
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(nostack, preserves_flags));
+    core::arch::asm!("asdf {p}", p = in(reg) &*p, options(readonly, nostack, preserves_flags));
+    let p = p as *const i32;
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(readonly, nostack, preserves_flags));
+}
+
+unsafe fn nomem_bad2(p: &mut i32) {
+    core::arch::asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags));
+}