Skip to main content

rustc_mir_build/builder/
cfg.rs

1//! Routines for manipulating the control-flow graph.
2
3use itertools::Either;
4use rustc_attr_ir::UnrollAttr;
5use rustc_data_structures::thin_vec::ThinVec;
6use rustc_index::IndexVec;
7use rustc_middle::mir::*;
8use rustc_middle::ty::TyCtxt;
9use tracing::debug;
10
11use crate::builder::{CFG, CFGBlock, UnterminatedBlockData};
12
13impl<'tcx> CFG<'tcx> {
14    fn block_data(&self, blk: BasicBlock) -> &CFGBlock<'tcx> {
15        &self.basic_blocks[blk]
16    }
17
18    fn block_data_mut(&mut self, blk: BasicBlock) -> &mut CFGBlock<'tcx> {
19        &mut self.basic_blocks[blk]
20    }
21
22    pub(crate) fn assert_terminator(&self, bb: BasicBlock) -> &Terminator<'tcx> {
23        self.block_data(bb).as_ref().left().unwrap().terminator()
24    }
25
26    pub(crate) fn assert_terminator_mut(&mut self, bb: BasicBlock) -> &mut Terminator<'tcx> {
27        self.block_data_mut(bb).as_mut().left().unwrap().terminator_mut()
28    }
29
30    pub(crate) fn statements(&self, blk: BasicBlock) -> &[Statement<'tcx>] {
31        match &self.basic_blocks[blk] {
32            CFGBlock::Left(bb) => &bb.statements,
33            CFGBlock::Right(bb) => &bb.statements,
34        }
35    }
36
37    pub(crate) fn statements_mut(&mut self, blk: BasicBlock) -> &mut Vec<Statement<'tcx>> {
38        match &mut self.basic_blocks[blk] {
39            CFGBlock::Left(bb) => &mut bb.statements,
40            CFGBlock::Right(bb) => &mut bb.statements,
41        }
42    }
43
44    pub(crate) fn into_basic_blocks(self) -> IndexVec<BasicBlock, BasicBlockData<'tcx>> {
45        // CFGBlock has the same layout as BasicBlockData, so this call should be
46        // almost no-op (we have a specialization for reusing the allocation in this case).
47        self.basic_blocks.into_iter().map(|bb| bb.left().unwrap()).collect()
48    }
49
50    // llvm.org/PR32488 makes this function use an excess of stack space. Mark
51    // it as #[inline(never)] to keep rustc's stack use in check.
52    #[inline(never)]
53    pub(crate) fn start_new_block(&mut self) -> BasicBlock {
54        self.basic_blocks.push(Either::Right(UnterminatedBlockData::new(Vec::new(), false)))
55    }
56
57    pub(crate) fn start_new_cleanup_block(&mut self) -> BasicBlock {
58        self.basic_blocks.push(Either::Right(UnterminatedBlockData::new(Vec::new(), true)))
59    }
60
61    pub(crate) fn push(&mut self, block: BasicBlock, statement: Statement<'tcx>) {
62        {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/cfg.rs:62",
                        "rustc_mir_build::builder::cfg", ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/cfg.rs"),
                        ::tracing_core::__macro_support::Option::Some(62u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::cfg"),
                        ::tracing_core::field::FieldSet::new(&["message"],
                            ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("push({0:?}, {1:?})",
                                                    block, statement) as &dyn ::tracing::field::Value))])
            });
    } else { ; }
};debug!("push({:?}, {:?})", block, statement);
63        self.statements_mut(block).push(statement);
64    }
65
66    pub(crate) fn push_assign(
67        &mut self,
68        block: BasicBlock,
69        source_info: SourceInfo,
70        place: Place<'tcx>,
71        rvalue: Rvalue<'tcx>,
72    ) {
73        self.push(
74            block,
75            Statement::new(source_info, StatementKind::Assign(Box::new((place, rvalue)))),
76        );
77    }
78
79    pub(crate) fn push_assign_constant(
80        &mut self,
81        block: BasicBlock,
82        source_info: SourceInfo,
83        temp: Place<'tcx>,
84        constant: ConstOperand<'tcx>,
85    ) {
86        self.push_assign(
87            block,
88            source_info,
89            temp,
90            Rvalue::Use(Operand::Constant(Box::new(constant)), WithRetag::Yes),
91        );
92    }
93
94    pub(crate) fn push_assign_unit(
95        &mut self,
96        block: BasicBlock,
97        source_info: SourceInfo,
98        place: Place<'tcx>,
99        tcx: TyCtxt<'tcx>,
100    ) {
101        self.push_assign(
102            block,
103            source_info,
104            place,
105            Rvalue::Use(
106                Operand::zero_sized_constant(tcx.types.unit, source_info.span),
107                WithRetag::Yes,
108            ),
109        );
110    }
111
112    pub(crate) fn push_fake_read(
113        &mut self,
114        block: BasicBlock,
115        source_info: SourceInfo,
116        cause: FakeReadCause,
117        place: Place<'tcx>,
118    ) {
119        let kind = StatementKind::FakeRead(Box::new((cause, place)));
120        let stmt = Statement::new(source_info, kind);
121        self.push(block, stmt);
122    }
123
124    pub(crate) fn push_place_mention(
125        &mut self,
126        block: BasicBlock,
127        source_info: SourceInfo,
128        place: Place<'tcx>,
129    ) {
130        let kind = StatementKind::PlaceMention(Box::new(place));
131        let stmt = Statement::new(source_info, kind);
132        self.push(block, stmt);
133    }
134
135    pub(crate) fn terminate(
136        &mut self,
137        block: BasicBlock,
138        source_info: SourceInfo,
139        kind: TerminatorKind<'tcx>,
140    ) -> &mut Terminator<'tcx> {
141        {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/cfg.rs:141",
                        "rustc_mir_build::builder::cfg", ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/cfg.rs"),
                        ::tracing_core::__macro_support::Option::Some(141u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::cfg"),
                        ::tracing_core::field::FieldSet::new(&["message"],
                            ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("terminating block {0:?} <- {1:?}",
                                                    block, kind) as &dyn ::tracing::field::Value))])
            });
    } else { ; }
};debug!("terminating block {:?} <- {:?}", block, kind);
142        if true {
    if !self.block_data(block).is_right() {
        {
            ::core::panicking::panic_fmt(format_args!("terminate: block {0:?}={1:?} already has a terminator set",
                    block, self.block_data(block)));
        }
    };
};debug_assert!(
143            self.block_data(block).is_right(),
144            "terminate: block {:?}={:?} already has a terminator set",
145            block,
146            self.block_data(block)
147        );
148        let UnterminatedBlockData { statements, is_cleanup } =
149            self.block_data_mut(block).as_mut().right().unwrap();
150
151        *self.block_data_mut(block) = Either::Left(BasicBlockData::new_stmts(
152            std::mem::take(statements),
153            Terminator { source_info, kind },
154            *is_cleanup,
155        ));
156        self.block_data_mut(block).as_mut().left().unwrap().terminator_mut()
157    }
158
159    /// In the `origin` block, push a `goto -> target` terminator.
160    pub(crate) fn goto(
161        &mut self,
162        origin: BasicBlock,
163        source_info: SourceInfo,
164        target: BasicBlock,
165    ) -> &mut Terminator<'tcx> {
166        self.goto_with_hints(origin, source_info, target, ThinVec::new())
167    }
168
169    #[inline(always)]
170    pub(crate) fn goto_with_hints(
171        &mut self,
172        origin: BasicBlock,
173        source_info: SourceInfo,
174        target: BasicBlock,
175        loop_hint_attrs: ThinVec<UnrollAttr>,
176    ) -> &mut Terminator<'tcx> {
177        self.terminate(origin, source_info, TerminatorKind::Goto { target, loop_hint_attrs })
178    }
179}