fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-04-19 14:30:39 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

nak: Get rid of the BitSet and BitSetMut traits

Browse source 
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24998>
This commit is contained in:
Faith Ekstrand 2023-04-10 17:23:25 -05:00 • committed by Marge Bot
parent dadf34c620
commit e1be53e266
2 changed files with 73 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
src/nouveau/compiler/bitset.rs
View file

@ -11,6 +11,7 @@ use std::ops::Range;
pub trait BitSetViewable {
fn bits(&self) -> usize;
fn get_bit_range_u64(&self, range: Range<usize>) -> u64;
}
@ -18,29 +19,6 @@ pub trait BitSetMutViewable: BitSetViewable {
fn set_bit_range_u64(&mut self, range: Range<usize>, 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<usize>) -> 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<usize>,
) -> 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<usize>) -> Self {
pub fn new_subset(parent: &'a BS, range: Range<usize>) -> 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<usize>,
) -> BitSetView<'a, BitSetView<'a, BS>> {
BitSetView::new_subset(self, range)
}
fn range_in_parent(&self, range: Range<usize>) -> Range<usize> {
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<usize>,
@ -211,7 +198,7 @@ impl<'a, BS: BitSetMutViewable + ?Sized> BitSetMutView<'a, BS> {
}
}
fn new_subset(parent: &'a mut BS, range: Range<usize>) -> Self {
pub fn new_subset(parent: &'a mut BS, range: Range<usize>) -> 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<usize>,
) -> BitSetMutView<'b, BitSetMutView<'a, BS>> {
BitSetMutView::new_subset(self, range)
}
fn range_in_parent(&self, range: Range<usize>) -> Range<usize> {
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<T> {
fn set_field(&mut self, range: Range<usize>, val: T);
pub trait SetFieldU64 {
fn set_field_u64(&mut self, range: Range<usize>, val: u64);
}
impl<'a, BS: BitSetMut> SetField<u64> for BS {
fn set_field(&mut self, range: Range<usize>, val: u64) {
impl<'a, BS: BitSetMutViewable + ?Sized> SetFieldU64 for BitSetMutView<'a, BS> {
fn set_field_u64(&mut self, range: Range<usize>, val: u64) {
let bits = range.end - range.start;
/* Check that it fits in the bitfield */
@ -267,32 +265,52 @@ impl<'a, BS: BitSetMut> SetField<u64> for BS {
}
}
impl<'a, BS: BitSetMut> SetField<u32> for BS {
pub trait SetField<T> {
fn set_field(&mut self, range: Range<usize>, val: T);
}
impl<'a, T: SetFieldU64> SetField<u64> for T {
fn set_field(&mut self, range: Range<usize>, val: u64) {
self.set_field_u64(range, val);
}
}
impl<'a, T: SetFieldU64> SetField<u32> for T {
fn set_field(&mut self, range: Range<usize>, val: u32) {
self.set_field(range, u64::from(val));
}
}
impl<'a, BS: BitSetMut> SetField<u16> for BS {
impl<'a, T: SetFieldU64> SetField<u16> for T {
fn set_field(&mut self, range: Range<usize>, val: u16) {
self.set_field(range, u64::from(val));
}
}
impl<'a, BS: BitSetMut> SetField<u8> for BS {
impl<'a, T: SetFieldU64> SetField<u8> for T {
fn set_field(&mut self, range: Range<usize>, val: u8) {
self.set_field(range, u64::from(val));
}
}
impl<'a, BS: BitSetMut> SetField<bool> for BS {
impl<'a, T: SetFieldU64> SetField<bool> for T {
fn set_field(&mut self, range: Range<usize>, val: bool) {
assert!(range.end == range.start + 1);
self.set_field(range, u64::from(val));
}
}
impl<'a, BS: BitSetMut> SetField<i64> 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<i64> for T {
fn set_field(&mut self, range: Range<usize>, val: i64) {
let bits = range.end - range.start;
let mask = u64_mask_for_bits(bits);
@ -304,23 +322,23 @@ impl<'a, BS: BitSetMut> SetField<i64> 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<i32> for BS {
impl<'a, T: SetFieldU64> SetField<i32> for T {
fn set_field(&mut self, range: Range<usize>, val: i32) {
self.set_field(range, i64::from(val));
}
}
impl<'a, BS: BitSetMut> SetField<i16> for BS {
impl<'a, T: SetFieldU64> SetField<i16> for T {
fn set_field(&mut self, range: Range<usize>, val: i16) {
self.set_field(range, i64::from(val));
}
}
impl<'a, BS: BitSetMut> SetField<i8> for BS {
impl<'a, T: SetFieldU64> SetField<i8> for T {
fn set_field(&mut self, range: Range<usize>, val: i8) {
self.set_field(range, i64::from(val));
}

16
src/nouveau/compiler/nak_encode_sm75.rs
View file

@ -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<usize>, 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<usize>, 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<usize>, 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<usize>, 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<usize>, 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);