rustc_mir_transform/
lint.rs

Help
1//! This pass statically detects code which has undefined behaviour or is likely to be erroneous.
2//! It can be used to locate problems in MIR building or optimizations. It assumes that all code
3//! can be executed, so it has false positives.
4
5use std::borrow::Cow;
6
7use rustc_data_structures::fx::FxHashSet;
8use rustc_index::bit_set::DenseBitSet;
9use rustc_middle::mir::visit::{PlaceContext, Visitor};
10use rustc_middle::mir::*;
11use rustc_middle::ty::TyCtxt;
12use rustc_mir_dataflow::impls::{MaybeStorageDead, MaybeStorageLive, always_storage_live_locals};
13use rustc_mir_dataflow::{Analysis, ResultsCursor};
14
15pub(super) fn lint_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, when: String) {
16    let always_live_locals = &always_storage_live_locals(body);
17
18    let maybe_storage_live = MaybeStorageLive::new(Cow::Borrowed(always_live_locals))
19        .iterate_to_fixpoint(tcx, body, None)
20        .into_results_cursor(body);
21
22    let maybe_storage_dead = MaybeStorageDead::new(Cow::Borrowed(always_live_locals))
23        .iterate_to_fixpoint(tcx, body, None)
24        .into_results_cursor(body);
25
26    let mut lint = Lint {
27        tcx,
28        when,
29        body,
30        is_fn_like: tcx.def_kind(body.source.def_id()).is_fn_like(),
31        always_live_locals,
32        maybe_storage_live,
33        maybe_storage_dead,
34        places: Default::default(),
35    };
36    for (bb, data) in traversal::reachable(body) {
37        lint.visit_basic_block_data(bb, data);
38    }
39}
40
41struct Lint<'a, 'tcx> {
42    tcx: TyCtxt<'tcx>,
43    when: String,
44    body: &'a Body<'tcx>,
45    is_fn_like: bool,
46    always_live_locals: &'a DenseBitSet<Local>,
47    maybe_storage_live: ResultsCursor<'a, 'tcx, MaybeStorageLive<'a>>,
48    maybe_storage_dead: ResultsCursor<'a, 'tcx, MaybeStorageDead<'a>>,
49    places: FxHashSet<PlaceRef<'tcx>>,
50}
51
52impl<'a, 'tcx> Lint<'a, 'tcx> {
53    #[track_caller]
54    fn fail(&self, location: Location, msg: impl AsRef<str>) {
55        let span = self.body.source_info(location).span;
56        self.tcx.sess.dcx().span_delayed_bug(
57            span,
58            format!(
59                "broken MIR in {:?} ({}) at {:?}:\n{}",
60                self.body.source.instance,
61                self.when,
62                location,
63                msg.as_ref()
64            ),
65        );
66    }
67}
68
69impl<'a, 'tcx> Visitor<'tcx> for Lint<'a, 'tcx> {
70    fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
71        if context.is_use() {
72            self.maybe_storage_dead.seek_after_primary_effect(location);
73            if self.maybe_storage_dead.get().contains(local) {
74                self.fail(location, format!("use of local {local:?}, which has no storage here"));
75            }
76        }
77    }
78
79    fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
80        match &statement.kind {
81            StatementKind::Assign(box (dest, rvalue)) => {
82                if let Rvalue::Use(Operand::Copy(src) | Operand::Move(src)) = rvalue {
83                    // The sides of an assignment must not alias. Currently this just checks whether
84                    // the places are identical.
85                    if dest == src {
86                        self.fail(
87                            location,
88                            "encountered `Assign` statement with overlapping memory",
89                        );
90                    }
91                }
92            }
93            StatementKind::StorageLive(local) => {
94                self.maybe_storage_live.seek_before_primary_effect(location);
95                if self.maybe_storage_live.get().contains(*local) {
96                    self.fail(
97                        location,
98                        format!("StorageLive({local:?}) which already has storage here"),
99                    );
100                }
101            }
102            _ => {}
103        }
104
105        self.super_statement(statement, location);
106    }
107
108    fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
109        match &terminator.kind {
110            TerminatorKind::Return => {
111                if self.is_fn_like {
112                    self.maybe_storage_live.seek_after_primary_effect(location);
113                    for local in self.maybe_storage_live.get().iter() {
114                        if !self.always_live_locals.contains(local) {
115                            self.fail(
116                                location,
117                                format!(
118                                    "local {local:?} still has storage when returning from function"
119                                ),
120                            );
121                        }
122                    }
123                }
124            }
125            TerminatorKind::Call { args, destination, .. } => {
126                // The call destination place and Operand::Move place used as an argument might be
127                // passed by a reference to the callee. Consequently they must be non-overlapping.
128                // Currently this simply checks for duplicate places.
129                self.places.clear();
130                self.places.insert(destination.as_ref());
131                let mut has_duplicates = false;
132                for arg in args {
133                    if let Operand::Move(place) = &arg.node {
134                        has_duplicates |= !self.places.insert(place.as_ref());
135                    }
136                }
137                if has_duplicates {
138                    self.fail(
139                        location,
140                        format!(
141                            "encountered overlapping memory in `Move` arguments to `Call` terminator: {:?}",
142                            terminator.kind,
143                        ),
144                    );
145                }
146            }
147            _ => {}
148        }
149
150        self.super_terminator(terminator, location);
151    }
152}
rustc_mir_transform/lint.rs

rustc_mir_transform/
lint.rs
