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::bitvec::BitVector;
  14 use rustc_data_structures::indexed_vec::Idx;
  15 use transform::{MirPass, MirSource};
  16 use util::patch::MirPatch;
  17
  18 /// A pass that removes no-op landing pads and replaces jumps to them with
  19 /// `None`. This is important because otherwise LLVM generates terrible
  20 /// code for these.
  21 pub struct RemoveNoopLandingPads;
  22
  23 impl MirPass for RemoveNoopLandingPads {
  24     fn run_pass<'a, 'tcx>(&self,
  25                           tcx: TyCtxt<'a, 'tcx, 'tcx>,
  26                           _src: MirSource,
  27                           mir: &mut Mir<'tcx>) {
  28         if tcx.sess.no_landing_pads() {
  29             return
  30         }
  31
  32         debug!("remove_noop_landing_pads({:?})", mir);
  33         self.remove_nop_landing_pads(mir);
  34     }
  35 }
  36
  37 impl RemoveNoopLandingPads {
  38     fn is_nop_landing_pad(&self, bb: BasicBlock, mir: &Mir, nop_landing_pads: &BitVector)
  39                           -> bool
  40     {
  41         for stmt in &mir[bb].statements {
  42             match stmt.kind {
  43                 StatementKind::StorageLive(_) |
  44                 StatementKind::StorageDead(_) |
  45                 StatementKind::EndRegion(_) |
  46                 StatementKind::Nop => {
  47                     // These are all nops in a landing pad (there's some
  48                     // borrowck interaction between EndRegion and storage
  49                     // instructions, but this should all run after borrowck).
  50                 }
  51
  52                 StatementKind::Assign(Place::Local(_), Rvalue::Use(_)) => {
  53                     // Writing to a local (e.g. a drop flag) does not
  54                     // turn a landing pad to a non-nop
  55                 }
  56
  57                 StatementKind::Assign(_, _) |
  58                 StatementKind::SetDiscriminant { .. } |
  59                 StatementKind::InlineAsm { .. } |
  60                 StatementKind::Validate { .. } => {
  61                     return false;
  62                 }
  63             }
  64         }
  65
  66         let terminator = mir[bb].terminator();
  67         match terminator.kind {
  68             TerminatorKind::Goto { .. } |
  69             TerminatorKind::Resume |
  70             TerminatorKind::SwitchInt { .. } |
  71             TerminatorKind::FalseEdges { .. } => {
  72                 terminator.successors().iter().all(|succ| {
  73                     nop_landing_pads.contains(succ.index())
  74                 })
  75             },
  76             TerminatorKind::GeneratorDrop |
  77             TerminatorKind::Yield { .. } |
  78             TerminatorKind::Return |
  79             TerminatorKind::Unreachable |
  80             TerminatorKind::Call { .. } |
  81             TerminatorKind::Assert { .. } |
  82             TerminatorKind::DropAndReplace { .. } |
  83             TerminatorKind::Drop { .. } => {
  84                 false
  85             }
  86         }
  87     }
  88
  89     fn remove_nop_landing_pads(&self, mir: &mut Mir) {
  90         // make sure there's a single resume block
  91         let resume_block = {
  92             let patch = MirPatch::new(mir);
  93             let resume_block = patch.resume_block();
  94             patch.apply(mir);
  95             resume_block
  96         };
  97         debug!("remove_noop_landing_pads: resume block is {:?}", resume_block);
  98
  99         let mut jumps_folded = 0;
 100         let mut landing_pads_removed = 0;
 101         let mut nop_landing_pads = BitVector::new(mir.basic_blocks().len());
 102
 103         // This is a post-order traversal, so that if A post-dominates B
 104         // then A will be visited before B.
 105         let postorder: Vec<_> = traversal::postorder(mir).map(|(bb, _)| bb).collect();
 106         for bb in postorder {
 107             debug!("  processing {:?}", bb);
 108             for target in mir[bb].terminator_mut().successors_mut() {
 109                 if *target != resume_block && nop_landing_pads.contains(target.index()) {
 110                     debug!("    folding noop jump to {:?} to resume block", target);
 111                     *target = resume_block;
 112                     jumps_folded += 1;
 113                 }
 114             }
 115
 116             match mir[bb].terminator_mut().unwind_mut() {
 117                 Some(unwind) => {
 118                     if *unwind == Some(resume_block) {
 119                         debug!("    removing noop landing pad");
 120                         jumps_folded -= 1;
 121                         landing_pads_removed += 1;
 122                         *unwind = None;
 123                     }
 124                 }
 125                 _ => {}
 126             }
 127
 128             let is_nop_landing_pad = self.is_nop_landing_pad(bb, mir, &nop_landing_pads);
 129             if is_nop_landing_pad {
 130                 nop_landing_pads.insert(bb.index());
 131             }
 132             debug!("    is_nop_landing_pad({:?}) = {}", bb, is_nop_landing_pad);
 133         }
 134
 135         debug!("removed {:?} jumps and {:?} landing pads", jumps_folded, landing_pads_removed);
 136     }
 137 }