compiler/rust/cfg: Add a hash func type parameter

and switch nak over to rustc-hash for CFGBuilder

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/34865>

src/compiler/rust/cfg.rs

@@ -3,7 +3,7 @@
 
 use crate::bitset::BitSet;
 use std::collections::HashMap;
-use std::hash::Hash;
+use std::hash::{BuildHasher, Hash};
 use std::ops::{Deref, DerefMut, Index, IndexMut};
 use std::slice;
 
@@ -397,24 +397,24 @@ impl<'a, N> IntoIterator for &'a mut CFG<N> {
 /// `CFGBuilder` makes all that automatic by letting you add nodes and edges
 /// using any key type desired.  You then call `as_cfg()` to get the final
 /// control-flow graph.
-pub struct CFGBuilder<K, N> {
+pub struct CFGBuilder<K, N, H: BuildHasher + Default> {
     nodes: Vec<N>,
     edges: Vec<(K, K)>,
-    key_map: HashMap<K, usize>,
+    key_map: HashMap<K, usize, H>,
 }
 
-impl<K, N> CFGBuilder<K, N> {
+impl<K, N, H: BuildHasher + Default> CFGBuilder<K, N, H> {
     /// Creates a new CFG builder.
-    pub fn new() -> CFGBuilder<K, N> {
+    pub fn new() -> Self {
         CFGBuilder {
             nodes: Vec::new(),
             edges: Vec::new(),
-            key_map: HashMap::new(),
+            key_map: Default::default(),
         }
     }
 }
 
-impl<K: Eq + Hash, N> CFGBuilder<K, N> {
+impl<K: Eq + Hash, N, H: BuildHasher + Default> CFGBuilder<K, N, H> {
     /// Adds a node to the CFG.
     pub fn add_node(&mut self, k: K, n: N) {
         self.key_map.insert(k, self.nodes.len());
@@ -437,7 +437,7 @@ impl<K: Eq + Hash, N> CFGBuilder<K, N> {
     }
 }
 
-impl<K, N> Default for CFGBuilder<K, N> {
+impl<K, N, H: BuildHasher + Default> Default for CFGBuilder<K, N, H> {
     fn default() -> Self {
         CFGBuilder::new()
     }

src/nouveau/compiler/nak/from_nir.rs

@@ -15,7 +15,7 @@ use compiler::bindings::*;
 use compiler::cfg::CFGBuilder;
 use compiler::nir::*;
 use compiler::nir_instr_printer::NirInstrPrinter;
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
 use std::cmp::max;
 use std::ops::Index;
 
@@ -319,7 +319,7 @@ struct ShaderFromNir<'a> {
     sm: &'a dyn ShaderModel,
     info: ShaderInfo,
     float_ctl: ShaderFloatControls,
-    cfg: CFGBuilder<u32, BasicBlock>,
+    cfg: CFGBuilder<u32, BasicBlock, FxBuildHasher>,
     label_alloc: LabelAllocator,
     block_label: FxHashMap<u32, Label>,
     bar_label: FxHashMap<u32, Label>,

src/nouveau/compiler/nak/hw_tests.rs

@@ -13,6 +13,7 @@ use acorn::Acorn;
 use compiler::bindings::MESA_SHADER_COMPUTE;
 use compiler::cfg::CFGBuilder;
 use nak_bindings::*;
+use rustc_hash::FxBuildHasher;
 use std::mem::offset_of;
 use std::str::FromStr;
 use std::sync::OnceLock;
@@ -190,7 +191,7 @@ impl<'a> TestShaderBuilder<'a> {
             instrs: self.b.into_vec(),
         };
 
-        let mut cfg = CFGBuilder::new();
+        let mut cfg = CFGBuilder::<_, _, FxBuildHasher>::new();
         cfg.add_node(0, self.start_block);
         cfg.add_node(1, block);
         cfg.add_edge(0, 1);

src/nouveau/compiler/nak/nvdisasm_tests.rs

@@ -4,6 +4,7 @@
 use crate::ir::*;
 use crate::sm70::ShaderModel70;
 use compiler::cfg::CFGBuilder;
+use rustc_hash::FxBuildHasher;
 
 use std::io::Write;
 use std::mem;
@@ -55,7 +56,7 @@ fn disassemble_instrs(instrs: Vec<Box<Instr>>, sm: u8) -> Vec<String> {
         instrs,
     };
 
-    let mut cfg = CFGBuilder::new();
+    let mut cfg = CFGBuilder::<_, _, FxBuildHasher>::new();
     cfg.add_node(0, block);
 
     let f = Function {

src/nouveau/compiler/nak/opt_jump_thread.rs

@@ -4,7 +4,7 @@
 use crate::ir::*;
 
 use compiler::cfg::CFGBuilder;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxBuildHasher, FxHashMap};
 
 fn clone_branch(op: &Op) -> Op {
     match op {
@@ -93,7 +93,7 @@ fn jump_thread(func: &mut Function) -> bool {
 fn rewrite_cfg(func: &mut Function) {
     // CFGBuilder takes care of removing dead blocks for us
     // We use the basic block's label to identify it
-    let mut builder = CFGBuilder::new();
+    let mut builder = CFGBuilder::<_, _, FxBuildHasher>::new();
 
     for i in 0..func.blocks.len() {
         let block = &func.blocks[i];