src/librustc_mir_build/build/cfg.rs

   1 //! Routines for manipulating the control-flow graph.
   2
   3 use crate::build::CFG;
   4 use rustc::mir::*;
   5
   6 impl<'tcx> CFG<'tcx> {
   7     crate fn block_data(&self, blk: BasicBlock) -> &BasicBlockData<'tcx> {
   8         &self.basic_blocks[blk]
   9     }
  10
  11     crate fn block_data_mut(&mut self, blk: BasicBlock) -> &mut BasicBlockData<'tcx> {
  12         &mut self.basic_blocks[blk]
  13     }
  14
  15     // llvm.org/PR32488 makes this function use an excess of stack space. Mark
  16     // it as #[inline(never)] to keep rustc's stack use in check.
  17     #[inline(never)]
  18     crate fn start_new_block(&mut self) -> BasicBlock {
  19         self.basic_blocks.push(BasicBlockData::new(None))
  20     }
  21
  22     crate fn start_new_cleanup_block(&mut self) -> BasicBlock {
  23         let bb = self.start_new_block();
  24         self.block_data_mut(bb).is_cleanup = true;
  25         bb
  26     }
  27
  28     crate fn push(&mut self, block: BasicBlock, statement: Statement<'tcx>) {
  29         debug!("push({:?}, {:?})", block, statement);
  30         self.block_data_mut(block).statements.push(statement);
  31     }
  32
  33     crate fn push_assign(
  34         &mut self,
  35         block: BasicBlock,
  36         source_info: SourceInfo,
  37         place: &Place<'tcx>,
  38         rvalue: Rvalue<'tcx>,
  39     ) {
  40         self.push(
  41             block,
  42             Statement { source_info, kind: StatementKind::Assign(box (place.clone(), rvalue)) },
  43         );
  44     }
  45
  46     crate fn push_assign_constant(
  47         &mut self,
  48         block: BasicBlock,
  49         source_info: SourceInfo,
  50         temp: &Place<'tcx>,
  51         constant: Constant<'tcx>,
  52     ) {
  53         self.push_assign(block, source_info, temp, Rvalue::Use(Operand::Constant(box constant)));
  54     }
  55
  56     crate fn push_assign_unit(
  57         &mut self,
  58         block: BasicBlock,
  59         source_info: SourceInfo,
  60         place: &Place<'tcx>,
  61     ) {
  62         self.push_assign(
  63             block,
  64             source_info,
  65             place,
  66             Rvalue::Aggregate(box AggregateKind::Tuple, vec![]),
  67         );
  68     }
  69
  70     crate fn push_fake_read(
  71         &mut self,
  72         block: BasicBlock,
  73         source_info: SourceInfo,
  74         cause: FakeReadCause,
  75         place: Place<'tcx>,
  76     ) {
  77         let kind = StatementKind::FakeRead(cause, box place);
  78         let stmt = Statement { source_info, kind };
  79         self.push(block, stmt);
  80     }
  81
  82     crate fn terminate(
  83         &mut self,
  84         block: BasicBlock,
  85         source_info: SourceInfo,
  86         kind: TerminatorKind<'tcx>,
  87     ) {
  88         debug!("terminating block {:?} <- {:?}", block, kind);
  89         debug_assert!(
  90             self.block_data(block).terminator.is_none(),
  91             "terminate: block {:?}={:?} already has a terminator set",
  92             block,
  93             self.block_data(block)
  94         );
  95         self.block_data_mut(block).terminator = Some(Terminator { source_info, kind });
  96     }
  97
  98     /// In the `origin` block, push a `goto -> target` terminator.
  99     crate fn goto(&mut self, origin: BasicBlock, source_info: SourceInfo, target: BasicBlock) {
 100         self.terminate(origin, source_info, TerminatorKind::Goto { target })
 101     }
 102 }