src/librustc_mir/transform/simplify_try.rs

   1 //! The general point of the optimizations provided here is to simplify something like:
   2 //!
   3 //! ```rust
   4 //! match x {
   5 //!     Ok(x) => Ok(x),
   6 //!     Err(x) => Err(x)
   7 //! }
   8 //! ```
   9 //!
  10 //! into just `x`.
  11
  12 use crate::transform::{simplify, MirPass, MirSource};
  13 use itertools::Itertools as _;
  14 use rustc::mir::*;
  15 use rustc::ty::{Ty, TyCtxt};
  16 use rustc_target::abi::VariantIdx;
  17
  18 /// Simplifies arms of form `Variant(x) => Variant(x)` to just a move.
  19 ///
  20 /// This is done by transforming basic blocks where the statements match:
  21 ///
  22 /// ```rust
  23 /// _LOCAL_TMP = ((_LOCAL_1 as Variant ).FIELD: TY );
  24 /// ((_LOCAL_0 as Variant).FIELD: TY) = move _LOCAL_TMP;
  25 /// discriminant(_LOCAL_0) = VAR_IDX;
  26 /// ```
  27 ///
  28 /// into:
  29 ///
  30 /// ```rust
  31 /// _LOCAL_0 = move _LOCAL_1
  32 /// ```
  33 pub struct SimplifyArmIdentity;
  34
  35 impl<'tcx> MirPass<'tcx> for SimplifyArmIdentity {
  36     fn run_pass(&self, _: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut BodyAndCache<'tcx>) {
  37         let (basic_blocks, local_decls) = body.basic_blocks_and_local_decls_mut();
  38         for bb in basic_blocks {
  39             // Need 3 statements:
  40             let (s0, s1, s2) = match &mut *bb.statements {
  41                 [s0, s1, s2] => (s0, s1, s2),
  42                 _ => continue,
  43             };
  44
  45             // Pattern match on the form we want:
  46             let (local_tmp_s0, local_1, vf_s0) = match match_get_variant_field(s0) {
  47                 None => continue,
  48                 Some(x) => x,
  49             };
  50             let (local_tmp_s1, local_0, vf_s1) = match match_set_variant_field(s1) {
  51                 None => continue,
  52                 Some(x) => x,
  53             };
  54             if local_tmp_s0 != local_tmp_s1
  55                 // The field-and-variant information match up.
  56                 || vf_s0 != vf_s1
  57                 // Source and target locals have the same type.
  58                 // FIXME(Centril | oli-obk): possibly relax to same layout?
  59                 || local_decls[local_0].ty != local_decls[local_1].ty
  60                 // We're setting the discriminant of `local_0` to this variant.
  61                 || Some((local_0, vf_s0.var_idx)) != match_set_discr(s2)
  62             {
  63                 continue;
  64             }
  65
  66             // Right shape; transform!
  67             match &mut s0.kind {
  68                 StatementKind::Assign(box (place, rvalue)) => {
  69                     *place = local_0.into();
  70                     *rvalue = Rvalue::Use(Operand::Move(local_1.into()));
  71                 }
  72                 _ => unreachable!(),
  73             }
  74             s1.make_nop();
  75             s2.make_nop();
  76         }
  77     }
  78 }
  79
  80 /// Match on:
  81 /// ```rust
  82 /// _LOCAL_INTO = ((_LOCAL_FROM as Variant).FIELD: TY);
  83 /// ```
  84 fn match_get_variant_field<'tcx>(stmt: &Statement<'tcx>) -> Option<(Local, Local, VarField<'tcx>)> {
  85     match &stmt.kind {
  86         StatementKind::Assign(box (place_into, rvalue_from)) => match rvalue_from {
  87             Rvalue::Use(Operand::Copy(pf)) | Rvalue::Use(Operand::Move(pf)) => {
  88                 let local_into = place_into.as_local()?;
  89                 let (local_from, vf) = match_variant_field_place(&pf)?;
  90                 Some((local_into, local_from, vf))
  91             }
  92             _ => None,
  93         },
  94         _ => None,
  95     }
  96 }
  97
  98 /// Match on:
  99 /// ```rust
 100 /// ((_LOCAL_FROM as Variant).FIELD: TY) = move _LOCAL_INTO;
 101 /// ```
 102 fn match_set_variant_field<'tcx>(stmt: &Statement<'tcx>) -> Option<(Local, Local, VarField<'tcx>)> {
 103     match &stmt.kind {
 104         StatementKind::Assign(box (place_from, rvalue_into)) => match rvalue_into {
 105             Rvalue::Use(Operand::Move(place_into)) => {
 106                 let local_into = place_into.as_local()?;
 107                 let (local_from, vf) = match_variant_field_place(&place_from)?;
 108                 Some((local_into, local_from, vf))
 109             }
 110             _ => None,
 111         },
 112         _ => None,
 113     }
 114 }
 115
 116 /// Match on:
 117 /// ```rust
 118 /// discriminant(_LOCAL_TO_SET) = VAR_IDX;
 119 /// ```
 120 fn match_set_discr<'tcx>(stmt: &Statement<'tcx>) -> Option<(Local, VariantIdx)> {
 121     match &stmt.kind {
 122         StatementKind::SetDiscriminant { place, variant_index } => {
 123             Some((place.as_local()?, *variant_index))
 124         }
 125         _ => None,
 126     }
 127 }
 128
 129 #[derive(PartialEq)]
 130 struct VarField<'tcx> {
 131     field: Field,
 132     field_ty: Ty<'tcx>,
 133     var_idx: VariantIdx,
 134 }
 135
 136 /// Match on `((_LOCAL as Variant).FIELD: TY)`.
 137 fn match_variant_field_place<'tcx>(place: &Place<'tcx>) -> Option<(Local, VarField<'tcx>)> {
 138     match place.as_ref() {
 139         PlaceRef {
 140             base: &PlaceBase::Local(local),
 141             projection: &[ProjectionElem::Downcast(_, var_idx), ProjectionElem::Field(field, ty)],
 142         } => Some((local, VarField { field, field_ty: ty, var_idx })),
 143         _ => None,
 144     }
 145 }
 146
 147 /// Simplifies `SwitchInt(_) -> [targets]`,
 148 /// where all the `targets` have the same form,
 149 /// into `goto -> target_first`.
 150 pub struct SimplifyBranchSame;
 151
 152 impl<'tcx> MirPass<'tcx> for SimplifyBranchSame {
 153     fn run_pass(&self, _: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut BodyAndCache<'tcx>) {
 154         let mut did_remove_blocks = false;
 155         let bbs = body.basic_blocks_mut();
 156         for bb_idx in bbs.indices() {
 157             let targets = match &bbs[bb_idx].terminator().kind {
 158                 TerminatorKind::SwitchInt { targets, .. } => targets,
 159                 _ => continue,
 160             };
 161
 162             let mut iter_bbs_reachable = targets
 163                 .iter()
 164                 .map(|idx| (*idx, &bbs[*idx]))
 165                 .filter(|(_, bb)| {
 166                     // Reaching `unreachable` is UB so assume it doesn't happen.
 167                     bb.terminator().kind != TerminatorKind::Unreachable
 168                     // But `asm!(...)` could abort the program,
 169                     // so we cannot assume that the `unreachable` terminator itself is reachable.
 170                     // FIXME(Centril): use a normalization pass instead of a check.
 171                     || bb.statements.iter().any(|stmt| match stmt.kind {
 172                         StatementKind::InlineAsm(..) => true,
 173                         _ => false,
 174                     })
 175                 })
 176                 .peekable();
 177
 178             // We want to `goto -> bb_first`.
 179             let bb_first = iter_bbs_reachable.peek().map(|(idx, _)| *idx).unwrap_or(targets[0]);
 180
 181             // All successor basic blocks should have the exact same form.
 182             let all_successors_equivalent =
 183                 iter_bbs_reachable.map(|(_, bb)| bb).tuple_windows().all(|(bb_l, bb_r)| {
 184                     bb_l.is_cleanup == bb_r.is_cleanup
 185                         && bb_l.terminator().kind == bb_r.terminator().kind
 186                         && bb_l.statements.iter().eq_by(&bb_r.statements, |x, y| x.kind == y.kind)
 187                 });
 188
 189             if all_successors_equivalent {
 190                 // Replace `SwitchInt(..) -> [bb_first, ..];` with a `goto -> bb_first;`.
 191                 bbs[bb_idx].terminator_mut().kind = TerminatorKind::Goto { target: bb_first };
 192                 did_remove_blocks = true;
 193             }
 194         }
 195
 196         if did_remove_blocks {
 197             // We have dead blocks now, so remove those.
 198             simplify::remove_dead_blocks(body);
 199         }
 200     }
 201 }