Make RISC-V instructions accept signed immediates

Now instructions with immediates (both for branches and alu operations) take i32s.

There's also no more attempts to try and take a smaller number which may be misleading. I had to roll my own implementation for signed N bit integers to pass into the instructions properly, since rust does not have arbitrary bit widths unfortunately.

Needs more testing which I will do via another one of my projects that relies on this.

Author: codebycruz

Cargo.toml

@@ -2,7 +2,7 @@
 name = "dasm"
 authors = ["David Cruz <[email protected]>"]
 description = "A tiny, zero dependency assembler"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 keywords = ["assembler", "jit", "dasm", "x86", "codegen"]
 categories = ["os", "no-std", "no-std::no-alloc"]

src/tier/raw/rv32/mod.rs

@@ -7,6 +7,14 @@ macro_rules! bitcat {
 		(bitcat! { acc($a) $b($e) } | bitcat! { acc($a - $b) $($rest)+ })
 	};
 
+	( acc($a:expr) signed $b:literal($e:expr), $($rest:tt)+ ) => {
+		(bitcat! { acc($a) signed $b($e) } | bitcat! { acc($a - $b) $($rest)+ })
+	};
+
+	( acc($a:expr) signed $b:literal($e:expr) ) => {
+		(i32_to_iN::<$b>($e)) << const { $a - $b }
+	};
+
 	( acc($a:expr) $b:literal($e:expr) ) => {
 		($e as u32 & const { (1 << $b) - 1 }) << const { $a - $b }
 	};
@@ -16,126 +24,193 @@ macro_rules! bitcat {
 	};
 }
 
+macro_rules! bits {
+	($start:literal .. $end:literal, $num:expr) => {
+		($num >> $start) & ((1 << ($end - $start)) - 1)
+	};
+
+	($start:literal ..= $end:literal, $num:expr) => {
+		($num >> $start) & ((1 << ($end - $start + 1)) - 1)
+	};
+
+	($bit:literal, $num:expr) => {
+		($num >> $bit) & 1
+	};
+}
+
+#[allow(non_snake_case)]
+fn i32_to_iN<const N: u32>(from: i32) -> u32 {
+	let lower_bits = (1 << (N - 1)) - 1;
+
+	if from.is_negative() {
+		(from as u32) & lower_bits | (1 << (N - 1))
+	} else {
+		(from as u32) & lower_bits
+	}
+}
+
+#[test]
+fn test_i32_reinterpret() {
+	assert_eq!(i32_to_iN::<4>(-1), 0b1111);
+	assert_eq!(i32_to_iN::<5>(-1), 0b11111);
+	assert_eq!(i32_to_iN::<4>(-2), 0b1110);
+	assert_eq!(i32_to_iN::<4>(1), 0b0001);
+	assert_eq!(i32_to_iN::<4>(0), 0b0000);
+	assert_eq!(i32_to_iN::<4>(-3), 0b1101);
+	assert_eq!(i32_to_iN::<4>(-4), 0b1100);
+	assert_eq!(i32_to_iN::<4>(2), 0b0010);
+	assert_eq!(i32_to_iN::<4>(3), 0b0011);
+	assert_eq!(i32_to_iN::<5>(-16), 0b10000);
+	assert_eq!(i32_to_iN::<5>(-15), 0b10001);
+	assert_eq!(i32_to_iN::<5>(15), 0b01111);
+	assert_eq!(i32_to_iN::<6>(-32), 0b100000);
+	assert_eq!(i32_to_iN::<6>(31), 0b011111);
+}
+
+#[test]
+#[rustfmt::skip]
+fn test_bitcat_signed() {
+	assert_eq!(bitcat! { acc(8) signed 4(0), 4(0) }, 0b0000_0000);
+	assert_eq!(bitcat! { acc(8) signed 4(-1), 4(0) }, 0b1111_0000);
+	assert_eq!(bitcat! { acc(8) signed 4(-2), 4(1) }, 0b1110_0001);
+	assert_eq!(bitcat! { acc(8) signed 4(2), 4(3) }, 0b0010_0011);
+	assert_eq!(bitcat! { acc(8) signed 5(-16), 3(7) }, 0b10000_111);
+	assert_eq!(bitcat! { acc(8) signed 6(-32), 2(3) }, 0b100000_11);
+	assert_eq!(bitcat! { acc(16) signed 8(-128), 8(255) }, 0b10000000_11111111);
+	assert_eq!(bitcat! { acc(16) signed 12(-2048), 4(15) }, 0b100000000000_1111);
+	assert_eq!(bitcat! { acc(32) signed 20(-524288), 12(0xFFF) }, 0b10000000000000000000_111111111111);
+}
+
 pub(crate) use bitcat;
 
 #[inline]
-pub fn lui(rd: u8, imm: u32) -> u32 {
-	bitcat! { 20(imm), 5(rd), 7(0b0110111) }
+pub fn lui(rd: u8, imm: i32) -> u32 {
+	bitcat! { signed 20(imm), 5(rd), 7(0b0110111) }
 }
 
 #[inline]
-pub fn auipc(rd: u8, imm: u32) -> u32 {
-	bitcat! { 20(imm), 5(rd), 7(0b0010111) }
+pub fn auipc(rd: u8, imm: i32) -> u32 {
+	bitcat! { signed 20(imm), 5(rd), 7(0b0010111) }
 }
 
 #[inline]
-pub fn jal(rd: u8, imm: u32) -> u32 {
+pub fn jal(rd: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<20>(imm);
 	bitcat! { 1(imm >> 20), 10(imm >> 1), 1(imm >> 11), 8(imm >> 12), 5(rd), 7(0b1101111) }
 }
 
 #[inline]
-pub fn jalr(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b000), 5(rd), 7(0b1100111) }
+pub fn jalr(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b000), 5(rd), 7(0b1100111) }
 }
 
 #[inline]
