src/librustc_mir/transform/inline.rs

   1 // Copyright 2016 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 //! Inlining pass for MIR functions
  12
  13 use rustc::hir;
  14 use rustc::hir::TransFnAttrFlags;
  15 use rustc::hir::def_id::DefId;
  16
  17 use rustc_data_structures::bitvec::BitVector;
  18 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
  19
  20 use rustc::mir::*;
  21 use rustc::mir::visit::*;
  22 use rustc::ty::{self, Instance, Ty, TyCtxt};
  23 use rustc::ty::subst::{Subst,Substs};
  24
  25 use std::collections::VecDeque;
  26 use std::iter;
  27 use transform::{MirPass, MirSource};
  28 use super::simplify::{remove_dead_blocks, CfgSimplifier};
  29
  30 use syntax::{attr};
  31 use rustc_target::spec::abi::Abi;
  32
  33 const DEFAULT_THRESHOLD: usize = 50;
  34 const HINT_THRESHOLD: usize = 100;
  35
  36 const INSTR_COST: usize = 5;
  37 const CALL_PENALTY: usize = 25;
  38
  39 const UNKNOWN_SIZE_COST: usize = 10;
  40
  41 pub struct Inline;
  42
  43 #[derive(Copy, Clone, Debug)]
  44 struct CallSite<'tcx> {
  45     callee: DefId,
  46     substs: &'tcx Substs<'tcx>,
  47     bb: BasicBlock,
  48     location: SourceInfo,
  49 }
  50
  51 impl MirPass for Inline {
  52     fn run_pass<'a, 'tcx>(&self,
  53                           tcx: TyCtxt<'a, 'tcx, 'tcx>,
  54                           source: MirSource,
  55                           mir: &mut Mir<'tcx>) {
  56         if tcx.sess.opts.debugging_opts.mir_opt_level >= 2 {
  57             Inliner { tcx, source }.run_pass(mir);
  58         }
  59     }
  60 }
  61
  62 struct Inliner<'a, 'tcx: 'a> {
  63     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  64     source: MirSource,
  65 }
  66
  67 impl<'a, 'tcx> Inliner<'a, 'tcx> {
  68     fn run_pass(&self, caller_mir: &mut Mir<'tcx>) {
  69         // Keep a queue of callsites to try inlining on. We take
  70         // advantage of the fact that queries detect cycles here to
  71         // allow us to try and fetch the fully optimized MIR of a
  72         // call; if it succeeds, we can inline it and we know that
  73         // they do not call us.  Otherwise, we just don't try to
  74         // inline.
  75         //
  76         // We use a queue so that we inline "broadly" before we inline
  77         // in depth. It is unclear if this is the best heuristic,
  78         // really, but that's true of all the heuristics in this
  79         // file. =)
  80
  81         let mut callsites = VecDeque::new();
  82
  83         let param_env = self.tcx.param_env(self.source.def_id);
  84
  85         // Only do inlining into fn bodies.
  86         let id = self.tcx.hir.as_local_node_id(self.source.def_id).unwrap();
  87         let body_owner_kind = self.tcx.hir.body_owner_kind(id);
  88         if let (hir::BodyOwnerKind::Fn, None) = (body_owner_kind, self.source.promoted) {
  89
  90             for (bb, bb_data) in caller_mir.basic_blocks().iter_enumerated() {
  91                 // Don't inline calls that are in cleanup blocks.
  92                 if bb_data.is_cleanup { continue; }
  93
  94                 // Only consider direct calls to functions
  95                 let terminator = bb_data.terminator();
  96                 if let TerminatorKind::Call {
  97                     func: Operand::Constant(ref f), .. } = terminator.kind {
  98                         if let ty::TyFnDef(callee_def_id, substs) = f.ty.sty {
  99                             if let Some(instance) = Instance::resolve(self.tcx,
 100                                                                       param_env,
 101                                                                       callee_def_id,
 102                                                                       substs) {
 103                                 callsites.push_back(CallSite {
 104                                     callee: instance.def_id(),
 105                                     substs: instance.substs,
 106                                     bb,
 107                                     location: terminator.source_info
 108                                 });
 109                             }
 110                         }
 111                     }
 112             }
 113         } else {
 114             return;
 115         }
 116
 117         let mut local_change;
 118         let mut changed = false;
 119
 120         loop {
 121             local_change = false;
 122             while let Some(callsite) = callsites.pop_front() {
 123                 debug!("checking whether to inline callsite {:?}", callsite);
 124                 if !self.tcx.is_mir_available(callsite.callee) {
 125                     debug!("checking whether to inline callsite {:?} - MIR unavailable", callsite);
 126                     continue;
 127                 }
 128
 129                 let callee_mir = match self.tcx.try_get_query::<ty::queries::optimized_mir>(
 130                                                                            callsite.location.span,
 131                                                                            callsite.callee) {
 132                     Ok(callee_mir) if self.should_inline(callsite, callee_mir) => {
 133                         self.tcx.subst_and_normalize_erasing_regions(
 134                             &callsite.substs,
 135                             param_env,
 136                             callee_mir,
 137                         )
 138                     }
 139                     Ok(_) => continue,
 140
 141                     Err(mut bug) => {
 142                         // FIXME(#43542) shouldn't have to cancel an error
 143                         bug.cancel();
 144                         continue
 145                     }
 146                 };
 147
 148                 let start = caller_mir.basic_blocks().len();
 149                 debug!("attempting to inline callsite {:?} - mir={:?}", callsite, callee_mir);
 150                 if !self.inline_call(callsite, caller_mir, callee_mir) {
 151                     debug!("attempting to inline callsite {:?} - failure", callsite);
 152                     continue;
 153                 }
 154                 debug!("attempting to inline callsite {:?} - success", callsite);
 155
 156                 // Add callsites from inlined function
 157                 for (bb, bb_data) in caller_mir.basic_blocks().iter_enumerated().skip(start) {
 158                     // Only consider direct calls to functions
 159                     let terminator = bb_data.terminator();
 160                     if let TerminatorKind::Call {
 161                         func: Operand::Constant(ref f), .. } = terminator.kind {
 162                         if let ty::TyFnDef(callee_def_id, substs) = f.ty.sty {
 163                             // Don't inline the same function multiple times.
 164                             if callsite.callee != callee_def_id {
 165                                 callsites.push_back(CallSite {
 166                                     callee: callee_def_id,
 167                                     substs,
 168                                     bb,
 169                                     location: terminator.source_info
 170                                 });
 171                             }
 172                         }
 173                     }
 174                 }
 175
 176                 local_change = true;
 177                 changed = true;
 178             }
 179
 180             if !local_change {
 181                 break;
 182             }
 183         }
 184
 185         // Simplify if we inlined anything.
 186         if changed {
 187             debug!("Running simplify cfg on {:?}", self.source);
 188             CfgSimplifier::new(caller_mir).simplify();
 189             remove_dead_blocks(caller_mir);
 190         }
 191     }
 192
 193     fn should_inline(&self,
 194                      callsite: CallSite<'tcx>,
 195                      callee_mir: &Mir<'tcx>)
 196                      -> bool
 197     {
 198         debug!("should_inline({:?})", callsite);
 199         let tcx = self.tcx;
 200
 201         // Don't inline closures that have captures
 202         // FIXME: Handle closures better
 203         if callee_mir.upvar_decls.len() > 0 {
 204             debug!("    upvar decls present - not inlining");
 205             return false;
 206         }
 207
 208         // Cannot inline generators which haven't been transformed yet
 209         if callee_mir.yield_ty.is_some() {
 210             debug!("    yield ty present - not inlining");
 211             return false;
 212         }
 213
 214         // Do not inline {u,i}128 lang items, trans const eval depends
 215         // on detecting calls to these lang items and intercepting them
 216         if tcx.is_binop_lang_item(callsite.callee).is_some() {
 217             debug!("    not inlining 128bit integer lang item");
 218             return false;
 219         }
 220
 221         let trans_fn_attrs = tcx.trans_fn_attrs(callsite.callee);
 222
 223         let hinted = match trans_fn_attrs.inline {
 224             // Just treat inline(always) as a hint for now,
 225             // there are cases that prevent inlining that we
 226             // need to check for first.
 227             attr::InlineAttr::Always => true,
 228             attr::InlineAttr::Never => {
 229                 debug!("#[inline(never)] present - not inlining");
 230                 return false
 231             }
 232             attr::InlineAttr::Hint => true,
 233             attr::InlineAttr::None => false,
 234         };
 235
 236         // Only inline local functions if they would be eligible for cross-crate
 237         // inlining. This is to ensure that the final crate doesn't have MIR that
 238         // reference unexported symbols
 239         if callsite.callee.is_local() {
 240             if callsite.substs.types().count() == 0 && !hinted {
 241                 debug!("    callee is an exported function - not inlining");
 242                 return false;
 243             }
 244         }
 245
 246         let mut threshold = if hinted {
 247             HINT_THRESHOLD
 248         } else {
 249             DEFAULT_THRESHOLD
 250         };
 251
 252         // Significantly lower the threshold for inlining cold functions
 253         if trans_fn_attrs.flags.contains(TransFnAttrFlags::COLD) {
 254             threshold /= 5;
 255         }
 256
 257         // Give a bonus functions with a small number of blocks,
 258         // We normally have two or three blocks for even
 259         // very small functions.
 260         if callee_mir.basic_blocks().len() <= 3 {
 261             threshold += threshold / 4;
 262         }
 263         debug!("    final inline threshold = {}", threshold);
 264
 265         // FIXME: Give a bonus to functions with only a single caller
 266
 267         let param_env = tcx.param_env(self.source.def_id);
 268
 269         let mut first_block = true;
 270         let mut cost = 0;
 271
 272         // Traverse the MIR manually so we can account for the effects of
 273         // inlining on the CFG.
 274         let mut work_list = vec![START_BLOCK];
 275         let mut visited = BitVector::new(callee_mir.basic_blocks().len());
 276         while let Some(bb) = work_list.pop() {
 277             if !visited.insert(bb.index()) { continue; }
 278             let blk = &callee_mir.basic_blocks()[bb];
 279
 280             for stmt in &blk.statements {
 281                 // Don't count StorageLive/StorageDead in the inlining cost.
 282                 match stmt.kind {
 283                     StatementKind::StorageLive(_) |
 284                     StatementKind::StorageDead(_) |
 285                     StatementKind::Nop => {}
 286                     _ => cost += INSTR_COST
 287                 }
 288             }
 289             let term = blk.terminator();
 290             let mut is_drop = false;
 291             match term.kind {
 292                 TerminatorKind::Drop { ref location, target, unwind } |
 293                 TerminatorKind::DropAndReplace { ref location, target, unwind, .. } => {
 294                     is_drop = true;
 295                     work_list.push(target);
 296                     // If the location doesn't actually need dropping, treat it like
 297                     // a regular goto.
 298                     let ty = location.ty(callee_mir, tcx).subst(tcx, callsite.substs);
 299                     let ty = ty.to_ty(tcx);
 300                     if ty.needs_drop(tcx, param_env) {
 301                         cost += CALL_PENALTY;
 302                         if let Some(unwind) = unwind {
 303                             work_list.push(unwind);
 304                         }
 305                     } else {
 306                         cost += INSTR_COST;
 307                     }
 308                 }
 309
 310                 TerminatorKind::Unreachable |
 311                 TerminatorKind::Call { destination: None, .. } if first_block => {
 312                     // If the function always diverges, don't inline
 313                     // unless the cost is zero
 314                     threshold = 0;
 315                 }
 316
 317                 TerminatorKind::Call {func: Operand::Constant(ref f), .. } => {
 318                     if let ty::TyFnDef(def_id, _) = f.ty.sty {
 319                         // Don't give intrinsics the extra penalty for calls
 320                         let f = tcx.fn_sig(def_id);
 321                         if f.abi() == Abi::RustIntrinsic || f.abi() == Abi::PlatformIntrinsic {
 322                             cost += INSTR_COST;
 323                         } else {
 324                             cost += CALL_PENALTY;
 325                         }
 326                     }
 327                 }
 328                 TerminatorKind::Assert { .. } => cost += CALL_PENALTY,
 329                 _ => cost += INSTR_COST
 330             }
 331
 332             if !is_drop {
 333                 for &succ in term.successors() {
 334                     work_list.push(succ);
 335                 }
 336             }
 337
 338             first_block = false;
 339         }
 340
 341         // Count up the cost of local variables and temps, if we know the size
 342         // use that, otherwise we use a moderately-large dummy cost.
 343
 344         let ptr_size = tcx.data_layout.pointer_size.bytes();
 345
 346         for v in callee_mir.vars_and_temps_iter() {
 347             let v = &callee_mir.local_decls[v];
 348             let ty = v.ty.subst(tcx, callsite.substs);
 349             // Cost of the var is the size in machine-words, if we know
 350             // it.
 351             if let Some(size) = type_size_of(tcx, param_env.clone(), ty) {
 352                 cost += (size / ptr_size) as usize;
 353             } else {
 354                 cost += UNKNOWN_SIZE_COST;
 355             }
 356         }
 357
 358         if let attr::InlineAttr::Always = trans_fn_attrs.inline {
 359             debug!("INLINING {:?} because inline(always) [cost={}]", callsite, cost);
 360             true
 361         } else {
 362             if cost <= threshold {
 363                 debug!("INLINING {:?} [cost={} <= threshold={}]", callsite, cost, threshold);
 364                 true
 365             } else {
 366                 debug!("NOT inlining {:?} [cost={} > threshold={}]", callsite, cost, threshold);
 367                 false
 368             }
 369         }
 370     }
 371
 372     fn inline_call(&self,
 373                    callsite: CallSite<'tcx>,
 374                    caller_mir: &mut Mir<'tcx>,
 375                    mut callee_mir: Mir<'tcx>) -> bool {
 376         let terminator = caller_mir[callsite.bb].terminator.take().unwrap();
 377         match terminator.kind {
 378             // FIXME: Handle inlining of diverging calls
 379             TerminatorKind::Call { args, destination: Some(destination), cleanup, .. } => {
 380                 debug!("Inlined {:?} into {:?}", callsite.callee, self.source);
 381
 382                 let mut local_map = IndexVec::with_capacity(callee_mir.local_decls.len());
 383                 let mut scope_map = IndexVec::with_capacity(callee_mir.visibility_scopes.len());
 384                 let mut promoted_map = IndexVec::with_capacity(callee_mir.promoted.len());
 385
 386                 for mut scope in callee_mir.visibility_scopes.iter().cloned() {
 387                     if scope.parent_scope.is_none() {
 388                         scope.parent_scope = Some(callsite.location.scope);
 389                         scope.span = callee_mir.span;
 390                     }
 391
 392                     scope.span = callsite.location.span;
 393
 394                     let idx = caller_mir.visibility_scopes.push(scope);
 395                     scope_map.push(idx);
 396                 }
 397
 398                 for loc in callee_mir.vars_and_temps_iter() {
 399                     let mut local = callee_mir.local_decls[loc].clone();
 400
 401                     local.source_info.scope = scope_map[local.source_info.scope];
 402                     local.source_info.span = callsite.location.span;
 403
 404                     let idx = caller_mir.local_decls.push(local);
 405                     local_map.push(idx);
 406                 }
 407
 408                 for p in callee_mir.promoted.iter().cloned() {
 409                     let idx = caller_mir.promoted.push(p);
 410                     promoted_map.push(idx);
 411                 }
 412
 413                 // If the call is something like `a[*i] = f(i)`, where
 414                 // `i : &mut usize`, then just duplicating the `a[*i]`
 415                 // Place could result in two different locations if `f`
 416                 // writes to `i`. To prevent this we need to create a temporary
 417                 // borrow of the place and pass the destination as `*temp` instead.
 418                 fn dest_needs_borrow(place: &Place) -> bool {
 419                     match *place {
 420                         Place::Projection(ref p) => {
 421                             match p.elem {
 422                                 ProjectionElem::Deref |
 423                                 ProjectionElem::Index(_) => true,
 424                                 _ => dest_needs_borrow(&p.base)
 425                             }
 426                         }
 427                         // Static variables need a borrow because the callee
 428                         // might modify the same static.
 429                         Place::Static(_) => true,
 430                         _ => false
 431                     }
 432                 }
 433
 434                 let dest = if dest_needs_borrow(&destination.0) {
 435                     debug!("Creating temp for return destination");
 436                     let dest = Rvalue::Ref(
 437                         self.tcx.types.re_erased,
 438                         BorrowKind::Mut { allow_two_phase_borrow: false },
 439                         destination.0);
 440
 441                     let ty = dest.ty(caller_mir, self.tcx);
 442
 443                     let temp = LocalDecl::new_temp(ty, callsite.location.span);
 444
 445                     let tmp = caller_mir.local_decls.push(temp);
 446                     let tmp = Place::Local(tmp);
 447
 448                     let stmt = Statement {
 449                         source_info: callsite.location,
 450                         kind: StatementKind::Assign(tmp.clone(), dest)
 451                     };
 452                     caller_mir[callsite.bb]
 453                         .statements.push(stmt);
 454                     tmp.deref()
 455                 } else {
 456                     destination.0
 457                 };
 458
 459                 let return_block = destination.1;
 460
 461                 // Copy the arguments if needed.
 462                 let args: Vec<_> = self.make_call_args(args, &callsite, caller_mir);
 463
 464                 let bb_len = caller_mir.basic_blocks().len();
 465                 let mut integrator = Integrator {
 466                     block_idx: bb_len,
 467                     args: &args,
 468                     local_map,
 469                     scope_map,
 470                     promoted_map,
 471                     _callsite: callsite,
 472                     destination: dest,
 473                     return_block,
 474                     cleanup_block: cleanup,
 475                     in_cleanup_block: false
 476                 };
 477
 478
 479                 for (bb, mut block) in callee_mir.basic_blocks_mut().drain_enumerated(..) {
 480                     integrator.visit_basic_block_data(bb, &mut block);
 481                     caller_mir.basic_blocks_mut().push(block);
 482                 }
 483
 484                 let terminator = Terminator {
 485                     source_info: callsite.location,
 486                     kind: TerminatorKind::Goto { target: BasicBlock::new(bb_len) }
 487                 };
 488
 489                 caller_mir[callsite.bb].terminator = Some(terminator);
 490
 491                 true
 492             }
 493             kind => {
 494                 caller_mir[callsite.bb].terminator = Some(Terminator {
 495                     source_info: terminator.source_info,
 496                     kind,
 497                 });
 498                 false
 499             }
 500         }
 501     }
 502
 503     fn make_call_args(
 504         &self,
 505         args: Vec<Operand<'tcx>>,
 506         callsite: &CallSite<'tcx>,
 507         caller_mir: &mut Mir<'tcx>,
 508     ) -> Vec<Local> {
 509         let tcx = self.tcx;
 510
 511         // There is a bit of a mismatch between the *caller* of a closure and the *callee*.
 512         // The caller provides the arguments wrapped up in a tuple:
 513         //
 514         //     tuple_tmp = (a, b, c)
 515         //     Fn::call(closure_ref, tuple_tmp)
 516         //
 517         // meanwhile the closure body expects the arguments (here, `a`, `b`, and `c`)
 518         // as distinct arguments. (This is the "rust-call" ABI hack.) Normally, trans has
 519         // the job of unpacking this tuple. But here, we are trans. =) So we want to create
 520         // a vector like
 521         //
 522         //     [closure_ref, tuple_tmp.0, tuple_tmp.1, tuple_tmp.2]
 523         //
 524         // Except for one tiny wrinkle: we don't actually want `tuple_tmp.0`. It's more convenient
 525         // if we "spill" that into *another* temporary, so that we can map the argument
 526         // variable in the callee MIR directly to an argument variable on our side.
 527         // So we introduce temporaries like:
 528         //
 529         //     tmp0 = tuple_tmp.0
 530         //     tmp1 = tuple_tmp.1
 531         //     tmp2 = tuple_tmp.2
 532         //
 533         // and the vector is `[closure_ref, tmp0, tmp1, tmp2]`.
 534         if tcx.is_closure(callsite.callee) {
 535             let mut args = args.into_iter();
 536             let self_ = self.create_temp_if_necessary(args.next().unwrap(), callsite, caller_mir);
 537             let tuple = self.create_temp_if_necessary(args.next().unwrap(), callsite, caller_mir);
 538             assert!(args.next().is_none());
 539
 540             let tuple = Place::Local(tuple);
 541             let tuple_tys = if let ty::TyTuple(s) = tuple.ty(caller_mir, tcx).to_ty(tcx).sty {
 542                 s
 543             } else {
 544                 bug!("Closure arguments are not passed as a tuple");
 545             };
 546
 547             // The `closure_ref` in our example above.
 548             let closure_ref_arg = iter::once(self_);
 549
 550             // The `tmp0`, `tmp1`, and `tmp2` in our example abonve.
 551             let tuple_tmp_args =
 552                 tuple_tys.iter().enumerate().map(|(i, ty)| {
 553                     // This is e.g. `tuple_tmp.0` in our example above.
 554                     let tuple_field = Operand::Move(tuple.clone().field(Field::new(i), ty));
 555
 556                     // Spill to a local to make e.g. `tmp0`.
 557                     self.create_temp_if_necessary(tuple_field, callsite, caller_mir)
 558                 });
 559
 560             closure_ref_arg.chain(tuple_tmp_args).collect()
 561         } else {
 562             args.into_iter()
 563                 .map(|a| self.create_temp_if_necessary(a, callsite, caller_mir))
 564                 .collect()
 565         }
 566     }
 567
 568     /// If `arg` is already a temporary, returns it. Otherwise, introduces a fresh
 569     /// temporary `T` and an instruction `T = arg`, and returns `T`.
 570     fn create_temp_if_necessary(
 571         &self,
 572         arg: Operand<'tcx>,
 573         callsite: &CallSite<'tcx>,
 574         caller_mir: &mut Mir<'tcx>,
 575     ) -> Local {
 576         // FIXME: Analysis of the usage of the arguments to avoid
 577         // unnecessary temporaries.
 578
 579         if let Operand::Move(Place::Local(local)) = arg {
 580             if caller_mir.local_kind(local) == LocalKind::Temp {
 581                 // Reuse the operand if it's a temporary already
 582                 return local;
 583             }
 584         }
 585
 586         debug!("Creating temp for argument {:?}", arg);
 587         // Otherwise, create a temporary for the arg
 588         let arg = Rvalue::Use(arg);
 589
 590         let ty = arg.ty(caller_mir, self.tcx);
 591
 592         let arg_tmp = LocalDecl::new_temp(ty, callsite.location.span);
 593         let arg_tmp = caller_mir.local_decls.push(arg_tmp);
 594
 595         let stmt = Statement {
 596             source_info: callsite.location,
 597             kind: StatementKind::Assign(Place::Local(arg_tmp), arg),
 598         };
 599         caller_mir[callsite.bb].statements.push(stmt);
 600         arg_tmp
 601     }
 602 }
 603
 604 fn type_size_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 605                           param_env: ty::ParamEnv<'tcx>,
 606                           ty: Ty<'tcx>) -> Option<u64> {
 607     tcx.layout_of(param_env.and(ty)).ok().map(|layout| layout.size.bytes())
 608 }
 609
 610 /**
 611  * Integrator.
 612  *
 613  * Integrates blocks from the callee function into the calling function.
 614  * Updates block indices, references to locals and other control flow
 615  * stuff.
 616  */
 617 struct Integrator<'a, 'tcx: 'a> {
 618     block_idx: usize,
 619     args: &'a [Local],
 620     local_map: IndexVec<Local, Local>,
 621     scope_map: IndexVec<VisibilityScope, VisibilityScope>,
 622     promoted_map: IndexVec<Promoted, Promoted>,
 623     _callsite: CallSite<'tcx>,
 624     destination: Place<'tcx>,
 625     return_block: BasicBlock,
 626     cleanup_block: Option<BasicBlock>,
 627     in_cleanup_block: bool,
 628 }
 629
 630 impl<'a, 'tcx> Integrator<'a, 'tcx> {
 631     fn update_target(&self, tgt: BasicBlock) -> BasicBlock {
 632         let new = BasicBlock::new(tgt.index() + self.block_idx);
 633         debug!("Updating target `{:?}`, new: `{:?}`", tgt, new);
 634         new
 635     }
 636 }
 637
 638 impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {
 639     fn visit_local(&mut self,
 640                    local: &mut Local,
 641                    _ctxt: PlaceContext<'tcx>,
 642                    _location: Location) {
 643         if *local == RETURN_PLACE {
 644             match self.destination {
 645                 Place::Local(l) => {
 646                     *local = l;
 647                     return;
 648                 },
 649                 ref place => bug!("Return place is {:?}, not local", place)
 650             }
 651         }
 652         let idx = local.index() - 1;
 653         if idx < self.args.len() {
 654             *local = self.args[idx];
 655             return;
 656         }
 657         *local = self.local_map[Local::new(idx - self.args.len())];
 658     }
 659
 660     fn visit_place(&mut self,
 661                     place: &mut Place<'tcx>,
 662                     _ctxt: PlaceContext<'tcx>,
 663                     _location: Location) {
 664         if let Place::Local(RETURN_PLACE) = *place {
 665             // Return pointer; update the place itself
 666             *place = self.destination.clone();
 667         } else {
 668             self.super_place(place, _ctxt, _location);
 669         }
 670     }
 671
 672     fn visit_basic_block_data(&mut self, block: BasicBlock, data: &mut BasicBlockData<'tcx>) {
 673         self.in_cleanup_block = data.is_cleanup;
 674         self.super_basic_block_data(block, data);
 675         self.in_cleanup_block = false;
 676     }
 677
 678     fn visit_terminator_kind(&mut self, block: BasicBlock,
 679                              kind: &mut TerminatorKind<'tcx>, loc: Location) {
 680         self.super_terminator_kind(block, kind, loc);
 681
 682         match *kind {
 683             TerminatorKind::GeneratorDrop |
 684             TerminatorKind::Yield { .. } => bug!(),
 685             TerminatorKind::Goto { ref mut target} => {
 686                 *target = self.update_target(*target);
 687             }
 688             TerminatorKind::SwitchInt { ref mut targets, .. } => {
 689                 for tgt in targets {
 690                     *tgt = self.update_target(*tgt);
 691                 }
 692             }
 693             TerminatorKind::Drop { ref mut target, ref mut unwind, .. } |
 694             TerminatorKind::DropAndReplace { ref mut target, ref mut unwind, .. } => {
 695                 *target = self.update_target(*target);
 696                 if let Some(tgt) = *unwind {
 697                     *unwind = Some(self.update_target(tgt));
 698                 } else if !self.in_cleanup_block {
 699                     // Unless this drop is in a cleanup block, add an unwind edge to
 700                     // the orignal call's cleanup block
 701                     *unwind = self.cleanup_block;
 702                 }
 703             }
 704             TerminatorKind::Call { ref mut destination, ref mut cleanup, .. } => {
 705                 if let Some((_, ref mut tgt)) = *destination {
 706                     *tgt = self.update_target(*tgt);
 707                 }
 708                 if let Some(tgt) = *cleanup {
 709                     *cleanup = Some(self.update_target(tgt));
 710                 } else if !self.in_cleanup_block {
 711                     // Unless this call is in a cleanup block, add an unwind edge to
 712                     // the orignal call's cleanup block
 713                     *cleanup = self.cleanup_block;
 714                 }
 715             }
 716             TerminatorKind::Assert { ref mut target, ref mut cleanup, .. } => {
 717                 *target = self.update_target(*target);
 718                 if let Some(tgt) = *cleanup {
 719                     *cleanup = Some(self.update_target(tgt));
 720                 } else if !self.in_cleanup_block {
 721                     // Unless this assert is in a cleanup block, add an unwind edge to
 722                     // the orignal call's cleanup block
 723                     *cleanup = self.cleanup_block;
 724                 }
 725             }
 726             TerminatorKind::Return => {
 727                 *kind = TerminatorKind::Goto { target: self.return_block };
 728             }
 729             TerminatorKind::Resume => {
 730                 if let Some(tgt) = self.cleanup_block {
 731                     *kind = TerminatorKind::Goto { target: tgt }
 732                 }
 733             }
 734             TerminatorKind::Abort => { }
 735             TerminatorKind::Unreachable => { }
 736             TerminatorKind::FalseEdges { ref mut real_target, ref mut imaginary_targets } => {
 737                 *real_target = self.update_target(*real_target);
 738                 for target in imaginary_targets {
 739                     *target = self.update_target(*target);
 740                 }
 741             }
 742             TerminatorKind::FalseUnwind { real_target: _ , unwind: _ } =>
 743                 // see the ordering of passes in the optimized_mir query.
 744                 bug!("False unwinds should have been removed before inlining")
 745         }
 746     }
 747
 748     fn visit_visibility_scope(&mut self, scope: &mut VisibilityScope) {
 749         *scope = self.scope_map[*scope];
 750     }
 751
 752     fn visit_literal(&mut self, literal: &mut Literal<'tcx>, loc: Location) {
 753         if let Literal::Promoted { ref mut index } = *literal {
 754             if let Some(p) = self.promoted_map.get(*index).cloned() {
 755                 *index = p;
 756             }
 757         } else {
 758             self.super_literal(literal, loc);
 759         }
 760     }
 761 }