src/librustc_mir/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     pub fn block_data(&self, blk: BasicBlock) -> &BasicBlockData<'tcx> {
   8         &self.basic_blocks[blk]
   9     }
  10
  11     pub 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     pub fn start_new_block(&mut self) -> BasicBlock {
  19         self.basic_blocks.push(BasicBlockData::new(None))
  20     }
  21
  22     pub 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     pub 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     pub fn push_assign(&mut self,
  34                        block: BasicBlock,
  35                        source_info: SourceInfo,
  36                        place: &Place<'tcx>,
  37                        rvalue: Rvalue<'tcx>) {
  38         self.push(block, Statement {
  39             source_info,
  40             kind: StatementKind::Assign(place.clone(), box rvalue)
  41         });
  42     }
  43
  44     pub fn push_assign_constant(&mut self,
  45                                 block: BasicBlock,
  46                                 source_info: SourceInfo,
  47                                 temp: &Place<'tcx>,
  48                                 constant: Constant<'tcx>) {
  49         self.push_assign(block, source_info, temp,
  50                          Rvalue::Use(Operand::Constant(box constant)));
  51     }
  52
  53     pub fn push_assign_unit(&mut self,
  54                             block: BasicBlock,
  55                             source_info: SourceInfo,
  56                             place: &Place<'tcx>) {
  57         self.push_assign(block, source_info, place, Rvalue::Aggregate(
  58             box AggregateKind::Tuple, vec![]
  59         ));
  60     }
  61
  62     pub fn terminate(&mut self,
  63                      block: BasicBlock,
  64                      source_info: SourceInfo,
  65                      kind: TerminatorKind<'tcx>) {
  66         debug!("terminating block {:?} <- {:?}", block, kind);
  67         debug_assert!(self.block_data(block).terminator.is_none(),
  68                       "terminate: block {:?}={:?} already has a terminator set",
  69                       block,
  70                       self.block_data(block));
  71         self.block_data_mut(block).terminator = Some(Terminator {
  72             source_info,
  73             kind,
  74         });
  75     }
  76 }