src/librustc_mir/transform/remove_noop_landing_pads.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use rustc::ty::TyCtxt;
  12 use rustc::mir::*;
  13 use rustc_data_structures::bit_set::BitSet;
  14 use transform::{MirPass, MirSource};
  15 use util::patch::MirPatch;
  16
  17 /// A pass that removes no-op landing pads and replaces jumps to them with
  18 /// `None`. This is important because otherwise LLVM generates terrible
  19 /// code for these.
  20 pub struct RemoveNoopLandingPads;
  21
  22 pub fn remove_noop_landing_pads<'a, 'tcx>(
  23     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  24     mir: &mut Mir<'tcx>)
  25 {
  26     if tcx.sess.no_landing_pads() {
  27         return
  28     }
  29     debug!("remove_noop_landing_pads({:?})", mir);
  30
  31     RemoveNoopLandingPads.remove_nop_landing_pads(mir)
  32 }
  33
  34 impl MirPass for RemoveNoopLandingPads {
  35     fn run_pass<'a, 'tcx>(&self,
  36                           tcx: TyCtxt<'a, 'tcx, 'tcx>,
  37                           _src: MirSource,
  38                           mir: &mut Mir<'tcx>) {
  39         remove_noop_landing_pads(tcx, mir);
  40     }
  41 }
  42
  43 impl RemoveNoopLandingPads {
  44     fn is_nop_landing_pad(
  45         &self,
  46         bb: BasicBlock,
  47         mir: &Mir,
  48         nop_landing_pads: &BitSet<BasicBlock>,
  49     ) -> bool {
  50         for stmt in &mir[bb].statements {
  51             match stmt.kind {
  52                 StatementKind::FakeRead(..) |
  53                 StatementKind::StorageLive(_) |
  54                 StatementKind::StorageDead(_) |
  55                 StatementKind::EndRegion(_) |
  56                 StatementKind::AscribeUserType(..) |
  57                 StatementKind::Nop => {
  58                     // These are all nops in a landing pad (there's some
  59                     // borrowck interaction between EndRegion and storage
  60                     // instructions, but this should all run after borrowck).
  61                 }
  62
  63                 StatementKind::Assign(Place::Local(_), box Rvalue::Use(_)) => {
  64                     // Writing to a local (e.g. a drop flag) does not
  65                     // turn a landing pad to a non-nop
  66                 }
  67
  68                 StatementKind::Assign { .. } |
  69                 StatementKind::SetDiscriminant { .. } |
  70                 StatementKind::InlineAsm { .. } |
  71                 StatementKind::Retag { .. } |
  72                 StatementKind::EscapeToRaw { .. } => {
  73                     return false;
  74                 }
  75             }
  76         }
  77
  78         let terminator = mir[bb].terminator();
  79         match terminator.kind {
  80             TerminatorKind::Goto { .. } |
  81             TerminatorKind::Resume |
  82             TerminatorKind::SwitchInt { .. } |
  83             TerminatorKind::FalseEdges { .. } |
  84             TerminatorKind::FalseUnwind { .. } => {
  85                 terminator.successors().all(|&succ| {
  86                     nop_landing_pads.contains(succ)
  87                 })
  88             },
  89             TerminatorKind::GeneratorDrop |
  90             TerminatorKind::Yield { .. } |
  91             TerminatorKind::Return |
  92             TerminatorKind::Abort |
  93             TerminatorKind::Unreachable |
  94             TerminatorKind::Call { .. } |
  95             TerminatorKind::Assert { .. } |
  96             TerminatorKind::DropAndReplace { .. } |
  97             TerminatorKind::Drop { .. } => {
  98                 false
  99             }
 100         }
 101     }
 102
 103     fn remove_nop_landing_pads(&self, mir: &mut Mir) {
 104         // make sure there's a single resume block
 105         let resume_block = {
 106             let patch = MirPatch::new(mir);
 107             let resume_block = patch.resume_block();
 108             patch.apply(mir);
 109             resume_block
 110         };
 111         debug!("remove_noop_landing_pads: resume block is {:?}", resume_block);
 112
 113         let mut jumps_folded = 0;
 114         let mut landing_pads_removed = 0;
 115         let mut nop_landing_pads = BitSet::new_empty(mir.basic_blocks().len());
 116
 117         // This is a post-order traversal, so that if A post-dominates B
 118         // then A will be visited before B.
 119         let postorder: Vec<_> = traversal::postorder(mir).map(|(bb, _)| bb).collect();
 120         for bb in postorder {
 121             debug!("  processing {:?}", bb);
 122             for target in mir[bb].terminator_mut().successors_mut() {
 123                 if *target != resume_block && nop_landing_pads.contains(*target) {
 124                     debug!("    folding noop jump to {:?} to resume block", target);
 125                     *target = resume_block;
 126                     jumps_folded += 1;
 127                 }
 128             }
 129
 130             match mir[bb].terminator_mut().unwind_mut() {
 131                 Some(unwind) => {
 132                     if *unwind == Some(resume_block) {
 133                         debug!("    removing noop landing pad");
 134                         jumps_folded -= 1;
 135                         landing_pads_removed += 1;
 136                         *unwind = None;
 137                     }
 138                 }
 139                 _ => {}
 140             }
 141
 142             let is_nop_landing_pad = self.is_nop_landing_pad(bb, mir, &nop_landing_pads);
 143             if is_nop_landing_pad {
 144                 nop_landing_pads.insert(bb);
 145             }
 146             debug!("    is_nop_landing_pad({:?}) = {}", bb, is_nop_landing_pad);
 147         }
 148
 149         debug!("removed {:?} jumps and {:?} landing pads", jumps_folded, landing_pads_removed);
 150     }
 151 }