1 use rustc_middle::mir::{self, Body, MirPhase, RuntimePhase};
2 use rustc_middle::ty::TyCtxt;
3 use rustc_session::Session;
5 use crate::{validate, MirPass};
7 /// Just like `MirPass`, except it cannot mutate `Body`.
8 pub trait MirLint<'tcx> {
9 fn name(&self) -> &str {
10 let name = std::any::type_name::<Self>();
11 if let Some((_, tail)) = name.rsplit_once(':') { tail } else { name }
14 fn is_enabled(&self, _sess: &Session) -> bool {
18 fn run_lint(&self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>);
21 /// An adapter for `MirLint`s that implements `MirPass`.
22 #[derive(Debug, Clone)]
23 pub struct Lint<T>(pub T);
25 impl<'tcx, T> MirPass<'tcx> for Lint<T>
29 fn name(&self) -> &str {
33 fn is_enabled(&self, sess: &Session) -> bool {
34 self.0.is_enabled(sess)
37 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
38 self.0.run_lint(tcx, body)
41 fn is_mir_dump_enabled(&self) -> bool {
46 pub struct WithMinOptLevel<T>(pub u32, pub T);
48 impl<'tcx, T> MirPass<'tcx> for WithMinOptLevel<T>
52 fn name(&self) -> &str {
56 fn is_enabled(&self, sess: &Session) -> bool {
57 sess.mir_opt_level() >= self.0 as usize
60 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
61 self.1.run_pass(tcx, body)
65 /// Run the sequence of passes without validating the MIR after each pass. The MIR is still
66 /// validated at the end.
67 pub fn run_passes_no_validate<'tcx>(
69 body: &mut Body<'tcx>,
70 passes: &[&dyn MirPass<'tcx>],
71 phase_change: Option<MirPhase>,
73 run_passes_inner(tcx, body, passes, phase_change, false);
76 /// The optional `phase_change` is applied after executing all the passes, if present
77 pub fn run_passes<'tcx>(
79 body: &mut Body<'tcx>,
80 passes: &[&dyn MirPass<'tcx>],
81 phase_change: Option<MirPhase>,
83 run_passes_inner(tcx, body, passes, phase_change, true);
86 fn run_passes_inner<'tcx>(
88 body: &mut Body<'tcx>,
89 passes: &[&dyn MirPass<'tcx>],
90 phase_change: Option<MirPhase>,
93 let validate = validate_each & tcx.sess.opts.unstable_opts.validate_mir & !body.should_skip();
94 let overridden_passes = &tcx.sess.opts.unstable_opts.mir_enable_passes;
95 trace!(?overridden_passes);
97 if !body.should_skip() {
99 let name = pass.name();
101 let overridden = overridden_passes.iter().rev().find(|(s, _)| s == &*name).map(
102 |(_name, polarity)| {
105 "{} as requested by flag",
106 if *polarity { "Running" } else { "Not running" },
111 if !overridden.unwrap_or_else(|| pass.is_enabled(&tcx.sess)) {
115 let dump_enabled = pass.is_mir_dump_enabled();
118 dump_mir_for_pass(tcx, body, &name, false);
121 validate_body(tcx, body, format!("before pass {}", name));
124 pass.run_pass(tcx, body);
127 dump_mir_for_pass(tcx, body, &name, true);
130 validate_body(tcx, body, format!("after pass {}", name));
133 body.pass_count += 1;
137 if let Some(new_phase) = phase_change {
138 if body.phase >= new_phase {
139 panic!("Invalid MIR phase transition from {:?} to {:?}", body.phase, new_phase);
142 body.phase = new_phase;
145 dump_mir_for_phase_change(tcx, body);
146 if validate || new_phase == MirPhase::Runtime(RuntimePhase::Optimized) {
147 validate_body(tcx, body, format!("after phase change to {}", new_phase.name()));
154 pub fn validate_body<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, when: String) {
155 validate::Validator { when, mir_phase: body.phase }.run_pass(tcx, body);
158 pub fn dump_mir_for_pass<'tcx>(
168 if is_after { &"after" } else { &"before" },
174 pub fn dump_mir_for_phase_change<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
175 assert_eq!(body.pass_count, 0);
176 mir::dump_mir(tcx, true, body.phase.name(), &"after", body, |_, _| Ok(()))