Add cf ("control-flow") module and split cfg into cf::unstructured vs cf::structurize.

Author: eddyb

src/cfgssa.rs renamed to src/cf/cfgssa.rs

@@ -0,0 +1,25 @@
+//! Control-flow abstractions and passes.
+//
+// FIXME(eddyb) consider moving more definitions into this module.
+
+use crate::spv;
+
+// NOTE(eddyb) all the modules are declared here, but they're documented "inside"
+// (i.e. using inner doc comments).
+pub mod cfgssa;
+pub mod structurize;
+pub mod unstructured;
+
+#[derive(Clone)]
+pub enum SelectionKind {
+    /// Two-case selection based on boolean condition, i.e. `if`-`else`, with
+    /// the two cases being "then" and "else" (in that order).
+    BoolCond,
+
+    SpvInst(spv::Inst),
+}
+
+#[derive(Clone)]
+pub enum ExitInvocationKind {
+    SpvInst(spv::Inst),
+}

src/cf/mod.rs

@@ -153,8 +153,7 @@
 
 // NOTE(eddyb) all the modules are declared here, but they're documented "inside"
 // (i.e. using inner doc comments).
-pub mod cfg;
-pub mod cfgssa;
+pub mod cf;
 mod context;
 pub mod func_at;
 pub mod print;
@@ -717,7 +716,9 @@ pub struct FuncDefBody {
     /// When present, it starts at `body` (more specifically, its exit),
     /// effectively replacing the structured return `body` otherwise implies,
     /// with `body` (or rather, its `children`) always being fully structured.
-    pub unstructured_cfg: Option<cfg::ControlFlowGraph>,
+    //
+    // FIXME(eddyb) replace this with a new `NodeKind` variant.
+    pub unstructured_cfg: Option<cf::unstructured::ControlFlowGraph>,
 }
 
 /// Entity handle for a [`RegionDef`](crate::RegionDef)
@@ -881,7 +882,7 @@ pub enum NodeKind {
     ///
     /// This corresponds to "gamma" (`γ`) nodes in (R)VSDG, though those are
     /// sometimes limited only to a two-way selection on a boolean condition.
-    Select { kind: SelectionKind, scrutinee: Value, cases: SmallVec<[Region; 2]> },
+    Select { kind: cf::SelectionKind, scrutinee: Value, cases: SmallVec<[Region; 2]> },
 
     /// Execute `body` repeatedly, until `repeat_condition` evaluates to `false`.
     ///
@@ -910,23 +911,14 @@ pub enum NodeKind {
     //
     // FIXME(eddyb) make this less shader-controlflow-centric.
     ExitInvocation {
-        kind: cfg::ExitInvocationKind,
+        kind: cf::ExitInvocationKind,
 
         // FIXME(eddyb) centralize `Value` inputs across `Node`s,
         // and only use stricter types for building/traversing the IR.
         inputs: SmallVec<[Value; 2]>,
     },
 }
 
-#[derive(Clone)]
-pub enum SelectionKind {
-    /// Two-case selection based on boolean condition, i.e. `if`-`else`, with
-    /// the two cases being "then" and "else" (in that order).
-    BoolCond,
-
-    SpvInst(spv::Inst),
-}
-
 /// Entity handle for a [`DataInstDef`](crate::DataInstDef) (a leaf instruction).
 pub use context::DataInst;
 

src/cfg.rs renamed to src/cf/structurize.rs

@@ -1,5 +1,5 @@
 use crate::visit::{InnerVisit, Visitor};
-use crate::{AttrSet, Const, Context, DeclDef, Func, FxIndexSet, GlobalVar, Module, Type, cfg};
+use crate::{AttrSet, Const, Context, DeclDef, Func, FxIndexSet, GlobalVar, Module, Type, cf};
 
 /// Apply the [`cfg::Structurizer`] algorithm to all function definitions in `module`.
 pub fn structurize_func_cfgs(module: &mut Module) {
@@ -22,7 +22,7 @@ pub fn structurize_func_cfgs(module: &mut Module) {
 
     for &func in &collector.seen_funcs {
         if let DeclDef::Present(func_def_body) = &mut module.funcs[func].def {
-            cfg::Structurizer::new(cx, func_def_body).structurize_func();
+            cf::structurize::Structurizer::new(cx, func_def_body).structurize_func();
         }
     }
 }

src/cf/unstructured.rs

@@ -19,6 +19,7 @@
 #![allow(unstable_name_collisions)]
 use itertools::Itertools as _;
 
+use crate::cf::{self, SelectionKind};
 use crate::func_at::FuncAt;
 use crate::mem::{DataHapp, DataHappKind, MemAccesses, MemAttr, MemOp};
 use crate::print::multiversion::Versions;
@@ -30,8 +31,7 @@ use crate::{
     EntityOrientedDenseMap, ExportKey, Exportee, Func, FuncDecl, FuncDefBody, FuncParam,
     FxIndexMap, FxIndexSet, GlobalVar, GlobalVarDecl, GlobalVarDefBody, Import, InternedStr,
     Module, ModuleDebugInfo, ModuleDialect, Node, NodeDef, NodeKind, NodeOutputDecl, OrdAssertEq,
-    Region, RegionDef, RegionInputDecl, SelectionKind, Type, TypeDef, TypeKind, TypeOrConst, Value,
-    cfg, spv,
+    Region, RegionDef, RegionInputDecl, Type, TypeDef, TypeKind, TypeOrConst, Value, spv,
 };
 use arrayvec::ArrayVec;
 use itertools::Either;
@@ -3858,7 +3858,7 @@ impl Print for FuncAt<'_, Node> {
                 ])
             }
             NodeKind::ExitInvocation {
-                kind: cfg::ExitInvocationKind::SpvInst(spv::Inst { opcode, imms }),
+                kind: cf::ExitInvocationKind::SpvInst(spv::Inst { opcode, imms }),
                 inputs,
             } => printer.pretty_spv_inst(
                 kw_style,
@@ -4274,7 +4274,7 @@ impl Print for FuncAt<'_, DataInst> {
     }
 }
 
