Re-write Predication to use FunctionEditor

• Write new Predication pass using FunctionEditor
  • Uses less analysis info, can work on branches outside fork-joins.
  • Supports partial predication (when some strict subset of inputs to a region form a simple branch, the corresponding strict subset of inputs to phis on the region are predicated).
• New WritePredication pass for converting a branch over writes to a branch over data and indices inputs to a single write, reducing need for spilling in GCM.

hercules_opt/src/pass.rs

@@ -25,6 +25,7 @@ pub enum Pass {
     PhiElim,
     Forkify,
     ForkGuardElim,
+    WritePredication,
     Predication,
     SROA,
     Inline,
@@ -469,27 +470,58 @@ impl PassManager {
                     }
                     self.clear_analyses();
                 }
+                Pass::WritePredication => {
+                    self.make_def_uses();
+                    let def_uses = self.def_uses.as_ref().unwrap();
+                    for idx in 0..self.module.functions.len() {
+                        let constants_ref =
+                            RefCell::new(std::mem::take(&mut self.module.constants));
+                        let dynamic_constants_ref =
+                            RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+                        let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+                        let mut editor = FunctionEditor::new(
+                            &mut self.module.functions[idx],
+                            FunctionID::new(idx),
+                            &constants_ref,
+                            &dynamic_constants_ref,
+                            &types_ref,
+                            &def_uses[idx],
+                        );
+                        write_predication(&mut editor);
+
+                        self.module.constants = constants_ref.take();
+                        self.module.dynamic_constants = dynamic_constants_ref.take();
+                        self.module.types = types_ref.take();
+
+                        self.module.functions[idx].delete_gravestones();
+                    }
+                    self.clear_analyses();
+                }
                 Pass::Predication => {
                     self.make_def_uses();
-                    self.make_reverse_postorders();
-                    self.make_doms();
-                    self.make_fork_join_maps();
+                    self.make_typing();
                     let def_uses = self.def_uses.as_ref().unwrap();
-                    let reverse_postorders = self.reverse_postorders.as_ref().unwrap();
-                    let doms = self.doms.as_ref().unwrap();
-                    let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
+                    let typing = self.typing.as_ref().unwrap();
                     for idx in 0..self.module.functions.len() {
-                        predication(
+                        let constants_ref =
+                            RefCell::new(std::mem::take(&mut self.module.constants));
+                        let dynamic_constants_ref =
+                            RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+                        let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+                        let mut editor = FunctionEditor::new(
                             &mut self.module.functions[idx],
+                            FunctionID::new(idx),
+                            &constants_ref,
+                            &dynamic_constants_ref,
+                            &types_ref,
                             &def_uses[idx],
-                            &reverse_postorders[idx],
-                            &doms[idx],
-                            &fork_join_maps[idx],
                         );
-                        let num_nodes = self.module.functions[idx].nodes.len();
-                        self.module.functions[idx]
-                            .schedules
-                            .resize(num_nodes, vec![]);
+                        predication(&mut editor, &typing[idx]);
+
+                        self.module.constants = constants_ref.take();
+                        self.module.dynamic_constants = dynamic_constants_ref.take();
+                        self.module.types = types_ref.take();
+
                         self.module.functions[idx].delete_gravestones();
                     }
                     self.clear_analyses();