WIP

Author: Grarak

src/bitset.rs

@@ -0,0 +1,160 @@
+use std::ops::{Add, AddAssign, BitAnd, BitXor, BitXorAssign, Not, Sub, SubAssign};
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct Bitset<const SIZE: usize>(pub [u32; SIZE]);
+
+impl<const SIZE: usize> Bitset<SIZE> {
+    pub const fn new() -> Self {
+        Bitset([0; SIZE])
+    }
+
+    fn _add(&mut self, bit: impl Into<usize>) {
+        let bit = bit.into();
+        let array_index = bit >> 5;
+        let pos_index = bit & 31;
+        self.0[array_index] |= 1 << pos_index;
+    }
+
+    fn _sub(&mut self, bit: impl Into<usize>) {
+        let bit = bit.into();
+        let array_index = bit >> 5;
+        let pos_index = bit & 31;
+        self.0[array_index] &= !(1 << pos_index);
+    }
+
+    pub fn contains(&self, bit: impl Into<usize>) -> bool {
+        let bit = bit.into();
+        let array_index = bit >> 5;
+        let pos_index = bit & 31;
+        self.0[array_index] & (1 << pos_index) != 0
+    }
+
+    pub const fn len(&self) -> usize {
+        let mut sum = 0;
+        let mut i = 0;
+        while i < self.0.len() {
+            sum += self.0[i].count_ones();
+            i += 1;
+        }
+        sum as usize
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<const SIZE: usize> Default for Bitset<SIZE> {
+    fn default() -> Self {
+        Bitset([0; SIZE])
+    }
+}
+
+impl<const SIZE: usize, T: Into<usize>> Add<T> for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn add(mut self, rhs: T) -> Self::Output {
+        self._add(rhs);
+        self
+    }
+}
+
+impl<const SIZE: usize, T: Into<usize>> AddAssign<T> for Bitset<SIZE> {
+    fn add_assign(&mut self, rhs: T) {
+        self._add(rhs)
+    }
+}
+
+impl<const SIZE: usize, T: Into<usize>> Sub<T> for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn sub(mut self, rhs: T) -> Self::Output {
+        self._sub(rhs);
+        self
+    }
+}
+
+impl<const SIZE: usize, T: Into<usize>> SubAssign<T> for Bitset<SIZE> {
+    fn sub_assign(&mut self, rhs: T) {
+        self._sub(rhs);
+    }
+}
+
+impl<const SIZE: usize> Add<Bitset<SIZE>> for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn add(mut self, rhs: Bitset<SIZE>) -> Self::Output {
+        for i in 0..self.0.len() {
+            self.0[i] |= rhs.0[i];
+        }
+        self
+    }
+}
+
+impl<const SIZE: usize> AddAssign<Bitset<SIZE>> for Bitset<SIZE> {
+    fn add_assign(&mut self, rhs: Bitset<SIZE>) {
+        for i in 0..self.0.len() {
+            self.0[i] |= rhs.0[i];
+        }
+    }
+}
+
+impl<const SIZE: usize> Sub<Bitset<SIZE>> for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn sub(mut self, rhs: Bitset<SIZE>) -> Self::Output {
+        for i in 0..self.0.len() {
+            self.0[i] &= !rhs.0[i];
+        }
+        self
+    }
+}
+
+impl<const SIZE: usize> SubAssign<Bitset<SIZE>> for Bitset<SIZE> {
+    fn sub_assign(&mut self, rhs: Bitset<SIZE>) {
+        for i in 0..self.0.len() {
+            self.0[i] &= !rhs.0[i];
+        }
+    }
+}
+
+impl<const SIZE: usize> BitAnd<Bitset<SIZE>> for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn bitand(mut self, rhs: Bitset<SIZE>) -> Self::Output {
+        for i in 0..self.0.len() {
+            self.0[i] &= rhs.0[i];
+        }
+        self
+    }
+}
+
+impl<const SIZE: usize> BitXor<Bitset<SIZE>> for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn bitxor(mut self, rhs: Bitset<SIZE>) -> Self::Output {
+        for i in 0..self.0.len() {
+            self.0[i] ^= rhs.0[i];
+        }
+        self
+    }
+}
+
+impl<const SIZE: usize> BitXorAssign for Bitset<SIZE> {
+    fn bitxor_assign(&mut self, rhs: Self) {
+        for i in 0..self.0.len() {
+            self.0[i] ^= rhs.0[i];
+        }
+    }
+}
+
+impl<const SIZE: usize> Not for Bitset<SIZE> {
+    type Output = Bitset<SIZE>;
+
+    fn not(mut self) -> Self::Output {
+        for i in 0..self.0.len() {
+            self.0[i] = !self.0[i];
+        }
+        self
+    }
+}

src/jit/assembler/basic_block.rs

@@ -5,7 +5,7 @@ use crate::jit::assembler::block_reg_set::BlockRegSet;
 use crate::jit::assembler::{BlockAsmBuf, BlockInst};
 use crate::jit::reg::{Reg, RegReserve};
 use crate::jit::{MemoryAmount, ShiftType};
-use crate::utils::{BuildNoHasher, NoHashSet};
+use crate::IS_DEBUG;
 use std::fmt::{Debug, Formatter};
 
 pub struct BasicBlock {
@@ -18,8 +18,8 @@ pub struct BasicBlock {
     pub regs_live_ranges: Vec<BlockRegSet>,
     pub used_regs: Vec<BlockRegSet>,
 
-    pub enter_blocks: NoHashSet<usize>,
-    pub exit_blocks: NoHashSet<usize>,
+    pub enter_blocks: Vec<usize>,
+    pub exit_blocks: Vec<usize>,
 
     pub insts_link: BlockInstList,
 
@@ -38,8 +38,8 @@ impl BasicBlock {
             regs_live_ranges: Vec::new(),
             used_regs: Vec::new(),
 
-            enter_blocks: NoHashSet::default(),
-            exit_blocks: NoHashSet::with_capacity_and_hasher(2, BuildNoHasher),
+            enter_blocks: Vec::new(),
+            exit_blocks: Vec::with_capacity(2),
 
             insts_link: BlockInstList::new(),
 
@@ -376,13 +376,13 @@ impl BasicBlock {
         }
     }
 
-    pub fn emit_opcodes(&self, asm: &mut BlockAsm, branch_placeholders: &mut Vec<usize>, opcodes_offset: usize) -> Vec<u32> {
+    pub fn emit_opcodes(&self, asm: &mut BlockAsm, branch_placeholders: &mut Vec<usize>, opcodes_offset: usize, used_host_regs: RegReserve) -> Vec<u32> {
         let mut opcodes = Vec::new();
         let mut inst_opcodes = Vec::new();
         for entry in self.insts_link.iter() {
             let inst = &mut asm.buf.insts[entry.value];
 
-            if unsafe { BLOCK_LOG } {
+            if IS_DEBUG && unsafe { BLOCK_LOG } {
                 match inst {
                     BlockInst::GuestPc(pc) => {
                         println!("(0x{:x}, 0x{pc:x}),", opcodes.len() + opcodes_offset);
@@ -397,7 +397,7 @@ impl BasicBlock {
             }
 
             inst_opcodes.clear();
-            inst.emit_opcode(&mut inst_opcodes, opcodes.len(), branch_placeholders, opcodes_offset);
+            inst.emit_opcode(&mut inst_opcodes, opcodes.len(), branch_placeholders, opcodes_offset, used_host_regs);
             opcodes.extend(&inst_opcodes);
         }
         opcodes