-impl Print for cfg::ControlInst {
+impl Print for cf::unstructured::ControlInst {
     type Output = pretty::Fragment;
     fn print(&self, printer: &Printer<'_>) -> pretty::Fragment {
         let Self { attrs, kind, inputs, targets, target_inputs } = self;
@@ -4300,12 +4300,12 @@ impl Print for cfg::ControlInst {
         });
 
         let def = match kind {
-            cfg::ControlInstKind::Unreachable => {
+            cf::unstructured::ControlInstKind::Unreachable => {
                 // FIXME(eddyb) use `targets.is_empty()` when that is stabilized.
                 assert!(targets.len() == 0 && inputs.is_empty());
                 kw("unreachable")
             }
-            cfg::ControlInstKind::Return => {
+            cf::unstructured::ControlInstKind::Return => {
                 // FIXME(eddyb) use `targets.is_empty()` when that is stabilized.
                 assert!(targets.len() == 0);
                 match inputs[..] {
@@ -4314,10 +4314,9 @@ impl Print for cfg::ControlInst {
                     _ => unreachable!(),
                 }
             }
-            cfg::ControlInstKind::ExitInvocation(cfg::ExitInvocationKind::SpvInst(spv::Inst {
-                opcode,
-                imms,
-            })) => {
+            cf::unstructured::ControlInstKind::ExitInvocation(cf::ExitInvocationKind::SpvInst(
+                spv::Inst { opcode, imms },
+            )) => {
                 // FIXME(eddyb) use `targets.is_empty()` when that is stabilized.
                 assert!(targets.len() == 0);
                 printer.pretty_spv_inst(
@@ -4328,12 +4327,12 @@ impl Print for cfg::ControlInst {
                 )
             }
 
-            cfg::ControlInstKind::Branch => {
+            cf::unstructured::ControlInstKind::Branch => {
                 assert_eq!((targets.len(), inputs.len()), (1, 0));
                 targets.next().unwrap()
             }
 
-            cfg::ControlInstKind::SelectBranch(kind) => {
+            cf::unstructured::ControlInstKind::SelectBranch(kind) => {
                 assert_eq!(inputs.len(), 1);
                 kind.print_with_scrutinee_and_cases(printer, kw_style, inputs[0], targets)
             }

src/lib.rs

@@ -1,14 +1,15 @@
 //! SPIR-T to SPIR-V lifting.
 
+use crate::cf::{self, SelectionKind};
 use crate::func_at::FuncAt;
 use crate::spv::{self, spec};
 use crate::visit::{InnerVisit, Visitor};
 use crate::{
     AddrSpace, Attr, AttrSet, Const, ConstDef, ConstKind, Context, DataInst, DataInstDef,
     DataInstKind, DbgSrcLoc, DeclDef, EntityList, ExportKey, Exportee, Func, FuncDecl, FuncParam,
     FxIndexMap, FxIndexSet, GlobalVar, GlobalVarDefBody, Import, Module, ModuleDebugInfo,
-    ModuleDialect, Node, NodeKind, NodeOutputDecl, OrdAssertEq, Region, RegionInputDecl,
-    SelectionKind, Type, TypeDef, TypeKind, TypeOrConst, Value, cfg,
+    ModuleDialect, Node, NodeKind, NodeOutputDecl, OrdAssertEq, Region, RegionInputDecl, Type,
+    TypeDef, TypeKind, TypeOrConst, Value,
 };
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
@@ -262,7 +263,7 @@ struct FuncLifting<'a> {
 /// What determines the values for [`Value::RegionInput`]s, for a specific
 /// region (effectively the subset of "region parents" that support inputs).
 ///
-/// Note that this is not used when a [`cfg::ControlInst`] has `target_inputs`,
+/// Note that this is not used when a [`cf::unstructured::ControlInst`] has `target_inputs`,
 /// and the target [`Region`] itself has phis for its `inputs`.
 enum RegionInputsSource {
     FuncParams,
@@ -299,7 +300,7 @@ struct Phi {
     default_value: Option<Value>,
 }
 
-/// Similar to [`cfg::ControlInst`], except:
+/// Similar to [`cf::unstructured::ControlInst`], except:
 /// * `targets` use [`CfgPoint`]s instead of [`Region`]s, to be able to
 ///   reach any of the SPIR-V blocks being created during lifting
 /// * φ ("phi") values can be provided for targets regardless of "which side" of
@@ -310,7 +311,7 @@ struct Phi {
 struct Terminator<'a> {
     attrs: AttrSet,
 
-    kind: Cow<'a, cfg::ControlInstKind>,
+    kind: Cow<'a, cf::unstructured::ControlInstKind>,
 
     // FIXME(eddyb) use `Cow` or something, but ideally the "owned" case always
     // has at most one input, so allocating a whole `Vec` for that seems unwise.
@@ -640,8 +641,13 @@ impl<'a> FuncLifting<'a> {
                         .as_ref()
                         .and_then(|cfg| cfg.control_inst_on_exit_from.get(region));
                     if let Some(terminator) = unstructured_terminator {
-                        let cfg::ControlInst { attrs, kind, inputs, targets, target_inputs } =
-                            terminator;
+                        let cf::unstructured::ControlInst {
+                            attrs,
+                            kind,
+                            inputs,
+                            targets,
+                            target_inputs,
+                        } = terminator;
                         Terminator {
                             attrs: *attrs,
                             kind: Cow::Borrowed(kind),
@@ -664,7 +670,7 @@ impl<'a> FuncLifting<'a> {
                         assert!(region == func_def_body.body);
                         Terminator {
                             attrs: AttrSet::default(),
-                            kind: Cow::Owned(cfg::ControlInstKind::Return),
+                            kind: Cow::Owned(cf::unstructured::ControlInstKind::Return),
                             inputs: func_def_body.at_body().def().outputs.clone(),
                             targets: [].into_iter().collect(),
                             target_phi_values: FxIndexMap::default(),
@@ -683,7 +689,9 @@ impl<'a> FuncLifting<'a> {
 
                         NodeKind::Select { kind, scrutinee, cases } => Terminator {
                             attrs: AttrSet::default(),
-                            kind: Cow::Owned(cfg::ControlInstKind::SelectBranch(kind.clone())),
+                            kind: Cow::Owned(cf::unstructured::ControlInstKind::SelectBranch(
+                                kind.clone(),
+                            )),
                             inputs: [*scrutinee].into_iter().collect(),
                             targets: cases
                                 .iter()
@@ -696,7 +704,7 @@ impl<'a> FuncLifting<'a> {
                         NodeKind::Loop { initial_inputs: _, body, repeat_condition: _ } => {
                             Terminator {
                                 attrs: AttrSet::default(),
-                                kind: Cow::Owned(cfg::ControlInstKind::Branch),
+                                kind: Cow::Owned(cf::unstructured::ControlInstKind::Branch),
                                 inputs: [].into_iter().collect(),
                                 targets: [CfgPoint::RegionEntry(*body)].into_iter().collect(),
                                 target_phi_values: FxIndexMap::default(),
@@ -716,7 +724,9 @@ impl<'a> FuncLifting<'a> {
 
                         NodeKind::ExitInvocation { kind, inputs } => Terminator {
                             attrs: AttrSet::default(),
-                            kind: Cow::Owned(cfg::ControlInstKind::ExitInvocation(kind.clone())),
+                            kind: Cow::Owned(cf::unstructured::ControlInstKind::ExitInvocation(
+                                kind.clone(),
+                            )),
                             inputs: inputs.clone(),
                             targets: [].into_iter().collect(),
                             target_phi_values: FxIndexMap::default(),
@@ -743,7 +753,7 @@ impl<'a> FuncLifting<'a> {
 
                         NodeKind::Select { .. } => Terminator {
                             attrs: AttrSet::default(),
-                            kind: Cow::Owned(cfg::ControlInstKind::Branch),
+                            kind: Cow::Owned(cf::unstructured::ControlInstKind::Branch),
                             inputs: [].into_iter().collect(),
                             targets: [parent_exit].into_iter().collect(),
                             target_phi_values: region_outputs
@@ -775,7 +785,7 @@ impl<'a> FuncLifting<'a> {
                             if is_infinite_loop {
                                 Terminator {
                                     attrs: AttrSet::default(),
-                                    kind: Cow::Owned(cfg::ControlInstKind::Branch),
+                                    kind: Cow::Owned(cf::unstructured::ControlInstKind::Branch),
                                     inputs: [].into_iter().collect(),
                                     targets: [backedge].into_iter().collect(),
                                     target_phi_values,
@@ -784,9 +794,11 @@ impl<'a> FuncLifting<'a> {
                             } else {
                                 Terminator {
                                     attrs: AttrSet::default(),
-                                    kind: Cow::Owned(cfg::ControlInstKind::SelectBranch(
-                                        SelectionKind::BoolCond,
-                                    )),
+                                    kind: Cow::Owned(
+                                        cf::unstructured::ControlInstKind::SelectBranch(
+                                            SelectionKind::BoolCond,
+                                        ),
+                                    ),
                                     inputs: [repeat_condition].into_iter().collect(),
                                     targets: [backedge, parent_exit].into_iter().collect(),
                                     target_phi_values,
@@ -801,7 +813,7 @@ impl<'a> FuncLifting<'a> {
                 // implied edge from a `Block`'s `Entry` to its `Exit`).
                 (_, Some(succ_cursor)) => Terminator {
                     attrs: AttrSet::default(),
-                    kind: Cow::Owned(cfg::ControlInstKind::Branch),
+                    kind: Cow::Owned(cf::unstructured::ControlInstKind::Branch),
                     inputs: [].into_iter().collect(),
                     targets: [succ_cursor.point].into_iter().collect(),
                     target_phi_values: FxIndexMap::default(),
@@ -877,7 +889,7 @@ impl<'a> FuncLifting<'a> {
                     original_terminator;
 
                 *attrs == AttrSet::default()
-                    && matches!(**kind, cfg::ControlInstKind::Branch)
+                    && matches!(**kind, cf::unstructured::ControlInstKind::Branch)
                     && inputs.is_empty()
                     && targets.len() == 1
                     && target_phi_values.is_empty()
@@ -903,7 +915,7 @@ impl<'a> FuncLifting<'a> {
                             new_terminator,
                             Terminator {
                                 attrs: Default::default(),
-                                kind: Cow::Owned(cfg::ControlInstKind::Unreachable),
+                                kind: Cow::Owned(cf::unstructured::ControlInstKind::Unreachable),
                                 inputs: Default::default(),
                                 targets: Default::default(),
                                 target_phi_values: Default::default(),
@@ -1282,26 +1294,26 @@ impl LazyInst<'_, '_> {
             },
             Self::Terminator { parent_func, terminator } => {
                 let inst = match &*terminator.kind {
-                    cfg::ControlInstKind::Unreachable => wk.OpUnreachable.into(),
-                    cfg::ControlInstKind::Return => {
+                    cf::unstructured::ControlInstKind::Unreachable => wk.OpUnreachable.into(),
+                    cf::unstructured::ControlInstKind::Return => {
                         if terminator.inputs.is_empty() {
                             wk.OpReturn.into()
                         } else {
                             wk.OpReturnValue.into()
                         }
                     }
-                    cfg::ControlInstKind::ExitInvocation(cfg::ExitInvocationKind::SpvInst(
+                    cf::unstructured::ControlInstKind::ExitInvocation(
+                        cf::ExitInvocationKind::SpvInst(inst),
+                    )
+                    | cf::unstructured::ControlInstKind::SelectBranch(SelectionKind::SpvInst(
                         inst,
                     )) => inst.clone(),
 
-                    cfg::ControlInstKind::Branch => wk.OpBranch.into(),
+                    cf::unstructured::ControlInstKind::Branch => wk.OpBranch.into(),
 
-                    cfg::ControlInstKind::SelectBranch(SelectionKind::BoolCond) => {
+                    cf::unstructured::ControlInstKind::SelectBranch(SelectionKind::BoolCond) => {
                         wk.OpBranchConditional.into()
                     }
-                    cfg::ControlInstKind::SelectBranch(SelectionKind::SpvInst(inst)) => {
-                        inst.clone()
-                    }
                 };
                 spv::InstWithIds {
                     without_ids: inst,