diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp index 10fdcdf8a2..4ad9cc69d5 100644 --- a/src/core/cpu_manager.cpp +++ b/src/core/cpu_manager.cpp @@ -26,15 +26,42 @@ CpuManager::~CpuManager() = default; void CpuManager::Initialize() { num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1; gpu_barrier = std::make_unique(num_cores + 1); - for (std::size_t core = 0; core < num_cores; core++) - core_data[core].host_thread = std::jthread([this, core](std::stop_token token) { RunThread(token, core); }); + for (std::size_t core = 0; core < num_cores; core++) { + core_data[core].host_thread = std::jthread([this, core](std::stop_token token) { + // Initialization + system.RegisterCoreThread(core); + Common::SetCurrentThreadName(("CPUCore_" + std::to_string(core)).c_str()); + Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical); +#ifdef __ANDROID__ + // Aimed specifically for Snapdragon 8 Elite devices + // This kills performance on desktop, but boosts perf for UMA devices + // like the S8E. Mediatek and Mali likely won't suffer. + Common::PinCurrentThreadToPerformanceCore(core); +#endif + auto& data = core_data[core]; + data.host_context = Common::Fiber::ThreadToFiber(); + // Running + if (gpu_barrier->Sync(token)) { + if (!is_async_gpu && !is_multicore) { + system.GPU().ObtainContext(); + } + auto& kernel = system.Kernel(); + auto& scheduler = *kernel.CurrentScheduler(); + auto* thread = scheduler.GetSchedulerCurrentThread(); + Kernel::SetCurrentThread(kernel, thread); + Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext()); + } + // Cleanup + data.host_context->Exit(); + }); + } } void CpuManager::Shutdown() { - for (std::size_t core = 0; core < num_cores; core++) { - if (core_data[core].host_thread.joinable()) { - core_data[core].host_thread.request_stop(); - core_data[core].host_thread.join(); + for (auto it = core_data.begin(); it != core_data.end(); ++it) { + if (it->host_thread.joinable()) { + it->host_thread.request_stop(); + it->host_thread.join(); } } } @@ -183,41 +210,4 @@ void CpuManager::ShutdownThread() { UNREACHABLE(); } -void CpuManager::RunThread(std::stop_token token, std::size_t core) { - /// Initialization - system.RegisterCoreThread(core); - std::string name = is_multicore ? ("CPUCore_" + std::to_string(core)) : std::string{"CPUThread"}; - Common::SetCurrentThreadName(name.c_str()); - Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical); -#ifdef __ANDROID__ - // Aimed specifically for Snapdragon 8 Elite devices - // This kills performance on desktop, but boosts perf for UMA devices - // like the S8E. Mediatek and Mali likely won't suffer. - Common::PinCurrentThreadToPerformanceCore(core); -#endif - auto& data = core_data[core]; - data.host_context = Common::Fiber::ThreadToFiber(); - - // Cleanup - SCOPE_EXIT { - data.host_context->Exit(); - }; - - // Running - if (!gpu_barrier->Sync(token)) { - return; - } - - if (!is_async_gpu && !is_multicore) { - system.GPU().ObtainContext(); - } - - auto& kernel = system.Kernel(); - auto& scheduler = *kernel.CurrentScheduler(); - auto* thread = scheduler.GetSchedulerCurrentThread(); - Kernel::SetCurrentThread(kernel, thread); - - Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext()); -} - } // namespace Core diff --git a/src/core/cpu_manager.h b/src/core/cpu_manager.h index a249dc5f76..6dffa79d1d 100644 --- a/src/core/cpu_manager.h +++ b/src/core/cpu_manager.h @@ -84,7 +84,6 @@ private: void GuestActivate(); void HandleInterrupt(); void ShutdownThread(); - void RunThread(std::stop_token stop_token, std::size_t core); struct CoreData { std::shared_ptr host_context; diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp index 77cdab76d7..3e3da62ffe 100644 --- a/src/core/hle/kernel/physical_core.cpp +++ b/src/core/hle/kernel/physical_core.cpp @@ -119,10 +119,9 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) { // Since scheduling may occur here, we cannot use any cached // state after returning from calls we make. - - // Notify the debugger and go to sleep if a breakpoint was hit, - // or if the thread is unable to continue for any reason. if (breakpoint || (prefetch_abort && may_abort)) { + // Notify the debugger and go to sleep if a breakpoint was hit, + // or if the thread is unable to continue for any reason. if (breakpoint) { interface->RewindBreakpointInstruction(); } @@ -133,26 +132,19 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) { } thread->RequestSuspend(SuspendType::Debug); return; - } - - // Notify the debugger and go to sleep on data abort. - if (data_abort) { + } else if (data_abort) { + // Notify the debugger and go to sleep on data abort. if (system.DebuggerEnabled()) { system.GetDebugger().NotifyThreadWatchpoint(thread, *interface->HaltedWatchpoint()); } thread->RequestSuspend(SuspendType::Debug); return; - } - - // Handle system calls. - if (supervisor_call) { - // Perform call. + } else if (supervisor_call) { + // Handle system calls: Perform call. Svc::Call(system, interface->GetSvcNumber()); return; - } - - // Handle external interrupt sources. - if (interrupt || m_is_single_core) { + } else if (interrupt || m_is_single_core) { + // Handle external interrupt sources. return; } } @@ -160,16 +152,14 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) { void PhysicalCore::LoadContext(const KThread* thread) { auto* const process = thread->GetOwnerProcess(); - if (!process) { + if (process) { // Kernel threads do not run on emulated CPU cores. - return; - } - - auto* interface = process->GetArmInterface(m_core_index); - if (interface) { - interface->SetContext(thread->GetContext()); - interface->SetTpidrroEl0(GetInteger(thread->GetTlsAddress())); - interface->SetWatchpointArray(&process->GetWatchpoints()); + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->SetContext(thread->GetContext()); + interface->SetTpidrroEl0(GetInteger(thread->GetTlsAddress())); + interface->SetWatchpointArray(&process->GetWatchpoints()); + } } } @@ -179,14 +169,12 @@ void PhysicalCore::LoadSvcArguments(const KProcess& process, std::spanGetOwnerProcess(); - if (!process) { + if (process) { // Kernel threads do not run on emulated CPU cores. - return; - } - - auto* interface = process->GetArmInterface(m_core_index); - if (interface) { - interface->GetContext(thread->GetContext()); + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->GetContext(thread->GetContext()); + } } } @@ -206,13 +194,11 @@ void PhysicalCore::CloneFpuStatus(KThread* dst) const { void PhysicalCore::LogBacktrace() { auto* process = GetCurrentProcessPointer(m_kernel); - if (!process) { - return; - } - - auto* interface = process->GetArmInterface(m_core_index); - if (interface) { - interface->LogBacktrace(process); + if (process) { + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->LogBacktrace(process); + } } } @@ -240,12 +226,10 @@ void PhysicalCore::Interrupt() { m_on_interrupt.notify_one(); // If there is no thread running, we are done. - if (arm_interface == nullptr) { - return; + if (arm_interface != nullptr) { + // Interrupt the CPU. + arm_interface->SignalInterrupt(thread); } - - // Interrupt the CPU. - arm_interface->SignalInterrupt(thread); } void PhysicalCore::ClearInterrupt() { diff --git a/src/dynarmic/src/dynarmic/backend/arm64/a32_interface.cpp b/src/dynarmic/src/dynarmic/backend/arm64/a32_interface.cpp index 91adc5783b..349b4ada4c 100644 --- a/src/dynarmic/src/dynarmic/backend/arm64/a32_interface.cpp +++ b/src/dynarmic/src/dynarmic/backend/arm64/a32_interface.cpp @@ -32,45 +32,31 @@ struct Jit::Impl final { , core(conf) {} HaltReason Run() { - ASSERT(!jit_interface->is_executing); - PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&halt_reason))); - - jit_interface->is_executing = true; - SCOPE_EXIT { - jit_interface->is_executing = false; - }; - + ASSERT(!is_executing); + PerformRequestedCacheInvalidation(HaltReason(Atomic::Load(&halt_reason))); + is_executing = true; HaltReason hr = core.Run(current_address_space, current_state, &halt_reason); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } HaltReason Step() { - ASSERT(!jit_interface->is_executing); - PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&halt_reason))); - - jit_interface->is_executing = true; - SCOPE_EXIT { - jit_interface->is_executing = false; - }; - + ASSERT(!is_executing); + PerformRequestedCacheInvalidation(HaltReason(Atomic::Load(&halt_reason))); + is_executing = true; HaltReason hr = core.Step(current_address_space, current_state, &halt_reason); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } void ClearCache() { - std::unique_lock lock{invalidation_mutex}; invalidate_entire_cache = true; HaltExecution(HaltReason::CacheInvalidation); } void InvalidateCacheRange(std::uint32_t start_address, std::size_t length) { - std::unique_lock lock{invalidation_mutex}; invalid_cache_ranges.add(boost::icl::discrete_interval::closed(start_address, static_cast(start_address + length - 1))); HaltExecution(HaltReason::CacheInvalidation); } @@ -80,12 +66,12 @@ struct Jit::Impl final { } void HaltExecution(HaltReason hr) { - Atomic::Or(&halt_reason, static_cast(hr)); + Atomic::Or(&halt_reason, u32(hr)); Atomic::Barrier(); } void ClearHalt(HaltReason hr) { - Atomic::And(&halt_reason, ~static_cast(hr)); + Atomic::And(&halt_reason, ~u32(hr)); Atomic::Barrier(); } @@ -132,21 +118,15 @@ struct Jit::Impl final { private: void PerformRequestedCacheInvalidation(HaltReason hr) { if (Has(hr, HaltReason::CacheInvalidation)) { - std::unique_lock lock{invalidation_mutex}; - ClearHalt(HaltReason::CacheInvalidation); - if (invalidate_entire_cache) { current_address_space.ClearCache(); - invalidate_entire_cache = false; invalid_cache_ranges.clear(); return; } - if (!invalid_cache_ranges.empty()) { current_address_space.InvalidateCacheRanges(invalid_cache_ranges); - invalid_cache_ranges.clear(); return; } @@ -160,10 +140,9 @@ private: A32Core core; volatile u32 halt_reason = 0; - - std::mutex invalidation_mutex; boost::icl::interval_set invalid_cache_ranges; bool invalidate_entire_cache = false; + bool is_executing = false; }; Jit::Jit(UserConfig conf) diff --git a/src/dynarmic/src/dynarmic/backend/arm64/a64_interface.cpp b/src/dynarmic/src/dynarmic/backend/arm64/a64_interface.cpp index 10324394a5..81de3aa31f 100644 --- a/src/dynarmic/src/dynarmic/backend/arm64/a64_interface.cpp +++ b/src/dynarmic/src/dynarmic/backend/arm64/a64_interface.cpp @@ -27,50 +27,37 @@ using namespace Backend::Arm64; struct Jit::Impl final { Impl(Jit*, A64::UserConfig conf) - : conf(conf) - , current_address_space(conf) - , core(conf) {} + : conf(conf) + , current_address_space(conf) + , core(conf) + {} HaltReason Run() { ASSERT(!is_executing); - PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&halt_reason))); - is_executing = true; - SCOPE_EXIT { - is_executing = false; - }; - + PerformRequestedCacheInvalidation(HaltReason(Atomic::Load(&halt_reason))); HaltReason hr = core.Run(current_address_space, current_state, &halt_reason); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } HaltReason Step() { ASSERT(!is_executing); - PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&halt_reason))); - is_executing = true; - SCOPE_EXIT { - is_executing = false; - }; - + PerformRequestedCacheInvalidation(HaltReason(Atomic::Load(&halt_reason))); HaltReason hr = core.Step(current_address_space, current_state, &halt_reason); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } void ClearCache() { - std::unique_lock lock{invalidation_mutex}; invalidate_entire_cache = true; HaltExecution(HaltReason::CacheInvalidation); } void InvalidateCacheRange(std::uint64_t start_address, std::size_t length) { - std::unique_lock lock{invalidation_mutex}; invalid_cache_ranges.add(boost::icl::discrete_interval::closed(start_address, start_address + length - 1)); HaltExecution(HaltReason::CacheInvalidation); } @@ -80,11 +67,13 @@ struct Jit::Impl final { } void HaltExecution(HaltReason hr) { - Atomic::Or(&halt_reason, static_cast(hr)); + Atomic::Or(&halt_reason, u32(hr)); + Atomic::Barrier(); } void ClearHalt(HaltReason hr) { - Atomic::And(&halt_reason, ~static_cast(hr)); + Atomic::And(&halt_reason, ~u32(hr)); + Atomic::Barrier(); } std::uint64_t PC() const { @@ -147,10 +136,6 @@ struct Jit::Impl final { current_state.exclusive_state = false; } - bool IsExecuting() const { - return is_executing; - } - std::string Disassemble() const { return {}; } @@ -158,21 +143,15 @@ struct Jit::Impl final { private: void PerformRequestedCacheInvalidation(HaltReason hr) { if (Has(hr, HaltReason::CacheInvalidation)) { - std::unique_lock lock{invalidation_mutex}; - ClearHalt(HaltReason::CacheInvalidation); - if (invalidate_entire_cache) { current_address_space.ClearCache(); - invalidate_entire_cache = false; invalid_cache_ranges.clear(); return; } - if (!invalid_cache_ranges.empty()) { current_address_space.InvalidateCacheRanges(invalid_cache_ranges); - invalid_cache_ranges.clear(); return; } @@ -185,8 +164,6 @@ private: A64Core core; volatile u32 halt_reason = 0; - - std::mutex invalidation_mutex; boost::icl::interval_set invalid_cache_ranges; bool invalidate_entire_cache = false; bool is_executing = false; @@ -307,10 +284,6 @@ void Jit::ClearExclusiveState() { impl->ClearExclusiveState(); } -bool Jit::IsExecuting() const { - return impl->IsExecuting(); -} - std::string Jit::Disassemble() const { return impl->Disassemble(); } diff --git a/src/dynarmic/src/dynarmic/backend/riscv64/a32_interface.cpp b/src/dynarmic/src/dynarmic/backend/riscv64/a32_interface.cpp index c0f65a49ed..9652f03d30 100644 --- a/src/dynarmic/src/dynarmic/backend/riscv64/a32_interface.cpp +++ b/src/dynarmic/src/dynarmic/backend/riscv64/a32_interface.cpp @@ -32,41 +32,29 @@ struct Jit::Impl final { , core(conf) {} HaltReason Run() { - ASSERT(!jit_interface->is_executing); - jit_interface->is_executing = true; - SCOPE_EXIT { - jit_interface->is_executing = false; - }; - + ASSERT(!is_executing); + is_executing = true; HaltReason hr = core.Run(current_address_space, current_state, &halt_reason); - RequestCacheInvalidation(); - + is_executing = false; return hr; } HaltReason Step() { - ASSERT(!jit_interface->is_executing); - jit_interface->is_executing = true; - SCOPE_EXIT { - jit_interface->is_executing = false; - }; - + ASSERT(!is_executing); + is_executing = true; UNIMPLEMENTED(); - RequestCacheInvalidation(); - + is_executing = false; return HaltReason{}; } void ClearCache() { - std::unique_lock lock{invalidation_mutex}; invalidate_entire_cache = true; HaltExecution(HaltReason::CacheInvalidation); } void InvalidateCacheRange(u32 start_address, size_t length) { - std::unique_lock lock{invalidation_mutex}; invalid_cache_ranges.add(boost::icl::discrete_interval::closed(start_address, static_cast(start_address + length - 1))); HaltExecution(HaltReason::CacheInvalidation); } @@ -132,12 +120,10 @@ private: A32JitState current_state{}; A32AddressSpace current_address_space; A32Core core; - volatile u32 halt_reason = 0; - - std::mutex invalidation_mutex; boost::icl::interval_set invalid_cache_ranges; bool invalidate_entire_cache = false; + bool is_executing = false; }; Jit::Jit(UserConfig conf) diff --git a/src/dynarmic/src/dynarmic/backend/x64/a32_interface.cpp b/src/dynarmic/src/dynarmic/backend/x64/a32_interface.cpp index e540839fd5..5afc41b864 100644 --- a/src/dynarmic/src/dynarmic/backend/x64/a32_interface.cpp +++ b/src/dynarmic/src/dynarmic/backend/x64/a32_interface.cpp @@ -75,14 +75,9 @@ struct Jit::Impl { ~Impl() = default; HaltReason Run() { - ASSERT(!jit_interface->is_executing); + ASSERT(!is_executing); PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&jit_state.halt_reason))); - - jit_interface->is_executing = true; - SCOPE_EXIT { - jit_interface->is_executing = false; - }; - + is_executing = true; const CodePtr current_codeptr = [this] { // RSB optimization const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSBPtrMask; @@ -93,44 +88,34 @@ struct Jit::Impl { return GetCurrentBlock(); }(); - const HaltReason hr = block_of_code.RunCode(&jit_state, current_codeptr); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } HaltReason Step() { - ASSERT(!jit_interface->is_executing); - PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&jit_state.halt_reason))); - - jit_interface->is_executing = true; - SCOPE_EXIT { - jit_interface->is_executing = false; - }; - + ASSERT(!is_executing); + PerformRequestedCacheInvalidation(HaltReason(Atomic::Load(&jit_state.halt_reason))); + is_executing = true; const HaltReason hr = block_of_code.StepCode(&jit_state, GetCurrentSingleStep()); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } void ClearCache() { - std::unique_lock lock{invalidation_mutex}; invalidate_entire_cache = true; HaltExecution(HaltReason::CacheInvalidation); } void InvalidateCacheRange(std::uint32_t start_address, std::size_t length) { - std::unique_lock lock{invalidation_mutex}; - invalid_cache_ranges.add(boost::icl::discrete_interval::closed(start_address, static_cast(start_address + length - 1))); + invalid_cache_ranges.add(boost::icl::discrete_interval::closed(start_address, u32(start_address + length - 1))); HaltExecution(HaltReason::CacheInvalidation); } void Reset() { - ASSERT(!jit_interface->is_executing); + ASSERT(!is_executing); jit_state = {}; } @@ -223,14 +208,10 @@ private: void PerformRequestedCacheInvalidation(HaltReason hr) { if (Has(hr, HaltReason::CacheInvalidation)) { - std::unique_lock lock{invalidation_mutex}; - ClearHalt(HaltReason::CacheInvalidation); - if (!invalidate_entire_cache && invalid_cache_ranges.empty()) { return; } - jit_state.ResetRSB(); if (invalidate_entire_cache) { block_of_code.ClearCache(); @@ -251,11 +232,10 @@ private: // Keep it here, you don't wanna mess with the fuckery that's initializer lists const A32::UserConfig conf; Jit* jit_interface; - // Requests made during execution to invalidate the cache are queued up here. - bool invalidate_entire_cache = false; boost::icl::interval_set invalid_cache_ranges; - std::mutex invalidation_mutex; + bool invalidate_entire_cache = false; + bool is_executing = false; }; Jit::Jit(UserConfig conf) diff --git a/src/dynarmic/src/dynarmic/backend/x64/a64_interface.cpp b/src/dynarmic/src/dynarmic/backend/x64/a64_interface.cpp index 44c63bdfc5..b6240fdb89 100644 --- a/src/dynarmic/src/dynarmic/backend/x64/a64_interface.cpp +++ b/src/dynarmic/src/dynarmic/backend/x64/a64_interface.cpp @@ -75,14 +75,8 @@ public: HaltReason Run() { ASSERT(!is_executing); PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&jit_state.halt_reason))); - is_executing = true; - SCOPE_EXIT { - this->is_executing = false; - }; - // TODO: Check code alignment - const CodePtr current_code_ptr = [this] { // RSB optimization const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSBPtrMask; @@ -94,37 +88,28 @@ public: }(); const HaltReason hr = block_of_code.RunCode(&jit_state, current_code_ptr); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } HaltReason Step() { ASSERT(!is_executing); - PerformRequestedCacheInvalidation(static_cast(Atomic::Load(&jit_state.halt_reason))); - + PerformRequestedCacheInvalidation(HaltReason(Atomic::Load(&jit_state.halt_reason))); is_executing = true; - SCOPE_EXIT { - this->is_executing = false; - }; - const HaltReason hr = block_of_code.StepCode(&jit_state, GetCurrentSingleStep()); - PerformRequestedCacheInvalidation(hr); - + is_executing = false; return hr; } void ClearCache() { - std::unique_lock lock{invalidation_mutex}; invalidate_entire_cache = true; HaltExecution(HaltReason::CacheInvalidation); } void InvalidateCacheRange(u64 start_address, size_t length) { - std::unique_lock lock{invalidation_mutex}; - const auto end_address = static_cast(start_address + length - 1); + const auto end_address = u64(start_address + length - 1); const auto range = boost::icl::discrete_interval::closed(start_address, end_address); invalid_cache_ranges.add(range); HaltExecution(HaltReason::CacheInvalidation); @@ -136,11 +121,11 @@ public: } void HaltExecution(HaltReason hr) { - Atomic::Or(&jit_state.halt_reason, static_cast(hr)); + Atomic::Or(&jit_state.halt_reason, u32(hr)); } void ClearHalt(HaltReason hr) { - Atomic::And(&jit_state.halt_reason, ~static_cast(hr)); + Atomic::And(&jit_state.halt_reason, ~u32(hr)); } u64 GetSP() const { @@ -228,10 +213,6 @@ public: jit_state.exclusive_state = 0; } - bool IsExecuting() const { - return is_executing; - } - std::string Disassemble() const { const size_t size = reinterpret_cast(block_of_code.getCurr()) - reinterpret_cast(block_of_code.GetCodeBegin()); auto const* p = reinterpret_cast(block_of_code.GetCodeBegin()); @@ -280,14 +261,10 @@ private: void PerformRequestedCacheInvalidation(HaltReason hr) { if (Has(hr, HaltReason::CacheInvalidation)) { - std::unique_lock lock{invalidation_mutex}; - ClearHalt(HaltReason::CacheInvalidation); - if (!invalidate_entire_cache && invalid_cache_ranges.empty()) { return; } - jit_state.ResetRSB(); if (invalidate_entire_cache) { block_of_code.ClearCache(); @@ -306,10 +283,9 @@ private: BlockOfCode block_of_code; A64EmitX64 emitter; Optimization::PolyfillOptions polyfill_options; - bool is_executing = false; - bool invalidate_entire_cache = false; boost::icl::interval_set invalid_cache_ranges; - std::mutex invalidation_mutex; + bool invalidate_entire_cache = false; + bool is_executing = false; }; Jit::Jit(UserConfig conf) @@ -421,10 +397,6 @@ void Jit::ClearExclusiveState() { impl->ClearExclusiveState(); } -bool Jit::IsExecuting() const { - return impl->IsExecuting(); -} - std::string Jit::Disassemble() const { return impl->Disassemble(); } diff --git a/src/dynarmic/src/dynarmic/interface/A32/a32.h b/src/dynarmic/src/dynarmic/interface/A32/a32.h index bc30b59c1e..504d0debf4 100644 --- a/src/dynarmic/src/dynarmic/interface/A32/a32.h +++ b/src/dynarmic/src/dynarmic/interface/A32/a32.h @@ -84,21 +84,11 @@ public: /// Clears exclusive state for this core. void ClearExclusiveState(); - /** - * Returns true if Jit::Run was called but hasn't returned yet. - * i.e.: We're in a callback. - */ - bool IsExecuting() const { - return is_executing; - } - /// @brief Disassemble the instructions following the current pc and return /// the resulting instructions as a vector of their string representations. std::string Disassemble() const; private: - bool is_executing = false; - struct Impl; std::unique_ptr impl; }; diff --git a/src/dynarmic/src/dynarmic/interface/A64/a64.h b/src/dynarmic/src/dynarmic/interface/A64/a64.h index e8d2352702..cdda06fc36 100644 --- a/src/dynarmic/src/dynarmic/interface/A64/a64.h +++ b/src/dynarmic/src/dynarmic/interface/A64/a64.h @@ -116,12 +116,6 @@ public: /// Clears exclusive state for this core. void ClearExclusiveState(); - /** - * Returns true if Jit::Run was called but hasn't returned yet. - * i.e.: We're in a callback. - */ - bool IsExecuting() const; - /// @brief Disassemble the instructions following the current pc and return /// the resulting instructions as a vector of their string representations. std::string Disassemble() const;