cranelift: fix cubic compile time for modules with many allocating globals

The alias-analysis worklist is drained LIFO, which redoes the whole tail of the
function each time it comes back to the other side of a branch, so a long chain
of diamonds -- a Wasm module's initializer for N allocating globals, say --
visits each block O(N) times and walks O(N) alias regions per visit. Reverse
postorder converges in a single pass instead. For N=2000, compiling goes from
67.0s to 0.22s.

The pass is still quadratic in the number of alias regions; that is left for a
separate change. Visit order also affects precision, hence the disas test update.

Refs bytecodealliance#14210

Assisted-by: Claude Code:claude-opus-5

Author: gfx

cranelift/codegen/src/alias_analysis.rs

@@ -86,7 +86,8 @@ use crate::{
     post_dominator_tree::PostDominatorTree,
     trace,
 };
-use core::cmp::Ordering;
+use alloc::collections::BinaryHeap;
+use core::cmp::{Ordering, Reverse};
 use cranelift_entity::{EntityRef, SecondaryMap, packed_option::PackedOption};
 
 /// Determine whether this opcode behaves as a memory fence, i.e.,
@@ -708,13 +709,21 @@ impl<'a> AliasAnalysis<'a> {
     }
 
     fn compute_block_input_states(&mut self, func: &Function) {
-        let mut queue = vec![];
+        // Drain the worklist in reverse postorder: a LIFO worklist redoes the
+        // whole tail of the function each time it comes back to the other side
+        // of a branch, which is quadratic for a long chain of diamonds.
+        let mut rpo_index = SecondaryMap::with_default(usize::MAX);
+        for (i, block) in self.domtree.cfg_rpo().enumerate() {
+            rpo_index[*block] = i;
+        }
+
+        let mut queue = BinaryHeap::new();
         let mut queue_set = FxHashSet::default();
         let entry = func.layout.entry_block().unwrap();
-        queue.push(entry);
+        queue.push(Reverse((rpo_index[entry], entry)));
         queue_set.insert(entry);
 
-        while let Some(block) = queue.pop() {
+        while let Some(Reverse((_, block))) = queue.pop() {
             queue_set.remove(&block);
             let mut state = self
                 .block_input
@@ -747,7 +756,7 @@ impl<'a> AliasAnalysis<'a> {
                 };
 
                 if updated && queue_set.insert(succ) {
-                    queue.push(succ);
+                    queue.push(Reverse((rpo_index[succ], succ)));
                 }
             });
         }

tests/disas/gc/array-copy-with-fuel.wat

@@ -107,8 +107,6 @@
 ;; @002b                               brif.i32 v6, block6, block9
 ;;
 ;;                                 block6:
-;;                                     v143 = load.i32 notrap aligned region6 v162
-;;                                     v145 = load.i32 notrap aligned region7 v163
 ;; @002b                               v102 = icmp.i64 ult v58, v82
 ;; @002b                               v107 = iadd.i64 v58, v170
 ;; @002b                               v108 = iadd.i64 v82, v170