add proc-bitfield, start experimenting with instruction decoding

Author: Dillonb

src/cpu/dynarec/dynarec.c

@@ -36,13 +36,7 @@ int missing_block_handler(u32 physical_address, n64_dynarec_block_t* block, n64_
 #endif
 
     mark_metric(METRIC_BLOCK_COMPILATION);
-    static_assert(sizeof(JitBlock) == sizeof(n64_dynarec_block_t), "sizeof(Rust JitBlock) == sizeof(n64_dynarec_block_t)");
-    v3_compile_new_block((JitBlock*)block, (uint8_t*)code_mask, BLOCKCACHE_INNER_SIZE, N64CPU.pc, physical_address);
-
-
-    printf("Code mask at 0: %d\n", code_mask[0]);
-    printf("Code mask at 1: %d\n", code_mask[1]);
-    printf("Host size: %zu\nGuest size: %zu\n", block->host_size, block->guest_size);
+    v3_compile_new_block(block, code_mask, N64CPU.pc, physical_address);
     v2_compile_new_block(block, code_mask, N64CPU.pc, physical_address);
     if (block->run == NULL) {
         logfatal("Failed to compile block!");

src/cpu/dynarec/v2/v2_compiler.c

@@ -1,5 +1,6 @@
 #include "v2_compiler.h"
 
+#include "jit_rs.h"
 #include <log.h>
 #include <mem/n64bus.h>
 #include <disassemble.h>
@@ -190,6 +191,15 @@ int idle_loop_replacement() {
     return ticks_to_skip;
 }
 
+void v3_compile_new_block(
+        n64_dynarec_block_t* block,
+        bool* code_mask,
+        u64 virtual_address,
+        u32 physical_address) {
+    fill_temp_code(virtual_address, physical_address, code_mask);
+    rs_jit_compile_new_block((uint32_t*)temp_code, temp_code_len, virtual_address, physical_address);
+}
+
 void v2_compile_new_block(
         n64_dynarec_block_t* block,
         bool* code_mask,

src/cpu/dynarec/v2/v2_compiler.h

@@ -27,4 +27,6 @@ void v2_compile_new_block(n64_dynarec_block_t *block, bool *code_mask, u64 virtu
 void v2_compiler_init();
 void v2_set_idle_loop_detection_enabled(bool enabled);
 
+void v3_compile_new_block(n64_dynarec_block_t *block, bool *code_mask, u64 virtual_address, u32 physical_address);
+
 #endif // N64_V2_COMPILER_H

src/jit/Cargo.lock

@@ -8,3 +8,4 @@ crate-type = ["staticlib"]
 
 [dependencies]
 dynasm = "2.0.0"
+proc-bitfield = "0.5.0"

src/jit/Cargo.toml

@@ -1,34 +1,6 @@
-use std::ffi::c_void;
-
-#[repr(C)]
-pub struct JitBlock {
-    // int (*run)(r4300i_t* cpu);
-    pub run: *mut c_void,
-    // size_t guest_size;
-    pub guest_size: usize,
-    // size_t host_size;
-    pub host_size: usize,
-    // n64_block_sysconfig_t sysconfig;
-    pub sysconfig : u64,
-    // u64 virtual_address;
-    pub virtual_address : u64,
-    // struct n64_dynarec_block* next; // for other sysconfigs
-    pub next: *mut JitBlock
-}
-
-fn compile_new_block(_block: &mut JitBlock, _code_mask: &mut [u8], virtual_address: u64, physical_address: u32) {
-    println!("Compiling a new block at virtual address 0x{virtual_address:016X} and physical address 0x{physical_address:08X}");
-    // block.run = std::ptr::null_mut();
-    // block.host_size = 1;
-    // block.guest_size = 2;
-    // block.sysconfig = 3;
-    // block.virtual_address = 4;
-    // block.next = std::ptr::null_mut();
-}
-
+mod mips_parser;
 #[no_mangle]
-pub unsafe extern fn v3_compile_new_block(block: *mut JitBlock, code_mask: *mut u8, code_mask_size: usize, virtual_address: u64, physical_address: u32) {
-    let safe_block = block.as_mut().unwrap_unchecked();
-    let safe_code_mask = std::slice::from_raw_parts_mut(code_mask, code_mask_size);
-    compile_new_block(safe_block, safe_code_mask, virtual_address, physical_address);
+pub unsafe extern fn rs_jit_compile_new_block(instructions: *mut u32, num_instructions: usize, virtual_address: u64, physical_address: u32) {
+    let safe_code = std::slice::from_raw_parts(instructions, num_instructions);
+    mips_parser::parse(safe_code, virtual_address, physical_address);
 }

src/jit/src/lib.rs

@@ -0,0 +1,28 @@
+proc_bitfield::bitfield! {
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub struct MipsInstruction(pub u32): Debug, FromStorage, IntoStorage, DerefStorage {
+        pub raw : u32 @ ..,
+
+        pub imm:   u16 @ 0..=15,
+        pub s_imm: i16 @ 0..=15,
+
+        pub rt: u8 @ 16 .. 20,
+        pub rs: u8 @ 21 .. 25,
+        pub op: u8 @ 26 .. 31,
+    }
+}
+
+pub fn parse(code: &[u32], virtual_address: u64, physical_address: u32) {
+    let instructions = code.iter().map(|word| MipsInstruction(*word));
+
+    let code_len = code.len();
+    println!("Compiling {code_len} instructions at virtual address 0x{virtual_address:016X} and physical address 0x{physical_address:08X}");
+
+    let mut addr = virtual_address;
+    for instr in instructions {
+        let x = instr.raw();
+        let opcode = instr.op();
+        println!("{addr:016X}\t{x:08X} (opcode {opcode:X})");
+        addr += 4;
+    }
+}