diff --git a/src/nouveau/compiler/nak/assign_regs.rs b/src/nouveau/compiler/nak/assign_regs.rs
index eb6877ee7c4..5c3eee9ff3c 100644
--- a/src/nouveau/compiler/nak/assign_regs.rs
+++ b/src/nouveau/compiler/nak/assign_regs.rs
@@ -7,11 +7,11 @@ use crate::liveness::{BlockLiveness, Liveness, SimpleLiveness};
 use crate::union_find::UnionFind;
 
 use compiler::bitset::BitSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 use std::cmp::{max, min, Ordering};
-use std::collections::{HashMap, HashSet};
 
 struct KillSet {
-    set: HashSet<SSAValue>,
+    set: FxHashSet<SSAValue>,
     vec: Vec<SSAValue>,
 }
 
@@ -83,7 +83,7 @@ enum SSAUse {
 }
 
 struct SSAUseMap {
-    ssa_map: HashMap<SSAValue, Vec<(usize, SSAUse)>>,
+    ssa_map: FxHashMap<SSAValue, Vec<(usize, SSAUse)>>,
 }
 
 impl SSAUseMap {
@@ -165,7 +165,7 @@ impl SSAUseMap {
 ///     Taiwan, 2011, pp. 45-54, doi: 10.1145/2038698.2038708.
 struct PhiWebs {
     uf: UnionFind<SSAValue>,
-    assignments: HashMap<SSAValue, u32>,
+    assignments: FxHashMap<SSAValue, u32>,
 }
 
 impl PhiWebs {
@@ -181,7 +181,7 @@ impl PhiWebs {
             let Some(phi_dsts) = f.blocks[b_idx].phi_dsts() else {
                 continue;
             };
-            let dsts: HashMap<u32, &SSARef> = phi_dsts
+            let dsts: FxHashMap<u32, &SSARef> = phi_dsts
                 .dsts
                 .iter()
                 .map(|(idx, dst)| {
@@ -263,7 +263,7 @@ struct RegAllocator {
     used: BitSet,
     pinned: BitSet,
     reg_ssa: Vec<Option<SSAValue>>,
-    ssa_reg: HashMap<SSAValue, u32>,
+    ssa_reg: FxHashMap<SSAValue, u32>,
 }
 
 impl RegAllocator {
@@ -486,7 +486,7 @@ struct VecRegAllocator<'a> {
     ra: &'a mut RegAllocator,
     pcopy: OpParCopy,
     pinned: BitSet,
-    evicted: HashMap<SSAValue, u32>,
+    evicted: FxHashMap<SSAValue, u32>,
 }
 
 impl<'a> VecRegAllocator<'a> {
@@ -922,7 +922,7 @@ struct AssignRegsBlock {
     ra: PerRegFile<RegAllocator>,
     pcopy_tmp_gprs: u8,
     live_in: Vec<LiveValue>,
-    phi_out: HashMap<u32, SrcRef>,
+    phi_out: FxHashMap<u32, SrcRef>,
 }
 
 impl AssignRegsBlock {
diff --git a/src/nouveau/compiler/nak/calc_instr_deps.rs b/src/nouveau/compiler/nak/calc_instr_deps.rs
index b88938af97c..4c4c67ef558 100644
--- a/src/nouveau/compiler/nak/calc_instr_deps.rs
+++ b/src/nouveau/compiler/nak/calc_instr_deps.rs
@@ -5,8 +5,8 @@ use crate::api::{GetDebugFlags, DEBUG};
 use crate::ir::*;
 use crate::reg_tracker::RegTracker;
 
+use rustc_hash::{FxHashMap, FxHashSet};
 use std::cmp::max;
-use std::collections::{HashMap, HashSet};
 use std::slice;
 
 #[derive(Clone)]
@@ -65,9 +65,9 @@ struct DepNode {
 
 struct DepGraph {
     deps: Vec<DepNode>,
-    instr_deps: HashMap<(usize, usize), (usize, usize)>,
-    instr_waits: HashMap<(usize, usize), Vec<usize>>,
-    active: HashSet<usize>,
+    instr_deps: FxHashMap<(usize, usize), (usize, usize)>,
+    instr_waits: FxHashMap<(usize, usize), Vec<usize>>,
+    active: FxHashSet<usize>,
 }
 
 impl DepGraph {
diff --git a/src/nouveau/compiler/nak/const_tracker.rs b/src/nouveau/compiler/nak/const_tracker.rs
index a54ddb8a632..32735220fee 100644
--- a/src/nouveau/compiler/nak/const_tracker.rs
+++ b/src/nouveau/compiler/nak/const_tracker.rs
@@ -3,10 +3,10 @@
 
 use crate::ir::*;
 
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 pub struct ConstTracker {
-    map: HashMap<SSAValue, SrcRef>,
+    map: FxHashMap<SSAValue, SrcRef>,
 }
 
 /// A tracker struct for finding re-materializable constants
diff --git a/src/nouveau/compiler/nak/from_nir.rs b/src/nouveau/compiler/nak/from_nir.rs
index 6cc633fe3ff..76301134bd6 100644
--- a/src/nouveau/compiler/nak/from_nir.rs
+++ b/src/nouveau/compiler/nak/from_nir.rs
@@ -15,8 +15,8 @@ use compiler::bindings::*;
 use compiler::cfg::CFGBuilder;
 use compiler::nir::*;
 use compiler::nir_instr_printer::NirInstrPrinter;
+use rustc_hash::{FxHashMap, FxHashSet};
 use std::cmp::max;
-use std::collections::{HashMap, HashSet};
 use std::ops::Index;
 
 fn init_info_from_nir(nak: &nak_compiler, nir: &nir_shader) -> ShaderInfo {
@@ -192,7 +192,7 @@ fn alloc_ssa_for_nir(b: &mut impl SSABuilder, ssa: &nir_def) -> Vec<SSAValue> {
 
 struct PhiAllocMap<'a> {
     alloc: &'a mut PhiAllocator,
-    map: HashMap<(u32, u8), u32>,
+    map: FxHashMap<(u32, u8), u32>,
 }
 
 impl<'a> PhiAllocMap<'a> {
@@ -321,14 +321,14 @@ struct ShaderFromNir<'a> {
     float_ctl: ShaderFloatControls,
     cfg: CFGBuilder<u32, BasicBlock>,
     label_alloc: LabelAllocator,
-    block_label: HashMap<u32, Label>,
-    bar_label: HashMap<u32, Label>,
-    sync_blocks: HashSet<u32>,
+    block_label: FxHashMap<u32, Label>,
+    bar_label: FxHashMap<u32, Label>,
+    sync_blocks: FxHashSet<u32>,
     crs: Vec<(u32, SyncType)>,
     fs_out_regs: [Option<SSAValue>; 34],
     end_block_id: u32,
-    ssa_map: HashMap<u32, Vec<SSAValue>>,
-    saturated: HashSet<*const nir_def>,
+    ssa_map: FxHashMap<u32, Vec<SSAValue>>,
+    saturated: FxHashSet<*const nir_def>,
     nir_instr_printer: NirInstrPrinter,
 }
 
diff --git a/src/nouveau/compiler/nak/legalize.rs b/src/nouveau/compiler/nak/legalize.rs
index dc7909e1593..c6539855e5a 100644
--- a/src/nouveau/compiler/nak/legalize.rs
+++ b/src/nouveau/compiler/nak/legalize.rs
@@ -5,7 +5,7 @@ use crate::api::{GetDebugFlags, DEBUG};
 use crate::ir::*;
 use crate::liveness::{BlockLiveness, Liveness, SimpleLiveness};
 
-use std::collections::{HashMap, HashSet};
+use rustc_hash::{FxHashMap, FxHashSet};
 
 pub type LegalizeBuilder<'a> = SSAInstrBuilder<'a>;
 
@@ -345,7 +345,7 @@ fn legalize_instr(
     b: &mut LegalizeBuilder,
     bl: &impl BlockLiveness,
     block_uniform: bool,
-    pinned: &HashSet<SSARef>,
+    pinned: &FxHashSet<SSARef>,
     ip: usize,
     instr: &mut Instr,
 ) {
@@ -439,8 +439,8 @@ fn legalize_instr(
 
     sm.legalize_op(b, &mut instr.op);
 
-    let mut vec_src_map: HashMap<SSARef, SSARef> = Default::default();
-    let mut vec_comps = HashSet::new();
+    let mut vec_src_map: FxHashMap<SSARef, SSARef> = Default::default();
+    let mut vec_comps: FxHashSet<_> = Default::default();
     for src in instr.srcs_mut() {
         if let SrcRef::SSA(vec) = &src.src_ref {
             if vec.comps() == 1 {
@@ -482,7 +482,7 @@ impl Shader<'_> {
         let sm = self.sm;
         for f in &mut self.functions {
             let live = SimpleLiveness::for_function(f);
-            let mut pinned = HashSet::new();
+            let mut pinned: FxHashSet<_> = Default::default();
 
             for (bi, b) in f.blocks.iter_mut().enumerate() {
                 let bl = live.block_live(bi);
diff --git a/src/nouveau/compiler/nak/liveness.rs b/src/nouveau/compiler/nak/liveness.rs
index f94ee8c86f5..2ca1337fa5e 100644
--- a/src/nouveau/compiler/nak/liveness.rs
+++ b/src/nouveau/compiler/nak/liveness.rs
@@ -4,14 +4,14 @@
 use crate::ir::*;
 
 use compiler::bitset::BitSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 use std::cell::RefCell;
 use std::cmp::{max, Ord, Ordering};
-use std::collections::{hash_set, HashMap, HashSet};
 
 #[derive(Clone)]
 pub struct LiveSet {
     live: PerRegFile<u32>,
-    set: HashSet<SSAValue>,
+    set: FxHashSet<SSAValue>,
 }
 
 impl LiveSet {
@@ -39,7 +39,7 @@ impl LiveSet {
         }
     }
 
-    pub fn iter(&self) -> hash_set::Iter<SSAValue> {
+    pub fn iter(&self) -> impl Iterator<Item = &SSAValue> {
         self.set.iter()
     }
 
@@ -151,7 +151,7 @@ pub trait BlockLiveness {
         let vec_dst_live = live;
 
         // Use a hash set because sources may occur more than once
-        let mut killed = HashSet::new();
+        let mut killed: FxHashSet<_> = Default::default();
         instr.for_each_ssa_use(|ssa| {
             if !self.is_live_after_ip(ssa, ip) {
                 killed.insert(*ssa);
@@ -230,7 +230,7 @@ pub trait Liveness {
 pub struct SimpleBlockLiveness {
     defs: BitSet,
     uses: BitSet,
-    last_use: HashMap<u32, usize>,
+    last_use: FxHashMap<u32, usize>,
     live_in: BitSet,
     live_out: BitSet,
 }
@@ -277,7 +277,7 @@ impl BlockLiveness for SimpleBlockLiveness {
 }
 
 pub struct SimpleLiveness {
-    ssa_block_ip: HashMap<SSAValue, (usize, usize)>,
+    ssa_block_ip: FxHashMap<SSAValue, (usize, usize)>,
     blocks: Vec<SimpleBlockLiveness>,
 }
 
@@ -399,7 +399,7 @@ impl SSAUseDef {
 
 pub struct NextUseBlockLiveness {
     num_instrs: usize,
-    ssa_map: HashMap<SSAValue, SSAUseDef>,
+    ssa_map: FxHashMap<SSAValue, SSAUseDef>,
 }
 
 impl NextUseBlockLiveness {
diff --git a/src/nouveau/compiler/nak/lower_par_copies.rs b/src/nouveau/compiler/nak/lower_par_copies.rs
index f91aa0ede2f..49d400bf2ff 100644
--- a/src/nouveau/compiler/nak/lower_par_copies.rs
+++ b/src/nouveau/compiler/nak/lower_par_copies.rs
@@ -6,7 +6,7 @@ use crate::{
     ir::*,
 };
 
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 struct CopyNode {
     num_reads: usize,
@@ -93,7 +93,7 @@ fn cycle_use_swap(pc: &OpParCopy, file: RegFile) -> bool {
 fn lower_par_copy(pc: OpParCopy, sm: &dyn ShaderModel) -> MappedInstrs {
     let mut graph = CopyGraph::new();
     let mut vals = Vec::new();
-    let mut reg_to_idx = HashMap::new();
+    let mut reg_to_idx = FxHashMap::default();
 
     for (i, (dst, _)) in pc.dsts_srcs.iter().enumerate() {
         // Destinations must be pairwise unique
diff --git a/src/nouveau/compiler/nak/opt_bar_prop.rs b/src/nouveau/compiler/nak/opt_bar_prop.rs
index c26e5b6208e..e630ccb84fe 100644
--- a/src/nouveau/compiler/nak/opt_bar_prop.rs
+++ b/src/nouveau/compiler/nak/opt_bar_prop.rs
@@ -5,11 +5,11 @@ use crate::api::{GetDebugFlags, DEBUG};
 use crate::ir::*;
 
 use compiler::bitset::BitSet;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 struct PhiMap {
-    phi_ssa: HashMap<u32, Vec<SSAValue>>,
-    ssa_phi: HashMap<SSAValue, u32>,
+    phi_ssa: FxHashMap<u32, Vec<SSAValue>>,
+    ssa_phi: FxHashMap<SSAValue, u32>,
 }
 
 impl PhiMap {
@@ -49,7 +49,7 @@ impl PhiMap {
 }
 
 struct BarPropPass {
-    ssa_map: HashMap<SSAValue, SSAValue>,
+    ssa_map: FxHashMap<SSAValue, SSAValue>,
     phi_is_bar: BitSet,
     phi_is_not_bar: BitSet,
 }
diff --git a/src/nouveau/compiler/nak/opt_copy_prop.rs b/src/nouveau/compiler/nak/opt_copy_prop.rs
index 80917192cac..82d894cdf4a 100644
--- a/src/nouveau/compiler/nak/opt_copy_prop.rs
+++ b/src/nouveau/compiler/nak/opt_copy_prop.rs
@@ -3,7 +3,7 @@
 
 use crate::ir::*;
 
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 enum CBufRule {
     Yes,
@@ -61,7 +61,7 @@ enum CopyPropEntry {
 
 struct CopyPropPass<'a> {
     sm: &'a dyn ShaderModel,
-    ssa_map: HashMap<SSAValue, CopyPropEntry>,
+    ssa_map: FxHashMap<SSAValue, CopyPropEntry>,
 }
 
 impl<'a> CopyPropPass<'a> {
diff --git a/src/nouveau/compiler/nak/opt_crs.rs b/src/nouveau/compiler/nak/opt_crs.rs
index d1d579faa4f..d9cc3ef37c6 100644
--- a/src/nouveau/compiler/nak/opt_crs.rs
+++ b/src/nouveau/compiler/nak/opt_crs.rs
@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: MIT
 
 use crate::ir::*;
-use std::collections::HashSet;
+
+use rustc_hash::FxHashSet;
 
 fn opt_crs(f: &mut Function) {
-    let mut live_targets = HashSet::new();
+    let mut live_targets: FxHashSet<Label> = Default::default();
     for b in f.blocks.iter() {
         let Some(instr) = b.instrs.last() else {
             continue;
diff --git a/src/nouveau/compiler/nak/opt_jump_thread.rs b/src/nouveau/compiler/nak/opt_jump_thread.rs
index 08ad066677e..c5434a5ad3d 100644
--- a/src/nouveau/compiler/nak/opt_jump_thread.rs
+++ b/src/nouveau/compiler/nak/opt_jump_thread.rs
@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: MIT
 
 use crate::ir::*;
+
 use compiler::cfg::CFGBuilder;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 fn clone_branch(op: &Op) -> Op {
     match op {
@@ -31,7 +32,7 @@ fn jump_thread(func: &mut Function) -> bool {
     let mut progress = false;
 
     // A branch to label can be replaced with Op
-    let mut replacements: HashMap<Label, Op> = Default::default();
+    let mut replacements: FxHashMap<Label, Op> = Default::default();
 
     // Invariant 1: At the end of each loop iteration,
     //              every trivial block with an index in [i, blocks.len())
diff --git a/src/nouveau/compiler/nak/opt_lop.rs b/src/nouveau/compiler/nak/opt_lop.rs
index 88d6f43853b..a6761891855 100644
--- a/src/nouveau/compiler/nak/opt_lop.rs
+++ b/src/nouveau/compiler/nak/opt_lop.rs
@@ -3,7 +3,7 @@
 
 use crate::ir::*;
 
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::slice;
 
 struct LopEntry {
@@ -13,8 +13,8 @@ struct LopEntry {
 }
 
 struct LopPass {
-    use_counts: HashMap<SSAValue, u32>,
-    ssa_lop: HashMap<SSAValue, LopEntry>,
+    use_counts: FxHashMap<SSAValue, u32>,
+    ssa_lop: FxHashMap<SSAValue, LopEntry>,
 }
 
 fn src_as_bool(src: &Src) -> Option<bool> {
@@ -28,7 +28,7 @@ fn src_as_bool(src: &Src) -> Option<bool> {
 
 impl LopPass {
     fn new(f: &Function) -> LopPass {
-        let mut use_counts = HashMap::new();
+        let mut use_counts = FxHashMap::default();
         for b in &f.blocks {
             for instr in &b.instrs {
                 if let PredRef::SSA(ssa) = instr.pred.pred_ref {
diff --git a/src/nouveau/compiler/nak/opt_prmt.rs b/src/nouveau/compiler/nak/opt_prmt.rs
index 7e8ad660f30..416452ce966 100644
--- a/src/nouveau/compiler/nak/opt_prmt.rs
+++ b/src/nouveau/compiler/nak/opt_prmt.rs
@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: MIT
  */
 
-use std::collections::HashMap;
-
 use crate::ir::*;
 
+use rustc_hash::FxHashMap;
+
 struct PrmtSrcs {
     srcs: [SrcRef; 2],
     num_srcs: usize,
@@ -82,7 +82,7 @@ struct PrmtEntry {
 }
 
 struct PrmtPass {
-    ssa_prmt: HashMap<SSAValue, PrmtEntry>,
+    ssa_prmt: FxHashMap<SSAValue, PrmtEntry>,
 }
 
 impl PrmtPass {
diff --git a/src/nouveau/compiler/nak/opt_uniform_instrs.rs b/src/nouveau/compiler/nak/opt_uniform_instrs.rs
index 8eb64d17e46..d1d92682a83 100644
--- a/src/nouveau/compiler/nak/opt_uniform_instrs.rs
+++ b/src/nouveau/compiler/nak/opt_uniform_instrs.rs
@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: MIT
 
 use crate::ir::*;
-use std::collections::HashMap;
+
+use rustc_hash::FxHashMap;
 
 fn should_lower_to_warp(
     sm: &dyn ShaderModel,
     instr: &Instr,
-    r2ur: &HashMap<SSAValue, SSAValue>,
+    r2ur: &FxHashMap<SSAValue, SSAValue>,
 ) -> bool {
     if !sm.op_can_be_uniform(&instr.op) {
         return true;
@@ -25,7 +26,7 @@ fn should_lower_to_warp(
 
 fn propagate_r2ur(
     instr: &mut Instr,
-    r2ur: &HashMap<SSAValue, SSAValue>,
+    r2ur: &FxHashMap<SSAValue, SSAValue>,
 ) -> bool {
     let mut progress = false;
 
diff --git a/src/nouveau/compiler/nak/repair_ssa.rs b/src/nouveau/compiler/nak/repair_ssa.rs
index 828253f52f5..e1b38677453 100644
--- a/src/nouveau/compiler/nak/repair_ssa.rs
+++ b/src/nouveau/compiler/nak/repair_ssa.rs
@@ -5,21 +5,22 @@ use crate::ir::*;
 use crate::union_find::UnionFind;
 
 use compiler::bitset::BitSet;
+use rustc_hash::FxHashMap;
 use std::cell::RefCell;
 use std::cmp::Reverse;
-use std::collections::{BinaryHeap, HashMap};
+use std::collections::BinaryHeap;
 
 struct Phi {
     idx: u32,
     orig: SSAValue,
     dst: SSAValue,
-    srcs: HashMap<usize, SSAValue>,
+    srcs: FxHashMap<usize, SSAValue>,
 }
 
 struct DefTrackerBlock {
     pred: Vec<usize>,
     succ: Vec<usize>,
-    defs: RefCell<HashMap<SSAValue, SSAValue>>,
+    defs: RefCell<FxHashMap<SSAValue, SSAValue>>,
     phis: RefCell<Vec<Phi>>,
 }
 
@@ -161,7 +162,7 @@ impl Function {
         // us to skip any SSA values which only have a single definition in
         // later passes.
         let mut has_mult_defs = false;
-        let mut num_defs = HashMap::new();
+        let mut num_defs = FxHashMap::default();
         for b in &self.blocks {
             for instr in &b.instrs {
                 instr.for_each_ssa_def(|ssa| {
diff --git a/src/nouveau/compiler/nak/sm20.rs b/src/nouveau/compiler/nak/sm20.rs
index d68060c045e..f34ac0fab01 100644
--- a/src/nouveau/compiler/nak/sm20.rs
+++ b/src/nouveau/compiler/nak/sm20.rs
@@ -10,8 +10,9 @@ use bitview::{
     SetFieldU64,
 };
 
+use rustc_hash::FxHashMap;
 use std::fmt;
-use std::{collections::HashMap, ops::Range};
+use std::ops::Range;
 
 pub struct ShaderModel20 {
     sm: u8,
@@ -191,7 +192,7 @@ trait SM20Op {
 struct SM20Encoder<'a> {
     sm: &'a ShaderModel20,
     ip: usize,
-    labels: &'a HashMap<Label, usize>,
+    labels: &'a FxHashMap<Label, usize>,
     inst: [u32; 2],
 }
 
@@ -2691,7 +2692,7 @@ fn encode_sm20_shader(sm: &ShaderModel20, s: &Shader<'_>) -> Vec<u32> {
     let func = &s.functions[0];
 
     let mut ip = 0_usize;
-    let mut labels = HashMap::new();
+    let mut labels = FxHashMap::default();
     for b in &func.blocks {
         // We ensure blocks will have groups of 7 instructions with a
         // schedule instruction before each groups.  As we should never jump
diff --git a/src/nouveau/compiler/nak/sm32.rs b/src/nouveau/compiler/nak/sm32.rs
index 4de0eab4f97..cbef2f478aa 100644
--- a/src/nouveau/compiler/nak/sm32.rs
+++ b/src/nouveau/compiler/nak/sm32.rs
@@ -10,7 +10,8 @@ use bitview::{
     SetFieldU64,
 };
 
-use std::{collections::HashMap, ops::Range};
+use rustc_hash::FxHashMap;
+use std::ops::Range;
 
 pub struct ShaderModel32 {
     sm: u8,
@@ -154,7 +155,7 @@ fn true_reg() -> RegRef {
 struct SM32Encoder<'a> {
     sm: &'a ShaderModel32,
     ip: usize,
-    labels: &'a HashMap<Label, usize>,
+    labels: &'a FxHashMap<Label, usize>,
     inst: [u32; 2],
     sched: u8,
 }
@@ -3056,7 +3057,7 @@ fn as_sm32_op_mut(op: &mut Op) -> &mut dyn SM32Op {
 fn encode_instr(
     instr: Option<&Box<Instr>>,
     sm: &ShaderModel32,
-    labels: &HashMap<Label, usize>,
+    labels: &FxHashMap<Label, usize>,
     encoded: &mut Vec<u32>,
 ) -> u8 {
     let mut e = SM32Encoder {
@@ -3088,7 +3089,7 @@ fn encode_sm32_shader(sm: &ShaderModel32, s: &Shader<'_>) -> Vec<u32> {
     let func = &s.functions[0];
 
     let mut ip = 0_usize;
-    let mut labels = HashMap::new();
+    let mut labels = FxHashMap::default();
     for b in &func.blocks {
         // We ensure blocks will have groups of 7 instructions with a
         // schedule instruction before each groups.  As we should never jump
diff --git a/src/nouveau/compiler/nak/sm50.rs b/src/nouveau/compiler/nak/sm50.rs
index cfd88d6496f..23f6c4c1af9 100644
--- a/src/nouveau/compiler/nak/sm50.rs
+++ b/src/nouveau/compiler/nak/sm50.rs
@@ -7,7 +7,7 @@ use crate::legalize::{
 };
 use bitview::*;
 
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::ops::Range;
 
 pub fn instr_latency(_sm: u8, op: &Op, dst_idx: usize) -> u32 {
@@ -179,7 +179,7 @@ trait SM50Op {
 struct SM50Encoder<'a> {
     sm: &'a ShaderModel50,
     ip: usize,
-    labels: &'a HashMap<Label, usize>,
+    labels: &'a FxHashMap<Label, usize>,
     inst: [u32; 2],
     sched: u32,
 }
@@ -3349,7 +3349,7 @@ fn encode_instr(
     instr_index: usize,
     instr: Option<&Box<Instr>>,
     sm: &ShaderModel50,
-    labels: &HashMap<Label, usize>,
+    labels: &FxHashMap<Label, usize>,
     ip: &mut usize,
     sched_instr: &mut [u32; 2],
 ) -> [u32; 2] {
@@ -3385,7 +3385,7 @@ fn encode_sm50_shader(sm: &ShaderModel50, s: &Shader<'_>) -> Vec<u32> {
     let func = &s.functions[0];
 
     let mut num_instrs = 0_usize;
-    let mut labels = HashMap::new();
+    let mut labels = FxHashMap::default();
     for b in &func.blocks {
         // We ensure blocks will have groups of 3 instructions with a
         // schedule instruction before each groups.  As we should never jump
diff --git a/src/nouveau/compiler/nak/sm70_encode.rs b/src/nouveau/compiler/nak/sm70_encode.rs
index 7ea7ef30b60..17227788cda 100644
--- a/src/nouveau/compiler/nak/sm70_encode.rs
+++ b/src/nouveau/compiler/nak/sm70_encode.rs
@@ -8,7 +8,7 @@ use crate::legalize::{
 };
 use bitview::*;
 
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::ops::Range;
 
 /// A per-op trait that implements Volta+ opcode semantics
@@ -20,7 +20,7 @@ trait SM70Op {
 struct SM70Encoder<'a> {
     sm: u8,
     ip: usize,
-    labels: &'a HashMap<Label, usize>,
+    labels: &'a FxHashMap<Label, usize>,
     inst: [u32; 4],
 }
 
@@ -3778,7 +3778,7 @@ pub fn encode_sm70_shader(sm: &dyn ShaderModel, s: &Shader<'_>) -> Vec<u32> {
     let func = &s.functions[0];
 
     let mut ip = 0_usize;
-    let mut labels = HashMap::new();
+    let mut labels = FxHashMap::default();
     for b in &func.blocks {
         labels.insert(b.label, ip);
         for instr in &b.instrs {
diff --git a/src/nouveau/compiler/nak/spill_values.rs b/src/nouveau/compiler/nak/spill_values.rs
index 137622278e6..aed1d67ba46 100644
--- a/src/nouveau/compiler/nak/spill_values.rs
+++ b/src/nouveau/compiler/nak/spill_values.rs
@@ -9,12 +9,13 @@ use crate::liveness::{
 };
 
 use compiler::bitset::BitSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 use std::cell::RefCell;
 use std::cmp::{max, Ordering, Reverse};
-use std::collections::{BinaryHeap, HashMap, HashSet};
+use std::collections::BinaryHeap;
 
 struct PhiDstMap {
-    ssa_phi: HashMap<SSAValue, u32>,
+    ssa_phi: FxHashMap<SSAValue, u32>,
 }
 
 impl PhiDstMap {
@@ -46,7 +47,7 @@ impl PhiDstMap {
 }
 
 struct PhiSrcMap {
-    phi_src: HashMap<u32, SSAValue>,
+    phi_src: FxHashMap<u32, SSAValue>,
 }
 
 impl PhiSrcMap {
@@ -283,7 +284,7 @@ struct SpillCache<'a, S: Spill> {
     alloc: &'a mut SSAValueAllocator,
     spill: S,
     const_tracker: ConstTracker,
-    val_spill: HashMap<SSAValue, SSAValue>,
+    val_spill: FxHashMap<SSAValue, SSAValue>,
 }
 
 impl<'a, S: Spill> SpillCache<'a, S> {
@@ -346,7 +347,7 @@ impl<'a, S: Spill> SpillCache<'a, S> {
 
 struct SpillChooser<'a> {
     bl: &'a NextUseBlockLiveness,
-    pinned: &'a HashSet<SSAValue>,
+    pinned: &'a FxHashSet<SSAValue>,
     ip: usize,
     count: usize,
     spills: BinaryHeap<Reverse<SSANextUse>>,
@@ -360,7 +361,7 @@ struct SpillChoiceIter {
 impl<'a> SpillChooser<'a> {
     pub fn new(
         bl: &'a NextUseBlockLiveness,
-        pinned: &'a HashSet<SSAValue>,
+        pinned: &'a FxHashSet<SSAValue>,
         ip: usize,
         count: usize,
     ) -> Self {
@@ -429,9 +430,9 @@ struct SSAState {
     w: LiveSet,
     // The set of variables which have already been spilled.  These don't need
     // to be spilled again.
-    s: HashSet<SSAValue>,
+    s: FxHashSet<SSAValue>,
     // The set of pinned variables
-    p: HashSet<SSAValue>,
+    p: FxHashSet<SSAValue>,
 }
 
 fn spill_values<S: Spill>(
@@ -447,7 +448,7 @@ fn spill_values<S: Spill>(
     // Record the set of SSA values used within each loop
     let mut phi_dst_maps = Vec::new();
     let mut phi_src_maps = Vec::new();
-    let mut loop_uses = HashMap::new();
+    let mut loop_uses = FxHashMap::default();
     for b_idx in 0..blocks.len() {
         phi_dst_maps.push(PhiDstMap::from_block(&blocks[b_idx]));
         phi_src_maps.push(PhiSrcMap::from_block(&blocks[b_idx]));
@@ -455,8 +456,8 @@ fn spill_values<S: Spill>(
         if let Some(lh_idx) = blocks.loop_header_index(b_idx) {
             let uses = loop_uses
                 .entry(lh_idx)
-                .or_insert_with(|| RefCell::new(HashSet::new()));
-            let uses = uses.get_mut();
+                .or_insert_with(|| RefCell::new(Default::default()));
+            let uses: &mut FxHashSet<_> = uses.get_mut();
 
             for instr in &blocks[b_idx].instrs {
                 instr.for_each_ssa_use(|ssa| {
@@ -533,8 +534,8 @@ fn spill_values<S: Spill>(
             debug_assert!(w.count(file) <= limit);
             w
         } else if blocks.is_loop_header(b_idx) {
-            let mut i_b: HashSet<SSAValue> =
-                HashSet::from_iter(bl.iter_live_in().cloned());
+            let mut i_b: FxHashSet<SSAValue> =
+                FxHashSet::from_iter(bl.iter_live_in().cloned());
 
             if let Some(phi) = blocks[b_idx].phi_dsts() {
                 for (_, dst) in phi.dsts.iter() {
@@ -592,7 +593,7 @@ fn spill_values<S: Spill>(
                 num_preds: usize,
                 next_use: usize,
             }
-            let mut live: HashMap<SSAValue, SSAPredInfo> = Default::default();
+            let mut live: FxHashMap<SSAValue, SSAPredInfo> = Default::default();
 
             for p_idx in &preds {
                 let phi_src_map = &phi_src_maps[*p_idx];
@@ -637,14 +638,14 @@ fn spill_values<S: Spill>(
         };
 
         let s = if preds.is_empty() {
-            HashSet::new()
+            Default::default()
         } else if preds.len() == 1 {
             let p_s = &ssa_state_out[preds[0]].s;
-            HashSet::from_iter(
+            FxHashSet::from_iter(
                 p_s.iter().filter(|ssa| bl.is_live_in(ssa)).cloned(),
             )
         } else {
-            let mut s = HashSet::new();
+            let mut s: FxHashSet<_> = Default::default();
             for p_idx in &preds {
                 if *p_idx >= b_idx {
                     continue;
@@ -676,7 +677,7 @@ fn spill_values<S: Spill>(
             s
         };
 
-        let mut p = HashSet::new();
+        let mut p: FxHashSet<_> = Default::default();
         for p_idx in &preds {
             if *p_idx < b_idx {
                 let p_p = &ssa_state_out[*p_idx].p;
@@ -786,8 +787,8 @@ fn spill_values<S: Spill>(
                             }
                         }
 
-                        let spills: HashSet<SSAValue> =
-                            HashSet::from_iter(spills);
+                        let spills: FxHashSet<SSAValue> =
+                            FxHashSet::from_iter(spills);
 
                         for (dst, src) in pcopy.dsts_srcs.iter_mut() {
                             let dst_ssa = &dst.as_ssa().unwrap()[0];
diff --git a/src/nouveau/compiler/nak/to_cssa.rs b/src/nouveau/compiler/nak/to_cssa.rs
index 2d548a5606b..09a55aff1b9 100644
--- a/src/nouveau/compiler/nak/to_cssa.rs
+++ b/src/nouveau/compiler/nak/to_cssa.rs
@@ -6,7 +6,7 @@ use crate::ir::*;
 use crate::liveness::{BlockLiveness, Liveness, SimpleLiveness};
 
 use compiler::cfg::CFG;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::iter::Peekable;
 
 struct MergedIter<I: Iterator> {
@@ -72,8 +72,8 @@ struct CoalesceGraph<'a> {
     live: &'a SimpleLiveness,
     nodes: Vec<CoalesceNode>,
     sets: Vec<CoalesceSet>,
-    ssa_node: HashMap<SSAValue, usize>,
-    phi_node_file: HashMap<u32, (usize, RegFile)>,
+    ssa_node: FxHashMap<SSAValue, usize>,
+    phi_node_file: FxHashMap<u32, (usize, RegFile)>,
 }
 
 impl<'a> CoalesceGraph<'a> {