declare_clippy_lint! {
/// **What it does:** Checks for usage of invalid atomic
- /// ordering in atomic loads/stores and memory fences.
+ /// ordering in atomic loads/stores/exchanges/updates and
+ /// memory fences.
///
/// **Why is this bad?** Using an invalid atomic ordering
/// will cause a panic at run-time.
///
/// **Example:**
/// ```rust,no_run
- /// # use std::sync::atomic::{self, AtomicBool, Ordering};
+ /// # use std::sync::atomic::{self, AtomicU8, Ordering};
///
- /// let x = AtomicBool::new(true);
+ /// let x = AtomicU8::new(0);
///
+ /// // Bad: `Release` and `AcqRel` cannot be used for `load`.
/// let _ = x.load(Ordering::Release);
/// let _ = x.load(Ordering::AcqRel);
///
- /// x.store(false, Ordering::Acquire);
- /// x.store(false, Ordering::AcqRel);
+ /// // Bad: `Acquire` and `AcqRel` cannot be used for `store`.
+ /// x.store(1, Ordering::Acquire);
+ /// x.store(2, Ordering::AcqRel);
///
+ /// // Bad: `Relaxed` cannot be used as a fence's ordering.
/// atomic::fence(Ordering::Relaxed);
/// atomic::compiler_fence(Ordering::Relaxed);
+ ///
+ /// // Bad: `Release` and `AcqRel` are both always invalid
+ /// // for the failure ordering (the last arg).
+ /// let _ = x.compare_exchange(1, 2, Ordering::SeqCst, Ordering::Release);
+ /// let _ = x.compare_exchange_weak(2, 3, Ordering::AcqRel, Ordering::AcqRel);
+ ///
+ /// // Bad: The failure ordering is not allowed to be
+ /// // stronger than the success order, and `SeqCst` is
+ /// // stronger than `Relaxed`.
+ /// let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |val| Some(val + val));
/// ```
pub INVALID_ATOMIC_ORDERING,
correctness,
- "usage of invalid atomic ordering in atomic loads/stores and memory fences"
+ "usage of invalid atomic ordering in atomic operations and memory fences"
}
declare_lint_pass!(AtomicOrdering => [INVALID_ATOMIC_ORDERING]);
}
}
+fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId> {
+ if let ExprKind::Path(ref ord_qpath) = ord_arg.kind {
+ cx.qpath_res(ord_qpath, ord_arg.hir_id).opt_def_id()
+ } else {
+ None
+ }
+}
+
+fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
+ if_chain! {
+ if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
+ let method = method_path.ident.name.as_str();
+ if type_is_atomic(cx, &args[0]);
+ if method == "compare_exchange" || method == "compare_exchange_weak" || method == "fetch_update";
+ let (success_order_arg, failure_order_arg) = if method == "fetch_update" {
+ (&args[1], &args[2])
+ } else {
+ (&args[3], &args[4])
+ };
+ if let Some(fail_ordering_def_id) = opt_ordering_defid(cx, failure_order_arg);
+ then {
+ // Helper type holding on to some checking and error reporting data. Has
+ // - (success ordering name,
+ // - list of failure orderings forbidden by the success order,
+ // - suggestion message)
+ type OrdLintInfo = (&'static str, &'static [&'static str], &'static str);
+ let relaxed: OrdLintInfo = ("Relaxed", &["SeqCst", "Acquire"], "ordering mode `Relaxed`");
+ let acquire: OrdLintInfo = ("Acquire", &["SeqCst"], "ordering modes `Acquire` or `Relaxed`");
+ let seq_cst: OrdLintInfo = ("SeqCst", &[], "ordering modes `Acquire`, `SeqCst` or `Relaxed`");
+ let release = ("Release", relaxed.1, relaxed.2);
+ let acqrel = ("AcqRel", acquire.1, acquire.2);
+ let search = [relaxed, acquire, seq_cst, release, acqrel];
+
+ let success_lint_info = opt_ordering_defid(cx, success_order_arg)
+ .and_then(|success_ord_def_id| -> Option<OrdLintInfo> {
+ search
+ .iter()
+ .find(|(ordering, ..)| {
+ match_def_path(cx, success_ord_def_id,
+ &["core", "sync", "atomic", "Ordering", ordering])
+ })
+ .copied()
+ });
+
+ if match_ordering_def_path(cx, fail_ordering_def_id, &["Release", "AcqRel"]) {
+ // If we don't know the success order is, use what we'd suggest
+ // if it were maximally permissive.
+ let suggested = success_lint_info.unwrap_or(seq_cst).2;
+ span_lint_and_help(
+ cx,
+ INVALID_ATOMIC_ORDERING,
+ failure_order_arg.span,
+ &format!(
+ "{}'s failure ordering may not be `Release` or `AcqRel`",
+ method,
+ ),
+ None,
+ &format!("consider using {} instead", suggested),
+ );
+ } else if let Some((success_ord_name, bad_ords_given_success, suggested)) = success_lint_info {
+ if match_ordering_def_path(cx, fail_ordering_def_id, bad_ords_given_success) {
+ span_lint_and_help(
+ cx,
+ INVALID_ATOMIC_ORDERING,
+ failure_order_arg.span,
+ &format!(
+ "{}'s failure ordering may not be stronger than the success ordering of `{}`",
+ method,
+ success_ord_name,
+ ),
+ None,
+ &format!("consider using {} instead", suggested),
+ );
+ }
+ }
+ }
+ }
+}
+
impl<'tcx> LateLintPass<'tcx> for AtomicOrdering {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
check_atomic_load_store(cx, expr);
check_memory_fence(cx, expr);
+ check_atomic_compare_exchange(cx, expr);
}
}
projects / rust.git / blobdiff