-pub fn beq(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn beq(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 1(imm >> 12), 6(imm >> 5), 5(rs2), 5(rs1), 3(0b000), 4(imm >> 1), 1(imm >> 11), 7(0b1100011) }
 }
 
 #[inline]
-pub fn bne(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn bne(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 1(imm >> 12), 6(imm >> 5), 5(rs2), 5(rs1), 3(0b001), 4(imm >> 1), 1(imm >> 11), 7(0b1100011) }
 }
 
 #[inline]
-pub fn blt(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn blt(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 1(imm >> 12), 6(imm >> 5), 5(rs2), 5(rs1), 3(0b100), 4(imm >> 1), 1(imm >> 11), 7(0b1100011) }
 }
 
 #[inline]
-pub fn bge(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn bge(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 1(imm >> 12), 6(imm >> 5), 5(rs2), 5(rs1), 3(0b101), 4(imm >> 1), 1(imm >> 11), 7(0b1100011) }
 }
 
 #[inline]
-pub fn bltu(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn bltu(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 1(imm >> 12), 6(imm >> 5), 5(rs2), 5(rs1), 3(0b110), 4(imm >> 1), 1(imm >> 11), 7(0b1100011) }
 }
 
 #[inline]
-pub fn bgeu(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn bgeu(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 1(imm >> 12), 6(imm >> 5), 5(rs2), 5(rs1), 3(0b111), 4(imm >> 1), 1(imm >> 11), 7(0b1100011) }
 }
 
 #[inline]
-pub fn lb(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b000), 5(rd), 7(0b0000011) }
+pub fn lb(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b000), 5(rd), 7(0b0000011) }
 }
 
 #[inline]
-pub fn lh(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b001), 5(rd), 7(0b0000011) }
+pub fn lh(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b001), 5(rd), 7(0b0000011) }
 }
 
 #[inline]
-pub fn lw(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b010), 5(rd), 7(0b0000011) }
+pub fn lw(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b010), 5(rd), 7(0b0000011) }
 }
 
 #[inline]
-pub fn lbu(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b100), 5(rd), 7(0b0000011) }
+pub fn lbu(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b100), 5(rd), 7(0b0000011) }
 }
 
 #[inline]
-pub fn lhu(rd: u8, rs1: u8, imm: u16) -> u32 {
+pub fn lhu(rd: u8, rs1: u8, imm: i32) -> u32 {
 	bitcat! { 12(imm), 5(rs1), 3(0b101), 5(rd), 7(0b0000011) }
 }
 
 #[inline]
-pub fn sb(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn sb(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 7(imm >> 5), 5(rs2), 5(rs1), 3(0b000), 5(imm), 7(0b0100011) }
 }
 
 #[inline]
-pub fn sh(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn sh(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 7(imm >> 5), 5(rs2), 5(rs1), 3(0b001), 5(imm), 7(0b0100011) }
 }
 
 #[inline]
-pub fn sw(rs1: u8, rs2: u8, imm: u16) -> u32 {
+pub fn sw(rs1: u8, rs2: u8, imm: i32) -> u32 {
+	let imm = i32_to_iN::<12>(imm);
 	bitcat! { 7(imm >> 5), 5(rs2), 5(rs1), 3(0b010), 5(imm), 7(0b0100011) }
 }
 
 #[inline]
-pub fn addi(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b000), 5(rd), 7(0b0010011) }
+pub fn addi(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b000), 5(rd), 7(0b0010011) }
 }
 
 #[inline]
-pub fn slti(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b010), 5(rd), 7(0b0010011) }
+pub fn slti(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b010), 5(rd), 7(0b0010011) }
 }
 
 #[inline]
-pub fn sltiu(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b011), 5(rd), 7(0b0010011) }
+pub fn sltiu(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b011), 5(rd), 7(0b0010011) }
 }
 
 #[inline]
-pub fn xori(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b100), 5(rd), 7(0b0010011) }
+pub fn xori(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b100), 5(rd), 7(0b0010011) }
 }
 
 #[inline]
-pub fn ori(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b110), 5(rd), 7(0b0010011) }
+pub fn ori(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b110), 5(rd), 7(0b0010011) }
 }
 
 #[inline]
-pub fn andi(rd: u8, rs1: u8, imm: u16) -> u32 {
-	bitcat! { 12(imm), 5(rs1), 3(0b111), 5(rd), 7(0b0010011) }
+pub fn andi(rd: u8, rs1: u8, imm: i32) -> u32 {
+	bitcat! { signed 12(imm), 5(rs1), 3(0b111), 5(rd), 7(0b0010011) }
 }
 
 #[inline]
@@ -229,7 +304,7 @@ pub fn mv(rd: u8, rs: u8) -> u32 {
 }
 
 #[inline]
-pub fn j(imm: u32) -> u32 {
+pub fn j(imm: i32) -> u32 {
 	jal(0, imm)
 }
 
@@ -244,6 +319,6 @@ pub fn jal_r(rd: u8, rs1: u8) -> u32 {
 }
 
 #[inline]
-pub fn call(imm: u32) -> u32 {
+pub fn call(imm: i32) -> u32 {
 	jal(1, imm)
 }