Complete risc-v implementation

This took so long after several attempts to try and get loading a 64 bit immediate to work - I just couldn't manage to do it. So I'll leave that for another time.

It doesn't help that there's no documentation on doing so because it's generally frowned upon. It's unfortunate as dasm is in a special place where it'd be very convenient to do so to use as a JIT.

Author: codebycruz

Cargo.toml

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

README.md

@@ -18,62 +18,46 @@
 
 ## Note
 
-Support for every single instruction is **NOT** planned.
-Nor will there be any passes for optimization.
+`dasm` has a goal of acting as a lightweight, simple instructions for compilers.
 
-This has a simple goal of assembling instructions for compilers.
-If you want a fully featured library, please refer to [`Iced`](https://github.com/icedland/iced)
+If you want a higher-level library or something more comprehensive, there's other great solutions like [`Iced`](https://github.com/icedland/iced) or [`dynasm-rs`](https://github.com/CensoredUsername/dynasm-rs).
 
 ## How it works
 
 Code generation doesn't have to be hard. This just provides explicit functions for generating instructions.  
-No abstractions for the sake of safety or optimization which add complexity. If you just want to write assembly, this is for you.
-
-**This library has tiered abstraction levels.**
-
-### Raw
-
-This gives you access to the "raw" bytes from an instruction given untagged numeric arguments.
-Despite how it sounds, it is pretty nice to use on its own.
+No abstractions through macros, or some DSL you need to learn. Just functions.
 
 **Example**
 
 ```rust
+use dasm::tier::raw::amd64::*;
+
 let rax = 0;
 let rsi = 6; // Argument 2
 let rdi = 7; // Argument 1
 
 let asm = [
-	&dasm::tier::raw::amd64::mov_r64_r64(rax, rdi) as &[u8],
-	&dasm::tier::raw::amd64::add_r64_r64(rax, rsi),
-	&dasm::tier::raw::amd64::ret()
+	&mov_r64_r64(rax, rdi) as &[u8],
+	&add_r64_r64(rax, rsi),
+	&ret()
 ].concat();
 
-// A helper for making memory executable is included.
+// Allocate an executable memory block
 let mmapped = dasm::mmap::Mmap::exec(&asm)
 	.expect("Failed to mmap");
 
-// Simply cast the bytes to the function you just made.
+// Simply cast that memory into a function to call it.
 let adder: extern "C" fn(x: u64, y: u64) -> u64 = unsafe { std::mem::transmute(mmapped.as_ptr()) };
 assert_eq!(adder(5, 200), 205);
 ```
 
-There's also an example showcasing a tiny AOT compiled lisp at [`examples/tinylisp`](https://github.com/DvvCz/dasm/tree/master/examples/tinylisp).
-
-## Other Tiers
+*There's also an example showcasing a tiny AOT compiled lisp at [`examples/tinylisp`](https://github.com/DvvCz/dasm/tree/master/examples/tinylisp).*
 
-At the moment, other tiers are not implemented as I plan out how these abstractions would go.
-
-Hopefully they'd involve abstracting away overloads with tagged enums and cross architecture compatibility.
 
 ## Why
 
-I felt the need for an assembler.
-
-LLVM was out of the question due to its size and difficult integration to Rust.
-
-I struggled to work with Cranelift due to its complexity for the sake of safety and performance.
-
-But sometimes, you don't care about safety or performance. You just want a simple solution to get it done.
+All of the other solutions are either too big for my usecase (`LLVM`), too complex (`Cranelift`) or have too many abstractions.  
+Sometimes, you don't need all of that - you just need to write some assembly.  
+That's what `dasm` is for.
 
-That's what `dasm` is supposed to be.
+*Of course - No shade to any other library. Anyone can use the tool they prefer.*

examples/hello/src/main.rs

@@ -1,3 +1,5 @@
+use dasm::tier::raw::amd64::*;
+
 fn main() {
 	let mut mem: Vec<u8> = vec![];
 
@@ -9,17 +11,14 @@ fn main() {
 	let rsi = 6; // Argument #2 on linux
 
 	// Calls linux sys_write with given string and length
-	mem.extend(dasm::tier::raw::amd64::mov_r64_i64(rdi, 1)); // fd
-	mem.extend(dasm::tier::raw::amd64::mov_r64_i64(rax, 1)); // sys_write
-	mem.extend(dasm::tier::raw::amd64::mov_r64_i64(rsi, message.as_ptr() as _));
-	mem.extend(dasm::tier::raw::amd64::mov_r64_i64(rdx, message.len() as _));
-	mem.extend(dasm::tier::raw::amd64::syscall());
-
-	// Still need to return
-	mem.extend(dasm::tier::raw::amd64::ret());
+	mem.extend(mov_r64_i64(rdi, 1)); // fd
+	mem.extend(mov_r64_i64(rax, 1)); // sys_write
+	mem.extend(mov_r64_i64(rsi, message.as_ptr() as _));
+	mem.extend(mov_r64_i64(rdx, message.len() as _));
+	mem.extend(syscall());
+	mem.extend(ret());
 
-	let map = dasm::mmap::Mmap::exec(&mem)
-		.expect("Failed to mmap");
+	let map = dasm::mmap::Mmap::exec(&mem).expect("Failed to mmap");
 
 	let f: extern "C" fn() = unsafe { std::mem::transmute(map.as_ptr()) };
 	f();

examples/rv32/README.md

@@ -1,5 +1,5 @@
 [package]
-name = "rv32"
+name = "rv64"
 version = "0.1.0"
 authors = ["David Cruz <[email protected]>"]
 edition = "2021"

examples/rv32/src/main.rs

@@ -0,0 +1,7 @@
+# rv64
+
+Example for generating RISC-V (rv64gc) instructions.
+
+```
+cargo run --package rv64
+```

examples/rv32/Cargo.toml examples/rv64/Cargo.tomlexamples/rv32/Cargo.toml renamed to examples/rv64/Cargo.toml

@@ -0,0 +1,29 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+	use dasm::tier::raw::rv64::*;
+
+	let a0 = 10;
+	let a1 = 11;
+	let a2 = 12;
+	let a7 = 17;
+
+	// Calls linux sys_write with given string and length
+	// Note that this implementation stores the string in the same memory, since
+	// there's no good way to load a 64 bit immediate address in risc-v.
+	let mut mem: Vec<u8> = vec![];
+	// .text
+	mem.extend(addi(a0, x0, 1).to_le_bytes()); // stdout
+	mem.extend(auipc(a1, 0).to_le_bytes()); // a1 = pc
+	mem.extend(addi(a1, a1, 24).to_le_bytes()); // string = pc + 24
+	mem.extend(addi(a2, x0, 14).to_le_bytes()); // length of string
+	mem.extend(addi(a7, x0, 64).to_le_bytes()); // sys_write
+	mem.extend(ecall().to_le_bytes());
+	mem.extend(ret().to_le_bytes());
+	// .data
+	mem.extend(b"Hello, world!\n");
+
+	let map = dasm::mmap::Mmap::exec(&mem)?;
+	let f: extern "C" fn() = unsafe { std::mem::transmute(map.as_ptr()) };
+	f();
+
+	Ok(())
+}

examples/rv64/README.md

@@ -1,3 +1,8 @@
+//! `amd64` implementation
+//!
+//! For 64 bit x86. This includes all compatible instructions from x86 (alongside 64 bit equivalents.)
+
+
 // amd64 should support all of these.
 pub use crate::tier::raw::x86::compatible::*;