From e1be53e26623403ccb4e1ce10a4f59d88918a212 Mon Sep 17 00:00:00 2001 From: Faith Ekstrand Date: Mon, 10 Apr 2023 17:23:25 -0500 Subject: [PATCH] nak: Get rid of the BitSet and BitSetMut traits Part-of: --- src/nouveau/compiler/bitset.rs | 106 ++++++++++++++---------- src/nouveau/compiler/nak_encode_sm75.rs | 16 ++-- 2 files changed, 73 insertions(+), 49 deletions(-) diff --git a/src/nouveau/compiler/bitset.rs b/src/nouveau/compiler/bitset.rs index e20f1468af6..05f8758b3ba 100644 --- a/src/nouveau/compiler/bitset.rs +++ b/src/nouveau/compiler/bitset.rs @@ -11,6 +11,7 @@ use std::ops::Range; pub trait BitSetViewable { fn bits(&self) -> usize; + fn get_bit_range_u64(&self, range: Range) -> u64; } @@ -18,29 +19,6 @@ pub trait BitSetMutViewable: BitSetViewable { fn set_bit_range_u64(&mut self, range: Range, val: u64); } -pub trait BitSet: BitSetViewable { - fn get_bit(&self, bit: usize) -> bool { - self.get_bit_range_u64(bit..(bit + 1)) != 0 - } - - fn subset<'a>(&'a self, range: Range) -> BitSetView<'a, Self> { - BitSetView::new_subset(self, range) - } -} - -pub trait BitSetMut: BitSetMutViewable { - fn set_bit(&mut self, bit: usize, val: bool) { - self.set_bit_range_u64(bit..(bit + 1), u64::from(val)); - } - - fn subset_mut<'a>( - &'a mut self, - range: Range, - ) -> BitSetMutView<'a, Self> { - BitSetMutView::new_subset(self, range) - } -} - fn u64_mask_for_bits(bits: usize) -> u64 { assert!(bits > 0 && bits <= 64); !0u64 >> (64 - bits) @@ -169,7 +147,7 @@ impl<'a, BS: BitSetViewable + ?Sized> BitSetView<'a, BS> { } } - fn new_subset(parent: &'a BS, range: Range) -> Self { + pub fn new_subset(parent: &'a BS, range: Range) -> Self { assert!(range.end <= parent.bits()); Self { parent: parent, @@ -177,12 +155,23 @@ impl<'a, BS: BitSetViewable + ?Sized> BitSetView<'a, BS> { } } + pub fn subset( + &'a self, + range: Range, + ) -> BitSetView<'a, BitSetView<'a, BS>> { + BitSetView::new_subset(self, range) + } + fn range_in_parent(&self, range: Range) -> Range { let new_start = self.range.start + range.start; let new_end = self.range.start + range.end; assert!(new_end <= self.range.end); new_start..new_end } + + pub fn get_bit(&self, bit: usize) -> bool { + self.get_bit_range_u64(bit..(bit + 1)) != 0 + } } impl<'a, BS: BitSetViewable + ?Sized> BitSetViewable for BitSetView<'a, BS> { @@ -195,8 +184,6 @@ impl<'a, BS: BitSetViewable + ?Sized> BitSetViewable for BitSetView<'a, BS> { } } -impl<'a, BS: BitSetViewable + ?Sized> BitSet for BitSetView<'a, BS> {} - pub struct BitSetMutView<'a, BS: BitSetMutViewable + ?Sized> { parent: &'a mut BS, range: Range, @@ -211,7 +198,7 @@ impl<'a, BS: BitSetMutViewable + ?Sized> BitSetMutView<'a, BS> { } } - fn new_subset(parent: &'a mut BS, range: Range) -> Self { + pub fn new_subset(parent: &'a mut BS, range: Range) -> Self { assert!(range.end <= parent.bits()); Self { parent: parent, @@ -219,12 +206,27 @@ impl<'a, BS: BitSetMutViewable + ?Sized> BitSetMutView<'a, BS> { } } + pub fn subset_mut<'b>( + &'b mut self, + range: Range, + ) -> BitSetMutView<'b, BitSetMutView<'a, BS>> { + BitSetMutView::new_subset(self, range) + } + fn range_in_parent(&self, range: Range) -> Range { let new_start = self.range.start + range.start; let new_end = self.range.start + range.end; assert!(new_end <= self.range.end); new_start..new_end } + + pub fn get_bit(&self, bit: usize) -> bool { + self.get_bit_range_u64(bit..(bit + 1)) != 0 + } + + pub fn set_bit(&mut self, bit: usize, val: bool) { + self.set_bit_range_u64(bit..(bit + 1), u64::from(val)); + } } impl<'a, BS: BitSetMutViewable + ?Sized> BitSetViewable @@ -239,8 +241,6 @@ impl<'a, BS: BitSetMutViewable + ?Sized> BitSetViewable } } -impl<'a, BS: BitSetMutViewable + ?Sized> BitSet for BitSetMutView<'a, BS> {} - impl<'a, BS: BitSetMutViewable + ?Sized> BitSetMutViewable for BitSetMutView<'a, BS> { @@ -250,14 +250,12 @@ impl<'a, BS: BitSetMutViewable + ?Sized> BitSetMutViewable } } -impl<'a, BS: BitSetMutViewable + ?Sized> BitSetMut for BitSetMutView<'a, BS> {} - -pub trait SetField { - fn set_field(&mut self, range: Range, val: T); +pub trait SetFieldU64 { + fn set_field_u64(&mut self, range: Range, val: u64); } -impl<'a, BS: BitSetMut> SetField for BS { - fn set_field(&mut self, range: Range, val: u64) { +impl<'a, BS: BitSetMutViewable + ?Sized> SetFieldU64 for BitSetMutView<'a, BS> { + fn set_field_u64(&mut self, range: Range, val: u64) { let bits = range.end - range.start; /* Check that it fits in the bitfield */ @@ -267,32 +265,52 @@ impl<'a, BS: BitSetMut> SetField for BS { } } -impl<'a, BS: BitSetMut> SetField for BS { +pub trait SetField { + fn set_field(&mut self, range: Range, val: T); +} + +impl<'a, T: SetFieldU64> SetField for T { + fn set_field(&mut self, range: Range, val: u64) { + self.set_field_u64(range, val); + } +} + +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: u32) { self.set_field(range, u64::from(val)); } } -impl<'a, BS: BitSetMut> SetField for BS { +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: u16) { self.set_field(range, u64::from(val)); } } -impl<'a, BS: BitSetMut> SetField for BS { +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: u8) { self.set_field(range, u64::from(val)); } } -impl<'a, BS: BitSetMut> SetField for BS { +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: bool) { assert!(range.end == range.start + 1); self.set_field(range, u64::from(val)); } } -impl<'a, BS: BitSetMut> SetField for BS { +pub trait SetBit { + fn set_bit(&mut self, bit: usize, val: bool); +} + +impl<'a, T: SetFieldU64> SetBit for T { + fn set_bit(&mut self, bit: usize, val: bool) { + self.set_field(bit..(bit + 1), val); + } +} + +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: i64) { let bits = range.end - range.start; let mask = u64_mask_for_bits(bits); @@ -304,23 +322,23 @@ impl<'a, BS: BitSetMut> SetField for BS { let sign_mask = !(mask >> 1); assert!((val & sign_mask) == 0 || (val & sign_mask) == sign_mask); - self.set_bit_range_u64(range, val & mask); + self.set_field_u64(range, val & mask); } } -impl<'a, BS: BitSetMut> SetField for BS { +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: i32) { self.set_field(range, i64::from(val)); } } -impl<'a, BS: BitSetMut> SetField for BS { +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: i16) { self.set_field(range, i64::from(val)); } } -impl<'a, BS: BitSetMut> SetField for BS { +impl<'a, T: SetFieldU64> SetField for T { fn set_field(&mut self, range: Range, val: i8) { self.set_field(range, i64::from(val)); } diff --git a/src/nouveau/compiler/nak_encode_sm75.rs b/src/nouveau/compiler/nak_encode_sm75.rs index d585b9cca40..2c6329013ed 100644 --- a/src/nouveau/compiler/nak_encode_sm75.rs +++ b/src/nouveau/compiler/nak_encode_sm75.rs @@ -101,17 +101,23 @@ impl BitSetViewable for SM75Instr { } } -impl BitSet for SM75Instr {} - impl BitSetMutViewable for SM75Instr { fn set_bit_range_u64(&mut self, range: Range, val: u64) { BitSetMutView::new(&mut self.inst).set_bit_range_u64(range, val); } } -impl BitSetMut for SM75Instr {} +impl SetFieldU64 for SM75Instr { + fn set_field_u64(&mut self, range: Range, val: u64) { + BitSetMutView::new(&mut self.inst).set_field_u64(range, val); + } +} impl SM75Instr { + fn set_bit(&mut self, bit: usize, val: bool) { + BitSetMutView::new(&mut self.inst).set_bit(bit, val); + } + fn set_src_imm(&mut self, range: Range, u: &u32) { assert!(range.len() == 32); self.set_field(range, *u); @@ -184,7 +190,7 @@ impl SM75Instr { } fn set_src_cb(&mut self, range: Range, cb: &CBufRef) { - let mut v = self.subset_mut(range); + let mut v = BitSetMutView::new_subset(self, range); v.set_field(0..16, cb.offset); if let CBuf::Binding(idx) = cb.buf { v.set_field(16..21, idx); @@ -194,7 +200,7 @@ impl SM75Instr { } fn set_src_cx(&mut self, range: Range, cb: &CBufRef) { - let mut v = self.subset_mut(range); + let mut v = BitSetMutView::new_subset(self, range); if let CBuf::BindlessGPR(reg) = cb.buf { assert!(reg.base_idx() <= 63); assert!(reg.file() == RegFile::UGPR);