From 9b42ad38593a332c465140a742be345ad2e52003 Mon Sep 17 00:00:00 2001 From: Stenzek Date: Sun, 30 Jun 2024 14:05:31 +1000 Subject: [PATCH] CPU/CodeCache: Purge JitCodeBuffer --- src/core/cpu_code_cache.cpp | 122 +++++++++++++++--- src/core/cpu_code_cache_private.h | 16 ++- src/core/cpu_newrec_compiler.cpp | 20 ++- src/core/cpu_recompiler_code_generator.h | 7 +- .../cpu_recompiler_code_generator_aarch32.cpp | 36 +++--- .../cpu_recompiler_code_generator_aarch64.cpp | 28 ++-- .../cpu_recompiler_code_generator_x64.cpp | 17 +-- src/util/CMakeLists.txt | 2 - src/util/jit_code_buffer.cpp | 74 ----------- src/util/jit_code_buffer.h | 54 -------- src/util/util.vcxproj | 2 - src/util/util.vcxproj.filters | 2 - 12 files changed, 160 insertions(+), 220 deletions(-) delete mode 100644 src/util/jit_code_buffer.cpp delete mode 100644 src/util/jit_code_buffer.h diff --git a/src/core/cpu_code_cache.cpp b/src/core/cpu_code_cache.cpp index c5130529c..0167a87ee 100644 --- a/src/core/cpu_code_cache.cpp +++ b/src/core/cpu_code_cache.cpp @@ -97,6 +97,7 @@ static BlockInstructionList s_block_instructions; static void BacklinkBlocks(u32 pc, const void* dst); static void UnlinkBlockExits(Block* block); +static void ResetCodeBuffer(); static void ClearASMFunctions(); static void CompileASMFunctions(); @@ -146,7 +147,15 @@ __attribute__((aligned(HOST_PAGE_SIZE))) static u8 s_code_buffer_ptr[RECOMPILER_ static u8* s_code_buffer_ptr = nullptr; #endif -static JitCodeBuffer s_code_buffer; +static u8* s_code_ptr = nullptr; +static u8* s_free_code_ptr = nullptr; +static u32 s_code_size = 0; +static u32 s_code_used = 0; + +static u8* s_far_code_ptr = nullptr; +static u8* s_free_far_code_ptr = nullptr; +static u32 s_far_code_size = 0; +static u32 s_far_code_used = 0; #ifdef _DEBUG static u32 s_total_instructions_compiled = 0; @@ -206,10 +215,9 @@ void CPU::CodeCache::Initialize() { Assert(s_blocks.empty()); - // TODO: Reduce far code size when not using memory exceptions. if (IsUsingAnyRecompiler()) { - s_code_buffer.Reset(s_code_buffer_ptr, RECOMPILER_CODE_CACHE_SIZE, RECOMPILER_FAR_CODE_CACHE_SIZE); + ResetCodeBuffer(); CompileASMFunctions(); ResetCodeLUT(); } @@ -234,7 +242,7 @@ void CPU::CodeCache::Reset() if (IsUsingAnyRecompiler()) { ClearASMFunctions(); - s_code_buffer.Reset(s_code_buffer_ptr, RECOMPILER_CODE_CACHE_SIZE, RECOMPILER_FAR_CODE_CACHE_SIZE); + ResetCodeBuffer(); CompileASMFunctions(); ResetCodeLUT(); } @@ -1331,8 +1339,8 @@ void CPU::CodeCache::CompileOrRevalidateBlock(u32 start_pc) // Ensure we're not going to run out of space while compiling this block. // We could definitely do better here... TODO: far code is no longer needed for newrec const u32 block_size = static_cast(s_block_instructions.size()); - if (s_code_buffer.GetFreeCodeSpace() < (block_size * Recompiler::MAX_NEAR_HOST_BYTES_PER_INSTRUCTION) || - s_code_buffer.GetFreeFarCodeSpace() < (block_size * Recompiler::MAX_FAR_HOST_BYTES_PER_INSTRUCTION)) + if (GetFreeCodeSpace() < (block_size * Recompiler::MAX_NEAR_HOST_BYTES_PER_INSTRUCTION) || + GetFreeFarCodeSpace() < (block_size * Recompiler::MAX_FAR_HOST_BYTES_PER_INSTRUCTION)) { ERROR_LOG("Out of code space while compiling {:08X}. Resetting code cache.", start_pc); CodeCache::Reset(); @@ -1420,9 +1428,86 @@ void CPU::CodeCache::UnlinkBlockExits(Block* block) block->num_exit_links = 0; } -JitCodeBuffer& CPU::CodeCache::GetCodeBuffer() +void CPU::CodeCache::ResetCodeBuffer() +{ + s_code_ptr = static_cast(s_code_buffer_ptr); + s_free_code_ptr = s_code_ptr; + s_code_size = RECOMPILER_CODE_CACHE_SIZE - RECOMPILER_FAR_CODE_CACHE_SIZE; + s_code_used = 0; + + s_far_code_size = RECOMPILER_FAR_CODE_CACHE_SIZE; + s_far_code_ptr = (s_far_code_size > 0) ? (static_cast(s_code_ptr) + s_code_size) : nullptr; + s_free_far_code_ptr = s_far_code_ptr; + s_far_code_used = 0; + + MemMap::BeginCodeWrite(); + + std::memset(s_code_ptr, 0, RECOMPILER_CODE_CACHE_SIZE); + MemMap::FlushInstructionCache(s_code_ptr, RECOMPILER_CODE_CACHE_SIZE); + + MemMap::EndCodeWrite(); +} + +u8* CPU::CodeCache::GetFreeCodePointer() { - return s_code_buffer; + return s_free_code_ptr; +} + +u32 CPU::CodeCache::GetFreeCodeSpace() +{ + return s_code_size - s_code_used; +} + +void CPU::CodeCache::CommitCode(u32 length) +{ + if (length == 0) [[unlikely]] + return; + + MemMap::FlushInstructionCache(s_free_code_ptr, length); + + Assert(length <= (s_code_size - s_code_used)); + s_free_code_ptr += length; + s_code_used += length; +} + +u8* CPU::CodeCache::GetFreeFarCodePointer() +{ + return s_free_far_code_ptr; +} + +u32 CPU::CodeCache::GetFreeFarCodeSpace() +{ + return s_far_code_size - s_far_code_used; +} + +void CPU::CodeCache::CommitFarCode(u32 length) +{ + if (length == 0) [[unlikely]] + return; + + MemMap::FlushInstructionCache(s_free_far_code_ptr, length); + + Assert(length <= (s_far_code_size - s_far_code_used)); + s_free_far_code_ptr += length; + s_far_code_used += length; +} + +void CPU::CodeCache::AlignCode(u32 alignment) +{ +#if defined(CPU_ARCH_X64) + constexpr u8 padding_value = 0xcc; // int3 +#else + constexpr u8 padding_value = 0x00; +#endif + + DebugAssert(Common::IsPow2(alignment)); + const u32 num_padding_bytes = + std::min(static_cast(Common::AlignUpPow2(reinterpret_cast(s_free_code_ptr), alignment) - + reinterpret_cast(s_free_code_ptr)), + GetFreeCodeSpace()); + std::memset(s_free_code_ptr, padding_value, num_padding_bytes); + s_free_code_ptr += num_padding_bytes; + s_code_used += num_padding_bytes; } const void* CPU::CodeCache::GetInterpretUncachedBlockFunction() @@ -1460,13 +1545,13 @@ void CPU::CodeCache::CompileASMFunctions() { MemMap::BeginCodeWrite(); - const u32 asm_size = EmitASMFunctions(s_code_buffer.GetFreeCodePointer(), s_code_buffer.GetFreeCodeSpace()); + const u32 asm_size = EmitASMFunctions(GetFreeCodePointer(), GetFreeCodeSpace()); #ifdef ENABLE_RECOMPILER_PROFILING - MIPSPerfScope.Register(s_code_buffer.GetFreeCodePointer(), asm_size, "ASMFunctions"); + MIPSPerfScope.Register(GetFreeCodePointer(), asm_size, "ASMFunctions"); #endif - s_code_buffer.CommitCode(asm_size); + CommitCode(asm_size); MemMap::EndCodeWrite(); } @@ -1479,7 +1564,7 @@ bool CPU::CodeCache::CompileBlock(Block* block) #ifdef ENABLE_RECOMPILER if (g_settings.cpu_execution_mode == CPUExecutionMode::Recompiler) { - Recompiler::CodeGenerator codegen(&s_code_buffer); + Recompiler::CodeGenerator codegen; host_code = codegen.CompileBlock(block, &host_code_size, &host_far_code_size); } #endif @@ -1503,12 +1588,13 @@ bool CPU::CodeCache::CompileBlock(Block* block) s_total_instructions_compiled += block->size; s_total_host_instructions_emitted += host_instructions; - Log_ProfileFmt("0x{:08X}: {}/{}b for {}b ({}i), blowup: {:.2f}x, cache: {:.2f}%/{:.2f}%, ipi: {:.2f}/{:.2f}", - block->pc, host_code_size, host_far_code_size, block->size * 4, block->size, - static_cast(host_code_size) / static_cast(block->size * 4), s_code_buffer.GetUsedPct(), - s_code_buffer.GetFarUsedPct(), static_cast(host_instructions) / static_cast(block->size), - static_cast(s_total_host_instructions_emitted) / - static_cast(s_total_instructions_compiled)); + DEV_LOG("0x{:08X}: {}/{}b for {}b ({}i), blowup: {:.2f}x, cache: {:.2f}%/{:.2f}%, ipi: {:.2f}/{:.2f}", block->pc, + host_code_size, host_far_code_size, block->size * 4, block->size, + static_cast(host_code_size) / static_cast(block->size * 4), + (static_cast(s_code_used) / static_cast(s_code_size)) * 100.0f, + (static_cast(s_far_code_used) / static_cast(s_far_code_size)) * 100.0f, + static_cast(host_instructions) / static_cast(block->size), + static_cast(s_total_host_instructions_emitted) / static_cast(s_total_instructions_compiled)); #endif #if 0 diff --git a/src/core/cpu_code_cache_private.h b/src/core/cpu_code_cache_private.h index 81991ef77..cd6dd9c8a 100644 --- a/src/core/cpu_code_cache_private.h +++ b/src/core/cpu_code_cache_private.h @@ -10,7 +10,6 @@ #include "cpu_core_private.h" #include "cpu_types.h" -#include "util/jit_code_buffer.h" #include "util/page_fault_handler.h" #include @@ -234,7 +233,20 @@ void LogCurrentState(); #define ENABLE_HOST_DISASSEMBLY 1 #endif -JitCodeBuffer& GetCodeBuffer(); +/// Access to normal code allocator. +u8* GetFreeCodePointer(); +u32 GetFreeCodeSpace(); +void CommitCode(u32 length); + +/// Access to far code allocator. +u8* GetFreeFarCodePointer(); +u32 GetFreeFarCodeSpace(); +void CommitFarCode(u32 length); + +/// Adjusts the free code pointer to the specified alignment, padding with bytes. +/// Assumes alignment is a power-of-two. +void AlignCode(u32 alignment); + const void* GetInterpretUncachedBlockFunction(); void CompileOrRevalidateBlock(u32 start_pc); diff --git a/src/core/cpu_newrec_compiler.cpp b/src/core/cpu_newrec_compiler.cpp index 2556bbd6e..2c215e102 100644 --- a/src/core/cpu_newrec_compiler.cpp +++ b/src/core/cpu_newrec_compiler.cpp @@ -99,9 +99,8 @@ void CPU::NewRec::Compiler::BeginBlock() const void* CPU::NewRec::Compiler::CompileBlock(CodeCache::Block* block, u32* host_code_size, u32* host_far_code_size) { - JitCodeBuffer& buffer = CodeCache::GetCodeBuffer(); - Reset(block, buffer.GetFreeCodePointer(), buffer.GetFreeCodeSpace(), buffer.GetFreeFarCodePointer(), - buffer.GetFreeFarCodeSpace()); + Reset(block, CPU::CodeCache::GetFreeCodePointer(), CPU::CodeCache::GetFreeCodeSpace(), + CPU::CodeCache::GetFreeFarCodePointer(), CPU::CodeCache::GetFreeFarCodeSpace()); DEBUG_LOG("Block range: {:08X} -> {:08X}", block->pc, block->pc + block->size * 4); @@ -141,8 +140,8 @@ const void* CPU::NewRec::Compiler::CompileBlock(CodeCache::Block* block, u32* ho const void* code = EndCompile(&code_size, &far_code_size); *host_code_size = code_size; *host_far_code_size = far_code_size; - buffer.CommitCode(code_size); - buffer.CommitFarCode(far_code_size); + CPU::CodeCache::CommitCode(code_size); + CPU::CodeCache::CommitFarCode(far_code_size); return code; } @@ -2341,21 +2340,20 @@ void CPU::NewRec::BackpatchLoadStore(void* exception_pc, const CodeCache::Loadst static_cast(static_cast(info.cycles)) - (info.is_load ? Bus::RAM_READ_TICKS : 0); const TickCount cycles_to_remove = static_cast(static_cast(info.cycles)); - JitCodeBuffer& buffer = CodeCache::GetCodeBuffer(); - void* thunk_address = buffer.GetFreeFarCodePointer(); + void* thunk_address = CPU::CodeCache::GetFreeFarCodePointer(); const u32 thunk_size = CompileLoadStoreThunk( - thunk_address, buffer.GetFreeFarCodeSpace(), exception_pc, info.code_size, cycles_to_add, cycles_to_remove, + thunk_address, CPU::CodeCache::GetFreeFarCodeSpace(), exception_pc, info.code_size, cycles_to_add, cycles_to_remove, info.gpr_bitmask, info.address_register, info.data_register, info.AccessSize(), info.is_signed, info.is_load); #if 0 Log_DebugPrint("**Backpatch Thunk**"); - CodeCache::DisassembleAndLogHostCode(thunk_address, thunk_size); + CPU::CodeCache::DisassembleAndLogHostCode(thunk_address, thunk_size); #endif // backpatch to a jump to the slowmem handler - CodeCache::EmitJump(exception_pc, thunk_address, true); + CPU::CodeCache::EmitJump(exception_pc, thunk_address, true); - buffer.CommitFarCode(thunk_size); + CPU::CodeCache::CommitFarCode(thunk_size); } void CPU::NewRec::Compiler::InitSpeculativeRegs() diff --git a/src/core/cpu_recompiler_code_generator.h b/src/core/cpu_recompiler_code_generator.h index 68ffc31c9..35f15bb82 100644 --- a/src/core/cpu_recompiler_code_generator.h +++ b/src/core/cpu_recompiler_code_generator.h @@ -7,8 +7,6 @@ #include #include -#include "util/jit_code_buffer.h" - #include "cpu_code_cache_private.h" #include "cpu_recompiler_register_cache.h" #include "cpu_recompiler_thunks.h" @@ -49,11 +47,10 @@ public: const CodeCache::InstructionInfo* info; }; - CodeGenerator(JitCodeBuffer* code_buffer); + CodeGenerator(); ~CodeGenerator(); static const char* GetHostRegName(HostReg reg, RegSize size = HostPointerSize); - static void AlignCodeBuffer(JitCodeBuffer* code_buffer); static void BackpatchLoadStore(void* host_pc, const CodeCache::LoadstoreBackpatchInfo& lbi); @@ -267,8 +264,6 @@ private: bool Compile_cop0(Instruction instruction, const CodeCache::InstructionInfo& info); bool Compile_cop2(Instruction instruction, const CodeCache::InstructionInfo& info); - JitCodeBuffer* m_code_buffer; - CodeCache::Block* m_block = nullptr; CodeBlockInstruction m_block_start = {}; CodeBlockInstruction m_block_end = {}; diff --git a/src/core/cpu_recompiler_code_generator_aarch32.cpp b/src/core/cpu_recompiler_code_generator_aarch32.cpp index b8be018e1..afb6f92ac 100644 --- a/src/core/cpu_recompiler_code_generator_aarch32.cpp +++ b/src/core/cpu_recompiler_code_generator_aarch32.cpp @@ -358,12 +358,11 @@ static const a32::Register GetFastmemBasePtrReg() return GetHostReg32(RMEMBASEPTR); } -CodeGenerator::CodeGenerator(JitCodeBuffer* code_buffer) - : m_code_buffer(code_buffer), m_register_cache(*this), - m_near_emitter(static_cast(code_buffer->GetFreeCodePointer()), code_buffer->GetFreeCodeSpace(), - a32::A32), - m_far_emitter(static_cast(code_buffer->GetFreeFarCodePointer()), code_buffer->GetFreeFarCodeSpace(), - a32::A32), +CodeGenerator::CodeGenerator() + : m_register_cache(*this), m_near_emitter(static_cast(CPU::CodeCache::GetFreeCodePointer()), + CPU::CodeCache::GetFreeCodeSpace(), a32::A32), + m_far_emitter(static_cast(CPU::CodeCache::GetFreeFarCodePointer()), + CPU::CodeCache::GetFreeFarCodeSpace(), a32::A32), m_emit(&m_near_emitter) { InitHostRegs(); @@ -387,11 +386,6 @@ const char* CodeGenerator::GetHostRegName(HostReg reg, RegSize size /*= HostPoin } } -void CodeGenerator::AlignCodeBuffer(JitCodeBuffer* code_buffer) -{ - code_buffer->Align(16, 0x90); -} - void CodeGenerator::InitHostRegs() { // allocate nonvolatile before volatile @@ -414,17 +408,17 @@ void CodeGenerator::SwitchToNearCode() void* CodeGenerator::GetStartNearCodePointer() const { - return static_cast(m_code_buffer->GetFreeCodePointer()); + return static_cast(CPU::CodeCache::GetFreeCodePointer()); } void* CodeGenerator::GetCurrentNearCodePointer() const { - return static_cast(m_code_buffer->GetFreeCodePointer()) + m_near_emitter.GetCursorOffset(); + return static_cast(CPU::CodeCache::GetFreeCodePointer()) + m_near_emitter.GetCursorOffset(); } void* CodeGenerator::GetCurrentFarCodePointer() const { - return static_cast(m_code_buffer->GetFreeFarCodePointer()) + m_far_emitter.GetCursorOffset(); + return static_cast(CPU::CodeCache::GetFreeFarCodePointer()) + m_far_emitter.GetCursorOffset(); } Value CodeGenerator::GetValueInHostRegister(const Value& value, bool allow_zero_register /* = true */) @@ -517,17 +511,17 @@ const void* CodeGenerator::FinalizeBlock(u32* out_host_code_size, u32* out_host_ m_near_emitter.FinalizeCode(); m_far_emitter.FinalizeCode(); - const void* code = m_code_buffer->GetFreeCodePointer(); + const void* code = CPU::CodeCache::GetFreeCodePointer(); *out_host_code_size = static_cast(m_near_emitter.GetSizeOfCodeGenerated()); *out_host_far_code_size = static_cast(m_far_emitter.GetSizeOfCodeGenerated()); - m_code_buffer->CommitCode(static_cast(m_near_emitter.GetSizeOfCodeGenerated())); - m_code_buffer->CommitFarCode(static_cast(m_far_emitter.GetSizeOfCodeGenerated())); + CPU::CodeCache::CommitCode(static_cast(m_near_emitter.GetSizeOfCodeGenerated())); + CPU::CodeCache::CommitFarCode(static_cast(m_far_emitter.GetSizeOfCodeGenerated())); - m_near_emitter = CodeEmitter(static_cast(m_code_buffer->GetFreeCodePointer()), - m_code_buffer->GetFreeCodeSpace(), a32::A32); - m_far_emitter = CodeEmitter(static_cast(m_code_buffer->GetFreeFarCodePointer()), - m_code_buffer->GetFreeFarCodeSpace(), a32::A32); + m_near_emitter = CodeEmitter(static_cast(CPU::CodeCache::GetFreeCodePointer()), + CPU::CodeCache::GetFreeCodeSpace(), a32::A32); + m_far_emitter = CodeEmitter(static_cast(CPU::CodeCache::GetFreeFarCodePointer()), + CPU::CodeCache::GetFreeFarCodeSpace(), a32::A32); return code; } diff --git a/src/core/cpu_recompiler_code_generator_aarch64.cpp b/src/core/cpu_recompiler_code_generator_aarch64.cpp index 52f0fb572..c6a45d33f 100644 --- a/src/core/cpu_recompiler_code_generator_aarch64.cpp +++ b/src/core/cpu_recompiler_code_generator_aarch64.cpp @@ -482,12 +482,11 @@ static const a64::XRegister GetFastmemBasePtrReg() return GetHostReg64(RMEMBASEPTR); } -CodeGenerator::CodeGenerator(JitCodeBuffer* code_buffer) - : m_code_buffer(code_buffer), m_register_cache(*this), - m_near_emitter(static_cast(code_buffer->GetFreeCodePointer()), code_buffer->GetFreeCodeSpace(), - a64::PositionDependentCode), - m_far_emitter(static_cast(code_buffer->GetFreeFarCodePointer()), code_buffer->GetFreeFarCodeSpace(), - a64::PositionDependentCode), +CodeGenerator::CodeGenerator() + : m_register_cache(*this), m_near_emitter(static_cast(CPU::CodeCache::GetFreeCodePointer()), + CPU::CodeCache::GetFreeCodeSpace(), a64::PositionDependentCode), + m_far_emitter(static_cast(CPU::CodeCache::GetFreeFarCodePointer()), + CPU::CodeCache::GetFreeFarCodeSpace(), a64::PositionDependentCode), m_emit(&m_near_emitter) { // remove the temporaries from vixl's list to prevent it from using them. @@ -523,11 +522,6 @@ const char* CodeGenerator::GetHostRegName(HostReg reg, RegSize size /*= HostPoin } } -void CodeGenerator::AlignCodeBuffer(JitCodeBuffer* code_buffer) -{ - code_buffer->Align(16, 0x90); -} - void CodeGenerator::InitHostRegs() { // TODO: function calls mess up the parameter registers if we use them.. fix it @@ -551,17 +545,17 @@ void CodeGenerator::SwitchToNearCode() void* CodeGenerator::GetStartNearCodePointer() const { - return static_cast(m_code_buffer->GetFreeCodePointer()); + return static_cast(CPU::CodeCache::GetFreeCodePointer()); } void* CodeGenerator::GetCurrentNearCodePointer() const { - return static_cast(m_code_buffer->GetFreeCodePointer()) + m_near_emitter.GetCursorOffset(); + return static_cast(CPU::CodeCache::GetFreeCodePointer()) + m_near_emitter.GetCursorOffset(); } void* CodeGenerator::GetCurrentFarCodePointer() const { - return static_cast(m_code_buffer->GetFreeFarCodePointer()) + m_far_emitter.GetCursorOffset(); + return static_cast(CPU::CodeCache::GetFreeFarCodePointer()) + m_far_emitter.GetCursorOffset(); } Value CodeGenerator::GetValueInHostRegister(const Value& value, bool allow_zero_register /* = true */) @@ -671,12 +665,12 @@ const void* CodeGenerator::FinalizeBlock(u32* out_host_code_size, u32* out_host_ m_near_emitter.FinalizeCode(); m_far_emitter.FinalizeCode(); - const void* code = m_code_buffer->GetFreeCodePointer(); + const void* code = CPU::CodeCache::GetFreeCodePointer(); *out_host_code_size = static_cast(m_near_emitter.GetSizeOfCodeGenerated()); *out_host_far_code_size = static_cast(m_far_emitter.GetSizeOfCodeGenerated()); - m_code_buffer->CommitCode(static_cast(m_near_emitter.GetSizeOfCodeGenerated())); - m_code_buffer->CommitFarCode(static_cast(m_far_emitter.GetSizeOfCodeGenerated())); + CPU::CodeCache::CommitCode(static_cast(m_near_emitter.GetSizeOfCodeGenerated())); + CPU::CodeCache::CommitFarCode(static_cast(m_far_emitter.GetSizeOfCodeGenerated())); m_near_emitter.Reset(); m_far_emitter.Reset(); diff --git a/src/core/cpu_recompiler_code_generator_x64.cpp b/src/core/cpu_recompiler_code_generator_x64.cpp index 8679cbf65..d8868044e 100644 --- a/src/core/cpu_recompiler_code_generator_x64.cpp +++ b/src/core/cpu_recompiler_code_generator_x64.cpp @@ -369,10 +369,10 @@ static const Xbyak::Reg64 GetFastmemBasePtrReg() return GetHostReg64(RMEMBASEPTR); } -CodeGenerator::CodeGenerator(JitCodeBuffer* code_buffer) - : m_code_buffer(code_buffer), m_register_cache(*this), - m_near_emitter(code_buffer->GetFreeCodeSpace(), code_buffer->GetFreeCodePointer()), - m_far_emitter(code_buffer->GetFreeFarCodeSpace(), code_buffer->GetFreeFarCodePointer()), m_emit(&m_near_emitter) +CodeGenerator::CodeGenerator() + : m_register_cache(*this), m_near_emitter(CPU::CodeCache::GetFreeCodeSpace(), CPU::CodeCache::GetFreeCodePointer()), + m_far_emitter(CPU::CodeCache::GetFreeFarCodeSpace(), CPU::CodeCache::GetFreeFarCodePointer()), + m_emit(&m_near_emitter) { InitHostRegs(); } @@ -408,11 +408,6 @@ const char* CodeGenerator::GetHostRegName(HostReg reg, RegSize size /*= HostPoin } } -void CodeGenerator::AlignCodeBuffer(JitCodeBuffer* code_buffer) -{ - code_buffer->Align(16, 0x90); -} - void CodeGenerator::InitHostRegs() { #if defined(ABI_WIN64) @@ -571,8 +566,8 @@ const void* CodeGenerator::FinalizeBlock(u32* out_host_code_size, u32* out_host_ const void* code = m_near_emitter.getCode(); *out_host_code_size = near_size; *out_host_far_code_size = far_size; - m_code_buffer->CommitCode(near_size); - m_code_buffer->CommitFarCode(far_size); + CPU::CodeCache::CommitCode(near_size); + CPU::CodeCache::CommitFarCode(far_size); m_near_emitter.reset(); m_far_emitter.reset(); diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt index a1d22575e..37437bc25 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -46,8 +46,6 @@ add_library(util input_source.h iso_reader.cpp iso_reader.h - jit_code_buffer.cpp - jit_code_buffer.h page_fault_handler.cpp page_fault_handler.h platform_misc.h diff --git a/src/util/jit_code_buffer.cpp b/src/util/jit_code_buffer.cpp deleted file mode 100644 index 7b0357dd4..000000000 --- a/src/util/jit_code_buffer.cpp +++ /dev/null @@ -1,74 +0,0 @@ -// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin -// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0) - -#include "jit_code_buffer.h" - -#include "common/align.h" -#include "common/assert.h" -#include "common/memmap.h" - -#include -#include - -JitCodeBuffer::JitCodeBuffer() = default; - -JitCodeBuffer::~JitCodeBuffer() = default; - -void JitCodeBuffer::Reset(void* ptr, u32 size, u32 far_code_size /* = 0 */) -{ - Assert(far_code_size < size); - - m_total_size = size; - m_code_ptr = static_cast(ptr); - m_free_code_ptr = m_code_ptr; - m_code_size = size - far_code_size; - m_code_used = 0; - - m_far_code_size = far_code_size; - m_far_code_ptr = (far_code_size > 0) ? (static_cast(m_code_ptr) + m_code_size) : nullptr; - m_free_far_code_ptr = m_far_code_ptr; - m_far_code_used = 0; - - MemMap::BeginCodeWrite(); - - std::memset(m_code_ptr, 0, m_total_size); - MemMap::FlushInstructionCache(m_code_ptr, m_total_size); - - MemMap::EndCodeWrite(); -} - -void JitCodeBuffer::CommitCode(u32 length) -{ - if (length == 0) - return; - - MemMap::FlushInstructionCache(m_free_code_ptr, length); - - Assert(length <= (m_code_size - m_code_used)); - m_free_code_ptr += length; - m_code_used += length; -} - -void JitCodeBuffer::CommitFarCode(u32 length) -{ - if (length == 0) - return; - - MemMap::FlushInstructionCache(m_free_far_code_ptr, length); - - Assert(length <= (m_far_code_size - m_far_code_used)); - m_free_far_code_ptr += length; - m_far_code_used += length; -} - -void JitCodeBuffer::Align(u32 alignment, u8 padding_value) -{ - DebugAssert(Common::IsPow2(alignment)); - const u32 num_padding_bytes = - std::min(static_cast(Common::AlignUpPow2(reinterpret_cast(m_free_code_ptr), alignment) - - reinterpret_cast(m_free_code_ptr)), - GetFreeCodeSpace()); - std::memset(m_free_code_ptr, padding_value, num_padding_bytes); - m_free_code_ptr += num_padding_bytes; - m_code_used += num_padding_bytes; -} diff --git a/src/util/jit_code_buffer.h b/src/util/jit_code_buffer.h deleted file mode 100644 index 69ecb997d..000000000 --- a/src/util/jit_code_buffer.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin -// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0) - -#pragma once -#include "common/types.h" - -class JitCodeBuffer -{ -public: - JitCodeBuffer(); - ~JitCodeBuffer(); - - bool IsValid() const { return (m_code_ptr != nullptr); } - - void Reset(void* ptr, u32 size, u32 far_code_size = 0); - - ALWAYS_INLINE u8* GetCodePointer() const { return m_code_ptr; } - ALWAYS_INLINE u32 GetTotalSize() const { return m_total_size; } - ALWAYS_INLINE float GetUsedPct() const - { - return (static_cast(m_code_used) / static_cast(m_code_size)) * 100.0f; - } - ALWAYS_INLINE float GetFarUsedPct() const - { - return (static_cast(m_far_code_used) / static_cast(m_far_code_size)) * 100.0f; - } - ALWAYS_INLINE u32 GetTotalUsed() const { return m_code_used + m_far_code_used; } - - ALWAYS_INLINE u8* GetFreeCodePointer() const { return m_free_code_ptr; } - ALWAYS_INLINE u32 GetFreeCodeSpace() const { return static_cast(m_code_size - m_code_used); } - void CommitCode(u32 length); - - ALWAYS_INLINE u8* GetFreeFarCodePointer() const { return m_free_far_code_ptr; } - ALWAYS_INLINE u32 GetFreeFarCodeSpace() const { return static_cast(m_far_code_size - m_far_code_used); } - void CommitFarCode(u32 length); - - /// Adjusts the free code pointer to the specified alignment, padding with bytes. - /// Assumes alignment is a power-of-two. - void Align(u32 alignment, u8 padding_value); - -private: - u8* m_code_ptr = nullptr; - u8* m_free_code_ptr = nullptr; - u32 m_code_size = 0; - u32 m_code_reserve_size = 0; - u32 m_code_used = 0; - - u8* m_far_code_ptr = nullptr; - u8* m_free_far_code_ptr = nullptr; - u32 m_far_code_size = 0; - u32 m_far_code_used = 0; - - u32 m_total_size = 0; -}; diff --git a/src/util/util.vcxproj b/src/util/util.vcxproj index ef04d47ef..d9f98898a 100644 --- a/src/util/util.vcxproj +++ b/src/util/util.vcxproj @@ -36,7 +36,6 @@ - true @@ -147,7 +146,6 @@ - true diff --git a/src/util/util.vcxproj.filters b/src/util/util.vcxproj.filters index d94e15a5a..7fa83be8d 100644 --- a/src/util/util.vcxproj.filters +++ b/src/util/util.vcxproj.filters @@ -1,7 +1,6 @@  - @@ -75,7 +74,6 @@ -