Add release debug profile

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/core/rtc.rs

@@ -1,4 +1,5 @@
 use crate::logging::debug_println;
+use crate::IS_DEBUG;
 use bilge::prelude::*;
 use chrono::{Datelike, Timelike};
 
@@ -133,27 +134,23 @@ impl Rtc {
     }
 
     fn update_date_time(&mut self) {
-        let local_now = chrono::Local::now();
-
-        // let year = local_now.year() as u32 % 100;
-        // let month = local_now.month() as u8;
-        // let day = local_now.day() as u8;
-        // let (hour, is_pm) = {
-        //     let hour = local_now.hour();
-        //     ((if self.cnt & 0x2 == 0 { hour % 12 } else { hour }) as u8, hour >= 12)
-        // };
-        // let min = local_now.minute() as u8;
-        // let sec = local_now.second() as u8;
-
-        let year = 2000 as u32 % 100;
-        let month = 1 as u8;
-        let day = 1 as u8;
-        let (hour, is_pm) = {
-            let hour = 11;
-            ((if self.cnt & 0x2 == 0 { hour % 12 } else { hour }) as u8, hour >= 12)
+        let (year, month, day, hour, is_pm, min, sec) = if IS_DEBUG {
+            (2000, 1, 1, 11, false, 0, 0)
+        } else {
+            let local_now = chrono::Local::now();
+
+            let year = local_now.year() as u32 % 100;
+            let month = local_now.month() as u8;
+            let day = local_now.day() as u8;
+            let (hour, is_pm) = {
+                let hour = local_now.hour();
+                ((if self.cnt & 0x2 == 0 { hour % 12 } else { hour }) as u8, hour >= 12)
+            };
+            let min = local_now.minute() as u8;
+            let sec = local_now.second() as u8;
+
+            (year, month, day, hour, is_pm, min, sec)
         };
-        let min = 0 as u8;
-        let sec = 0 as u8;
 
         self.date_time[0] = (((year / 10) << 4) | (year % 10)) as u8;
         self.date_time[1] = ((month / 10) << 4) | (month % 10);

src/jit/emitter/emit.rs

@@ -8,7 +8,7 @@ use crate::jit::jit_asm::{JitAsm, JitRuntimeData};
 use crate::jit::op::Op;
 use crate::jit::reg::Reg;
 use crate::jit::Cond;
-use crate::DEBUG_LOG_BRANCH_OUT;
+use crate::IS_DEBUG;
 use CpuType::ARM9;
 
 impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
@@ -29,7 +29,7 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
             Op::MrsRc | Op::MrsRs => self.emit_mrs(block_asm),
             Op::Swi => self.emit_swi::<false>(block_asm),
             Op::Swpb | Op::Swp => self.emit_swp(block_asm),
-            Op::UnkArm => todo!(),
+            Op::UnkArm => unreachable!(),
             op if op.is_single_mem_transfer() => {
                 if op.mem_is_write() {
                     self.emit_single_write(block_asm)
@@ -103,7 +103,7 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
         let runtime_data_addr_reg = block_asm.new_reg();
         block_asm.mov(runtime_data_addr_reg, self.runtime_data.get_addr() as u32);
 
-        if DEBUG_LOG_BRANCH_OUT {
+        if IS_DEBUG {
             let pc_reg = block_asm.new_reg();
             block_asm.mov(pc_reg, self.jit_buf.current_pc);
             block_asm.store_u32(pc_reg, runtime_data_addr_reg, JitRuntimeData::get_out_pc_offset() as u32);

src/jit/emitter/thumb/emit_thumb.rs

@@ -56,7 +56,7 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
             Op::BlxRegT => self.emit_blx_thumb(block_asm),
 
             Op::SwiT => self.emit_swi::<true>(block_asm),
-            Op::UnkThumb => {}
+            Op::UnkThumb => unreachable!(),
             op if op.is_single_mem_transfer() => {
                 if op.mem_is_write() {
                     self.emit_str_thumb(block_asm)

src/jit/inst_mem_handler.rs

@@ -153,7 +153,7 @@ mod handler {
 macro_rules! imm_breakout {
     ($asm:expr, $pc:expr, $thumb:expr, $total_cycles:expr) => {{
         crate::logging::debug_println!("immediate breakout");
-        if crate::DEBUG_LOG_BRANCH_OUT {
+        if crate::IS_DEBUG {
             $asm.runtime_data.branch_out_pc = $pc;
         }
         $asm.runtime_data.accumulated_cycles += $total_cycles - $asm.runtime_data.pre_cycle_count_sum;

src/jit/jit_asm.rs

@@ -11,9 +11,10 @@ use crate::jit::op::Op;
 use crate::jit::reg::Reg;
 use crate::jit::reg::{reg_reserve, RegReserve};
 use crate::logging::debug_println;
-use crate::{get_jit_asm_ptr, DEBUG_LOG, DEBUG_LOG_BRANCH_OUT};
+use crate::{get_jit_asm_ptr, DEBUG_LOG, IS_DEBUG};
 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 IS_DEBUG {
+        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 {
@@ -154,36 +155,37 @@ fn emit_code_block_internal<const CPU: CpuType, const THUMB: bool>(store_host_sp
     let asm = unsafe { get_jit_asm_ptr::<CPU>().as_mut().unwrap_unchecked() };
 
     {
-        let mut index = 0;
+        let mut pc_offset = 0;
         loop {
             let inst_info = if THUMB {
-                let opcode = asm.emu.mem_read::<CPU, u16>(guest_pc + index);
+                let opcode = asm.emu.mem_read::<CPU, u16>(guest_pc + pc_offset);
                 let (op, func) = lookup_thumb_opcode(opcode);
                 InstInfo::from(func(opcode, *op))
             } else {
-                let opcode = asm.emu.mem_read::<CPU, u32>(guest_pc + index);
+                let opcode = asm.emu.mem_read::<CPU, u32>(guest_pc + pc_offset);
                 let (op, func) = lookup_opcode(opcode);
                 func(opcode, *op)
             };
 
+            if inst_info.op == Op::UnkArm || inst_info.op == Op::UnkThumb {
+                break;
+            }
+
             if let Some(last) = asm.jit_buf.insts_cycle_counts.last() {
-                assert!(u16::MAX - last >= inst_info.cycle as u16, "{CPU:?} {guest_pc:x} {inst_info:?}");
+                debug_assert!(u16::MAX - last >= inst_info.cycle as u16, "{CPU:?} {guest_pc:x} {inst_info:?}");
                 asm.jit_buf.insts_cycle_counts.push(last + inst_info.cycle as u16);
             } else {
                 asm.jit_buf.insts_cycle_counts.push(inst_info.cycle as u16);
-                assert!(asm.jit_buf.insts_cycle_counts.len() <= u16::MAX as usize, "{CPU:?} {guest_pc:x} {inst_info:?}")
+                debug_assert!(asm.jit_buf.insts_cycle_counts.len() <= u16::MAX as usize, "{CPU:?} {guest_pc:x} {inst_info:?}")
             }
 
             let is_unreturnable_branch = !inst_info.out_regs.is_reserved(Reg::LR) && inst_info.is_uncond_branch();
-            // let is_uncond_branch = inst_info.is_uncond_branch();
-            let is_unknown = inst_info.op == Op::UnkArm || inst_info.op == Op::UnkThumb;
-
             asm.jit_buf.insts.push(inst_info);
 
-            index += if THUMB { 2 } else { 4 };
-            if is_unreturnable_branch || is_unknown {
+            if is_unreturnable_branch {
                 break;
             }
+            pc_offset += if THUMB { 2 } else { 4 };
         }
     }
 
@@ -198,7 +200,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 +209,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 +219,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);
@@ -263,7 +265,7 @@ fn execute_internal<const CPU: CpuType>(guest_pc: u32) -> u16 {
 
         debug_println!("{CPU:?} Enter jit addr {:x}", jit_entry as usize);
 
-        if DEBUG_LOG {
+        if IS_DEBUG {
             asm.runtime_data.branch_out_pc = u32::MAX;
         }
         asm.runtime_data.pre_cycle_count_sum = 0;
@@ -274,11 +276,9 @@ fn execute_internal<const CPU: CpuType>(guest_pc: u32) -> u16 {
 
     jit_entry(true);
 
-    if DEBUG_LOG {
-        assert_ne!(asm.runtime_data.branch_out_pc, u32::MAX);
-    }
+    debug_assert_ne!(asm.runtime_data.branch_out_pc, u32::MAX);
 
-    if DEBUG_LOG && DEBUG_LOG_BRANCH_OUT {
+    if DEBUG_LOG {
         println!(
             "{:?} reading opcode of breakout at {:x} executed cycles {}",
             CPU, asm.runtime_data.branch_out_pc, asm.runtime_data.accumulated_cycles

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,8 +46,9 @@ mod presenter;
 mod settings;
 mod utils;
 
-pub const DEBUG_LOG: bool = cfg!(debug_assertions);
-pub const DEBUG_LOG_BRANCH_OUT: bool = DEBUG_LOG;
+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 IS_DEBUG: bool = !const_str_equal(BUILD_PROFILE_NAME, "release");
 
 fn run_cpu(
     cartridge_io: CartridgeIo,

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())
+}