WIP

Author: Grarak

Cargo.toml

@@ -53,6 +53,17 @@ vitasdk-sys = { version = "0.3.2", features = [
     #    "SceRazorCapture_stub",
 ] }
 
+[profile.release-debug]
+inherits = "dev"
+opt-level = 3
+overflow-checks = true
+debug-assertions = true
+debug = true
+panic = "abort"
+
+[profile.release.package."*"]
+opt-level = 3
+
 [profile.release]
 panic = "abort"
 lto = "fat"

build.rs

@@ -1,9 +1,17 @@
 use bindgen::Formatter;
+use std::fs::File;
+use std::io::Write;
 use std::path::PathBuf;
 use std::process::Command;
 use std::{env, fs};
 
 fn main() {
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+
+    let build_profile_name = out_path.to_str().unwrap().split(std::path::MAIN_SEPARATOR).nth_back(3).unwrap();
+    let build_profile_name_file = out_path.join("build_profile_name");
+    File::create(build_profile_name_file).unwrap().write_all(build_profile_name.as_bytes()).unwrap();
+
     let target = env::var("TARGET").unwrap();
     if target != "armv7-sony-vita-newlibeabihf" {
         // Running IDE on anything other than linux will fail, so ignore compile error
@@ -17,7 +25,6 @@ fn main() {
     let vitasdk_include_path = vitasdk_path.join("arm-vita-eabi").join("include");
     let vitasdk_lib_path = vitasdk_path.join("arm-vita-eabi").join("lib");
 
-    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
     let bindings_file = out_path.join("imgui_bindings.rs");
 
     const IMGUI_HEADERS: [&str; 3] = ["imgui.h", "imgui_internal.h", "imgui_impl_vitagl.h"];

src/core/cpu_regs.rs

@@ -48,13 +48,14 @@ struct InterruptFlags(u32);
 
 impl Debug for InterruptFlags {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let mut flags = f.debug_set();
+        let mut debug_set = f.debug_set();
         for i in 0..=InterruptFlag::Wifi as u8 {
             if self.0 & (1 << i) != 0 {
-                flags.entry(&InterruptFlag::from(i));
+                let flag = InterruptFlag::from(i);
+                debug_set.entry(&flag);
             }
         }
-        flags.finish()
+        debug_set.finish()
     }
 }
 
@@ -112,7 +113,7 @@ impl CpuRegs {
     }
 
     pub fn set_irf(&mut self, mask: u32, value: u32) {
-        debug_println!("{:?} set irf {:?}", self.cpu_type, InterruptFlags(value & mask));
+        // debug_println!("{:?} set irf {:?}", self.cpu_type, InterruptFlags(value & mask));
         self.irf &= !(value & mask);
     }
 

src/jit/jit_asm.rs

@@ -14,6 +14,7 @@ use crate::logging::debug_println;
 use crate::{get_jit_asm_ptr, DEBUG_LOG, DEBUG_LOG_BRANCH_OUT};
 use std::arch::asm;
 use std::cell::UnsafeCell;
+use std::hint::unreachable_unchecked;
 use std::intrinsics::unlikely;
 use std::{mem, ptr};
 
@@ -111,22 +112,22 @@ impl JitRuntimeData {
 
 pub extern "C" fn hle_bios_uninterrupt<const CPU: CpuType>(store_host_sp: bool) {
     let asm = unsafe { get_jit_asm_ptr::<CPU>().as_mut().unwrap_unchecked() };
-    bios::uninterrupt::<CPU>(asm.emu);
+    if DEBUG_LOG_BRANCH_OUT {
+        asm.runtime_data.branch_out_pc = get_regs!(asm.emu, CPU).pc;
+    }
     asm.runtime_data.return_stack_ptr = 0;
     asm.runtime_data.accumulated_cycles += 3;
+    bios::uninterrupt::<CPU>(asm.emu);
     if unlikely(get_cpu_regs!(asm.emu, CPU).is_halted()) {
-        if DEBUG_LOG_BRANCH_OUT {
-            asm.runtime_data.branch_out_pc = get_regs!(asm.emu, CPU).pc;
-        }
         if !store_host_sp {
             // r4-r12,pc since we need an even amount of registers for 8 byte alignment, in case the compiler decides to use neon instructions
             unsafe {
                 asm!(
-                "mov sp, {}",
-                "pop {{r4-r12,pc}}",
-                in(reg) asm.runtime_data.host_sp
+                    "mov sp, {}",
+                    "pop {{r4-r12,pc}}",
+                    in(reg) asm.runtime_data.host_sp
                 );
-                std::hint::unreachable_unchecked();
+                unreachable_unchecked();
             }
         }
     } else {
@@ -198,7 +199,7 @@ fn emit_code_block_internal<const CPU: CpuType, const THUMB: bool>(store_host_sp
             block_asm.restore_reg(Reg::CPSR);
         }
 
-        // if guest_pc == 0x20b2688 {
+        // if guest_pc == 0x2001b5e {
         //     block_asm.bkpt(2);
         // }
 
@@ -207,7 +208,7 @@ fn emit_code_block_internal<const CPU: CpuType, const THUMB: bool>(store_host_sp
             asm.jit_buf.current_pc = guest_pc + (i << if THUMB { 1 } else { 2 }) as u32;
             debug_println!("{CPU:?} emitting {:?} at pc: {:x}", asm.jit_buf.current_inst(), asm.jit_buf.current_pc);
 
-            // if asm.jit_buf.current_pc == 0x20216e2 {
+            // if asm.jit_buf.current_pc == 0x2001b5c {
             //     block_asm.bkpt(1);
             // }
 
@@ -217,11 +218,11 @@ fn emit_code_block_internal<const CPU: CpuType, const THUMB: bool>(store_host_sp
                 asm.emit(&mut block_asm);
             }
 
-            // if DEBUG_LOG {
-            //     block_asm.save_context();
-            //     block_asm.call2(debug_after_exec_op::<CPU> as *const (), asm.jit_buf.current_pc, asm.jit_buf.current_inst().opcode);
-            //     block_asm.restore_reg(Reg::CPSR);
-            // }
+            if DEBUG_LOG {
+                block_asm.save_context();
+                block_asm.call2(debug_after_exec_op::<CPU> as *const (), asm.jit_buf.current_pc, asm.jit_buf.current_inst().opcode);
+                block_asm.restore_reg(Reg::CPSR);
+            }
         }
 
         let opcodes = block_asm.finalize(guest_pc, THUMB);

src/main.rs

@@ -23,7 +23,7 @@ use crate::jit::jit_asm::JitAsm;
 use crate::logging::debug_println;
 use crate::presenter::{PresentEvent, Presenter, PRESENTER_AUDIO_BUF_SIZE};
 use crate::settings::Settings;
-use crate::utils::{set_thread_prio_affinity, HeapMemU32, ThreadAffinity, ThreadPriority};
+use crate::utils::{const_str_equal, set_thread_prio_affinity, HeapMemU32, ThreadAffinity, ThreadPriority};
 use std::cell::UnsafeCell;
 use std::cmp::min;
 use std::intrinsics::{likely, unlikely};
@@ -46,7 +46,8 @@ mod presenter;
 mod settings;
 mod utils;
 
-pub const DEBUG_LOG: bool = cfg!(debug_assertions);
+const BUILD_PROFILE_NAME: &str = include_str!(concat!(env!("OUT_DIR"), "/build_profile_name"));
+pub const DEBUG_LOG: bool = const_str_equal(BUILD_PROFILE_NAME, "debug");
 pub const DEBUG_LOG_BRANCH_OUT: bool = DEBUG_LOG;
 
 fn run_cpu(

src/utils.rs

@@ -260,3 +260,21 @@ pub fn rgb6_to_float8(color: u32) -> (f32, f32, f32) {
     let b = ((color >> 12) & 0x3F) as f32;
     (r / 63f32, g / 63f32, b / 63f32)
 }
+
+pub const fn const_bytes_equal(lhs: &[u8], rhs: &[u8]) -> bool {
+    if lhs.len() != rhs.len() {
+        return false;
+    }
+    let mut i = 0;
+    while i < lhs.len() {
+        if lhs[i] != rhs[i] {
+            return false;
+        }
+        i += 1;
+    }
+    true
+}
+
+pub const fn const_str_equal(lhs: &str, rhs: &str) -> bool {
+    const_bytes_equal(lhs.as_bytes(), rhs.as_bytes())
+}