src/tools/clippy/clippy_lints/src/asm_syntax.rs

   1 use std::fmt;
   2
   3 use crate::utils::span_lint_and_help;
   4 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
   5 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
   6 use rustc_session::{declare_lint_pass, declare_tool_lint};
   7
   8 #[derive(Clone, Copy, PartialEq, Eq)]
   9 enum AsmStyle {
  10     Intel,
  11     Att,
  12 }
  13
  14 impl fmt::Display for AsmStyle {
  15     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  16         match self {
  17             AsmStyle::Intel => f.write_str("Intel"),
  18             AsmStyle::Att => f.write_str("AT&T"),
  19         }
  20     }
  21 }
  22
  23 impl std::ops::Not for AsmStyle {
  24     type Output = AsmStyle;
  25
  26     fn not(self) -> AsmStyle {
  27         match self {
  28             AsmStyle::Intel => AsmStyle::Att,
  29             AsmStyle::Att => AsmStyle::Intel,
  30         }
  31     }
  32 }
  33
  34 fn check_expr_asm_syntax(lint: &'static Lint, cx: &EarlyContext<'_>, expr: &Expr, check_for: AsmStyle) {
  35     if let ExprKind::InlineAsm(ref inline_asm) = expr.kind {
  36         let style = if inline_asm.options.contains(InlineAsmOptions::ATT_SYNTAX) {
  37             AsmStyle::Att
  38         } else {
  39             AsmStyle::Intel
  40         };
  41
  42         if style == check_for {
  43             span_lint_and_help(
  44                 cx,
  45                 lint,
  46                 expr.span,
  47                 &format!("{} x86 assembly syntax used", style),
  48                 None,
  49                 &format!("use {} x86 assembly syntax", !style),
  50             );
  51         }
  52     }
  53 }
  54
  55 declare_clippy_lint! {
  56     /// **What it does:** Checks for usage of Intel x86 assembly syntax.
  57     ///
  58     /// **Why is this bad?** The lint has been enabled to indicate a preference
  59     /// for AT&T x86 assembly syntax.
  60     ///
  61     /// **Known problems:** None.
  62     ///
  63     /// **Example:**
  64     ///
  65     /// ```rust,no_run
  66     /// # #![feature(asm)]
  67     /// # unsafe { let ptr = "".as_ptr();
  68     /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
  69     /// # }
  70     /// ```
  71     /// Use instead:
  72     /// ```rust,no_run
  73     /// # #![feature(asm)]
  74     /// # unsafe { let ptr = "".as_ptr();
  75     /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
  76     /// # }
  77     /// ```
  78     pub INLINE_ASM_X86_INTEL_SYNTAX,
  79     restriction,
  80     "prefer AT&T x86 assembly syntax"
  81 }
  82
  83 declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
  84
  85 impl EarlyLintPass for InlineAsmX86IntelSyntax {
  86     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  87         check_expr_asm_syntax(Self::get_lints()[0], cx, expr, AsmStyle::Intel);
  88     }
  89 }
  90
  91 declare_clippy_lint! {
  92     /// **What it does:** Checks for usage of AT&T x86 assembly syntax.
  93     ///
  94     /// **Why is this bad?** The lint has been enabled to indicate a preference
  95     /// for Intel x86 assembly syntax.
  96     ///
  97     /// **Known problems:** None.
  98     ///
  99     /// **Example:**
 100     ///
 101     /// ```rust,no_run
 102     /// # #![feature(asm)]
 103     /// # unsafe { let ptr = "".as_ptr();
 104     /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
 105     /// # }
 106     /// ```
 107     /// Use instead:
 108     /// ```rust,no_run
 109     /// # #![feature(asm)]
 110     /// # unsafe { let ptr = "".as_ptr();
 111     /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
 112     /// # }
 113     /// ```
 114     pub INLINE_ASM_X86_ATT_SYNTAX,
 115     restriction,
 116     "prefer Intel x86 assembly syntax"
 117 }
 118
 119 declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
 120
 121 impl EarlyLintPass for InlineAsmX86AttSyntax {
 122     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
 123         check_expr_asm_syntax(Self::get_lints()[0], cx, expr, AsmStyle::Att);
 124     }
 125 }