refactor(cranelift): merge DominatorTreePreorder into DominatorTree (#11596)

* refactor(cranelift): merge DominatorTreePreorder into DominatorTree

Integrate preorder functionality directly into DominatorTree to
eliminate duplicate computation and improve performance.

This eliminates the need for a separate DominatorTreePreorder data
structure, reducing memory usage and providing O(1) block dominance
checks by default. Block dominance checks throughout the compiler now
benefit from constant-time performance instead of O(depth) tree
traversal.

* refactor(cranelift): implement the new unified DominatorTree

Remove separate DominatorTreePreorder computation and use unified API:

- Context: Remove domtree_preorder field, simplify compute_domtree()
- AliasAnalysis: Switch from DominatorTreePreorder to DominatorTree
- Update dominance checks to use general dominates() method

All dominance checks in alias analysis now automatically benefit from
O(1) block dominance performance when instructions are in different
blocks.

* refactor(cranelift): update optimization passes for DominatorTree

* refactor(cranelift): update verifier and tests for new DominatorTree

SSA dominance validation in the verifier now benefits from O(1)
block-to-block dominance checks, improving compilation performance
during debug builds with verification enabled.

Author: pnodet

cranelift/codegen/src/alias_analysis.rs

@@ -63,7 +63,7 @@
 
 use crate::{
     cursor::{Cursor, FuncCursor},
-    dominator_tree::DominatorTreePreorder,
+    dominator_tree::DominatorTree,
     inst_predicates::{
         has_memory_fence_semantics, inst_addr_offset_type, inst_store_data, visit_block_succs,
     },
@@ -176,7 +176,7 @@ struct MemoryLoc {
 /// An alias-analysis pass.
 pub struct AliasAnalysis<'a> {
     /// The domtree for the function.
-    domtree: &'a DominatorTreePreorder,
+    domtree: &'a DominatorTree,
 
     /// Input state to a basic block.
     block_input: FxHashMap<Block, LastStores>,
@@ -191,7 +191,7 @@ pub struct AliasAnalysis<'a> {
 
 impl<'a> AliasAnalysis<'a> {
     /// Perform an alias analysis pass.
-    pub fn new(func: &Function, domtree: &'a DominatorTreePreorder) -> AliasAnalysis<'a> {
+    pub fn new(func: &Function, domtree: &'a DominatorTree) -> AliasAnalysis<'a> {
         trace!("alias analysis: input is:\n{:?}", func);
         let mut analysis = AliasAnalysis {
             domtree,
@@ -333,7 +333,7 @@ impl<'a> AliasAnalysis<'a> {
                             value.index(),
                             def_inst.index()
                         );
-                        if self.domtree.dominates_inst(def_inst, inst, &func.layout) {
+                        if self.domtree.dominates(def_inst, inst, &func.layout) {
                             trace!(
                                 " -> dominates; value equiv from v{} to v{} inserted",
                                 load_result.index(),

cranelift/codegen/src/context.rs

@@ -11,7 +11,6 @@
 
 use crate::alias_analysis::AliasAnalysis;
 use crate::dominator_tree::DominatorTree;
-use crate::dominator_tree::DominatorTreePreorder;
 use crate::egraph::EgraphPass;
 use crate::flowgraph::ControlFlowGraph;
 use crate::inline::{Inline, do_inlining};
@@ -48,9 +47,6 @@ pub struct Context {
     /// Dominator tree for `func`.
     pub domtree: DominatorTree,
 
-    /// Dominator tree with dominance stored implicitly via visit-order indices for `func`
-    domtree_preorder: DominatorTreePreorder,
-
     /// Loop analysis of `func`.
     pub loop_analysis: LoopAnalysis,
 
@@ -79,7 +75,6 @@ impl Context {
             func,
             cfg: ControlFlowGraph::new(),
             domtree: DominatorTree::new(),
-            domtree_preorder: DominatorTreePreorder::new(),
             loop_analysis: LoopAnalysis::new(),
             compiled_code: None,
             want_disasm: false,
@@ -319,7 +314,6 @@ impl Context {
     /// Compute dominator tree.
     pub fn compute_domtree(&mut self) {
         self.domtree.compute(&self.func, &self.cfg);
-        self.domtree_preorder.compute(&self.domtree);
     }
 
     /// Compute the loop analysis.
@@ -349,7 +343,7 @@ impl Context {
     /// by a store instruction to the same instruction (so-called
     /// "store-to-load forwarding").
     pub fn replace_redundant_loads(&mut self) -> CodegenResult<()> {
-        let mut analysis = AliasAnalysis::new(&self.func, &self.domtree_preorder);
+        let mut analysis = AliasAnalysis::new(&self.func, &self.domtree);
         analysis.compute_and_update_aliases(&mut self.func);
         Ok(())
     }
@@ -381,7 +375,7 @@ impl Context {
         );
         let fisa = fisa.into();
         self.compute_loop_analysis();
-        let mut alias_analysis = AliasAnalysis::new(&self.func, &self.domtree_preorder);
+        let mut alias_analysis = AliasAnalysis::new(&self.func, &self.domtree);
         let mut pass = EgraphPass::new(
             &mut self.func,
             &self.domtree,