piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-15 22:09:19 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity
68aab70c75
dolphin/Source/Core/Common/DebugInterface.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

116 lines
4.4 KiB
C
Raw Normal View History

Add missing license headers
2015-05-23 22:32:32 -06:00
// Copyright 2008 Dolphin Emulator Project
treewide: convert GPLv2+ license info to SPDX tags SPDX standardizes how source code conveys its copyright and licensing information. See https://spdx.github.io/spdx-spec/1-rationale/ . SPDX tags are adopted in many large projects, including things like the Linux kernel.
2021-07-04 19:22:19 -06:00
// SPDX-License-Identifier: GPL-2.0-or-later
Add missing license headers
2015-05-23 22:32:32 -06:00
Replace all include guard ifdefs with "#pragma once"
2014-02-10 11:54:46 -07:00
#pragma once
set svn:eol-style=native for **.h git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1438 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-12-07 21:46:09 -07:00
Fix memory breakpoint when checking the middle of the data If the delimiters of a memory aren't exactly the same as an address, but their size includes the memory breakpoint delimiter, the break will not go through. This makes it so that you can specify a search for a memory breakpoint with a data size and will check if the data fits with that size on all memory breakpoints so the breaks go through.
2017-03-02 18:07:24 -07:00
#include <cstddef>
Initial megacommit. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-07-12 11:40:22 -06:00
#include <string>
DebugInterface: Watches methods added Move Watches to Common
2018-01-29 09:58:02 -07:00
#include <vector>
#include "Common/CommonTypes.h"
Debugger: Add a Thread widget DebugInterface: Add GetThreads WatchWidget: Update widget on AddWatch
2020-03-21 01:48:49 -06:00
#include "Common/Debug/Threads.h"
Common/DebugInterface: Use forward declarations where applicable We're allowed (by the standard) to forward declare types within std::vector, so we can replace direct includes with forward declarations and then include the types where they're directly needed. While we're at it, we can remove an unused inclusion of <cstring>, given nothing in the header uses anything from it. This also revealed an indirect inclusion, which this also resolves.
2019-07-08 16:07:11 -06:00
namespace Common::Debug
{
struct MemoryPatch;
struct Watch;
} // namespace Common::Debug
set svn:eol-style=native for **.h git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1438 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-12-07 21:46:09 -07:00
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
namespace Core
{
class CPUThreadGuard;
} // namespace Core
Common/DebugInterface: Namespace code under the Common namespace Gets more identifiers out of the global namespace and makes it more in line with the rest of the (mostly) namespaced Common code.
2018-07-09 19:47:50 -06:00
namespace Common
{
Initial megacommit. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-07-12 11:40:22 -06:00
class DebugInterface
Turned on Warnings as Errors for all vcprojs. Fixed almost all of the warnings in win32. Added many SVN Ignore settings. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@283 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-08-23 09:28:24 -06:00
{
protected:
Common/DebugInterface: Default virtual destructor While we're at it, we can also default the constructor and destructor of inheriting classes in their respective cpp file to prevent the construction and destruction of non-trivial types being inlined into other regions of code.
2019-07-08 15:44:56 -06:00
virtual ~DebugInterface() = default;
Reformat all the things!
2018-04-12 06:18:04 -06:00
Initial megacommit. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-07-12 11:40:22 -06:00
public:
DebugInterface: Watches methods added Move Watches to Common
2018-01-29 09:58:02 -07:00
// Watches
Common/Watches: std::move strings where applicable Allows calling code to move the std::string into the Watch instances, avoiding copies.
2019-07-08 15:28:07 -06:00
virtual std::size_t SetWatch(u32 address, std::string name = "") = 0;
Common/DebugInterface: Use forward declarations where applicable We're allowed (by the standard) to forward declare types within std::vector, so we can replace direct includes with forward declarations and then include the types where they're directly needed. While we're at it, we can remove an unused inclusion of <cstring>, given nothing in the header uses anything from it. This also revealed an indirect inclusion, which this also resolves.
2019-07-08 16:07:11 -06:00
virtual const Debug::Watch& GetWatch(std::size_t index) const = 0;
virtual const std::vector<Debug::Watch>& GetWatches() const = 0;
DebugInterface: Watches methods added Move Watches to Common
2018-01-29 09:58:02 -07:00
virtual void UnsetWatch(u32 address) = 0;
Common/Watches: std::move strings where applicable Allows calling code to move the std::string into the Watch instances, avoiding copies.
2019-07-08 15:28:07 -06:00
virtual void UpdateWatch(std::size_t index, u32 address, std::string name) = 0;
DebugInterface: Watches methods added Move Watches to Common
2018-01-29 09:58:02 -07:00
virtual void UpdateWatchAddress(std::size_t index, u32 address) = 0;
Common/Watches: std::move strings where applicable Allows calling code to move the std::string into the Watch instances, avoiding copies.
2019-07-08 15:28:07 -06:00
virtual void UpdateWatchName(std::size_t index, std::string name) = 0;
Core: add locked state to watches
2022-12-22 22:17:09 -07:00
virtual void UpdateWatchLockedState(std::size_t index, bool locked) = 0;
DebugInterface: Watches methods added Move Watches to Common
2018-01-29 09:58:02 -07:00
virtual void EnableWatch(std::size_t index) = 0;
virtual void DisableWatch(std::size_t index) = 0;
virtual bool HasEnabledWatch(u32 address) const = 0;
virtual void RemoveWatch(std::size_t index) = 0;
virtual void LoadWatchesFromStrings(const std::vector<std::string>& watches) = 0;
virtual std::vector<std::string> SaveWatchesToStrings() const = 0;
virtual void ClearWatches() = 0;
DebugInterface: MemoryPatches methods added CodeView: Restore instruction added
2018-05-21 08:46:03 -06:00
// Memory Patches
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual void SetPatch(const Core::CPUThreadGuard& guard, u32 address, u32 value) = 0;
virtual void SetPatch(const Core::CPUThreadGuard& guard, u32 address, std::vector<u8> value) = 0;
virtual void SetFramePatch(const Core::CPUThreadGuard& guard, u32 address, u32 value) = 0;
virtual void SetFramePatch(const Core::CPUThreadGuard& guard, u32 address,
std::vector<u8> value) = 0;
Common/DebugInterface: Use forward declarations where applicable We're allowed (by the standard) to forward declare types within std::vector, so we can replace direct includes with forward declarations and then include the types where they're directly needed. While we're at it, we can remove an unused inclusion of <cstring>, given nothing in the header uses anything from it. This also revealed an indirect inclusion, which this also resolves.
2019-07-08 16:07:11 -06:00
virtual const std::vector<Debug::MemoryPatch>& GetPatches() const = 0;
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual void UnsetPatch(const Core::CPUThreadGuard& guard, u32 address) = 0;
virtual void EnablePatch(const Core::CPUThreadGuard& guard, std::size_t index) = 0;
virtual void DisablePatch(const Core::CPUThreadGuard& guard, std::size_t index) = 0;
DebugInterface: MemoryPatches methods added CodeView: Restore instruction added
2018-05-21 08:46:03 -06:00
virtual bool HasEnabledPatch(u32 address) const = 0;
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual void RemovePatch(const Core::CPUThreadGuard& guard, std::size_t index) = 0;
virtual void ClearPatches(const Core::CPUThreadGuard& guard) = 0;
virtual void ApplyExistingPatch(const Core::CPUThreadGuard& guard, std::size_t index) = 0;
DebugInterface: MemoryPatches methods added CodeView: Restore instruction added
2018-05-21 08:46:03 -06:00
Debugger: Add a Thread widget DebugInterface: Add GetThreads WatchWidget: Update widget on AddWatch
2020-03-21 01:48:49 -06:00
// Threads
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual Debug::Threads GetThreads(const Core::CPUThreadGuard& guard) const = 0;
Debugger: Add a Thread widget DebugInterface: Add GetThreads WatchWidget: Update widget on AddWatch
2020-03-21 01:48:49 -06:00
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual std::string Disassemble(const Core::CPUThreadGuard* /*guard*/, u32 /*address*/) const
{
return "NODEBUGGER";
}
virtual std::string GetRawMemoryString(const Core::CPUThreadGuard& /*guard*/, int /*memory*/,
u32 /*address*/) const
Common: asterisks go against the type name not the variable name
2016-01-21 12:46:25 -07:00
{
DebugInterface: Make GetRawMemoryString return a std::string
2016-10-07 07:56:02 -06:00
return "NODEBUGGER";
Common: asterisks go against the type name not the variable name
2016-01-21 12:46:25 -07:00
}
Common/DebugInterface: Mark a few member functions as const Quite a few member functions act as a means to query information. Given these don't actually modify object state, they can be made const.
2019-07-08 16:25:14 -06:00
virtual bool IsAlive() const { return true; }
virtual bool IsBreakpoint(u32 /*address*/) const { return false; }
Common/DebugInterface: Use u32 instead of unsigned int consistently Previously u32 was being used for part of the interface and unsigned int was being used for other parts. This makes the interface fully consistent by using only one type. We opt for u32 here given they communicate the same thing (for platforms we care about where int is 32-bit), while also being less to read.
2019-07-08 15:53:47 -06:00
virtual void SetBreakpoint(u32 /*address*/) {}
virtual void ClearBreakpoint(u32 /*address*/) {}
Change the DebugInterface, PPCDebugInterface, and DSPDebugInterface to use CamelCase names. This is the standard coding convention in the codebase, so our interfaces should use it too.
2014-03-02 22:39:08 -07:00
virtual void ClearAllBreakpoints() {}
Common/DebugInterface: Use u32 instead of unsigned int consistently Previously u32 was being used for part of the interface and unsigned int was being used for other parts. This makes the interface fully consistent by using only one type. We opt for u32 here given they communicate the same thing (for platforms we care about where int is 32-bit), while also being less to read.
2019-07-08 15:53:47 -06:00
virtual void ToggleBreakpoint(u32 /*address*/) {}
Add ClearAllMemChecks to DebugInterface Breakpoints have one, but memchecks don't, despite being cleared directly in the breakpoint window. Now DolphinWX should call the interface functions and not the direct functions of the breakpoints or memchecks for clearing.
2014-03-05 18:51:27 -07:00
virtual void ClearAllMemChecks() {}
Common/DebugInterface: Mark a few member functions as const Quite a few member functions act as a means to query information. Given these don't actually modify object state, they can be made const.
2019-07-08 16:25:14 -06:00
virtual bool IsMemCheck(u32 /*address*/, size_t /*size*/) const { return false; }
Common/DebugInterface: Use u32 instead of unsigned int consistently Previously u32 was being used for part of the interface and unsigned int was being used for other parts. This makes the interface fully consistent by using only one type. We opt for u32 here given they communicate the same thing (for platforms we care about where int is 32-bit), while also being less to read.
2019-07-08 15:53:47 -06:00
virtual void ToggleMemCheck(u32 /*address*/, bool /*read*/, bool /*write*/, bool /*log*/) {}
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual u32 ReadMemory(const Core::CPUThreadGuard& /*guard*/, u32 /*address*/) const { return 0; }
virtual void WriteExtraMemory(const Core::CPUThreadGuard& /*guard*/, int /*memory*/,
u32 /*value*/, u32 /*address*/)
{
}
virtual u32 ReadExtraMemory(const Core::CPUThreadGuard& /*guard*/, int /*memory*/,
u32 /*address*/) const
{
return 0;
}
virtual u32 ReadInstruction(const Core::CPUThreadGuard& /*guard*/, u32 /*address*/) const
{
return 0;
}
Gekko constistancy changes. Add context item to codeview to show or copy a load/store target memory address from instructions at or near PC when paused.
2022-03-17 13:53:38 -06:00
virtual std::optional<u32>
GetMemoryAddressFromInstruction(const std::string& /*instruction*/) const
{
return std::nullopt;
}
Common/DebugInterface: Mark a few member functions as const Quite a few member functions act as a means to query information. Given these don't actually modify object state, they can be made const.
2019-07-08 16:25:14 -06:00
virtual u32 GetPC() const { return 0; }
Common/DebugInterface: Use u32 instead of unsigned int consistently Previously u32 was being used for part of the interface and unsigned int was being used for other parts. This makes the interface fully consistent by using only one type. We opt for u32 here given they communicate the same thing (for platforms we care about where int is 32-bit), while also being less to read.
2019-07-08 15:53:47 -06:00
virtual void SetPC(u32 /*address*/) {}
Change the DebugInterface, PPCDebugInterface, and DSPDebugInterface to use CamelCase names. This is the standard coding convention in the codebase, so our interfaces should use it too.
2014-03-02 22:39:08 -07:00
virtual void Step() {}
virtual void RunToBreakpoint() {}
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual u32 GetColor(const Core::CPUThreadGuard* /*guard*/, u32 /*address*/) const
{
return 0xFFFFFFFF;
}
Common/DebugInterface: Mark a few member functions as const Quite a few member functions act as a means to query information. Given these don't actually modify object state, they can be made const.
2019-07-08 16:25:14 -06:00
virtual std::string GetDescription(u32 /*address*/) const = 0;
DolphinQt: Properly lock CPU before accessing emulated memory This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
2023-02-12 03:07:11 -07:00
virtual void Clear(const Core::CPUThreadGuard& guard) = 0;
Initial megacommit. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-07-12 11:40:22 -06:00
};
Common/DebugInterface: Namespace code under the Common namespace Gets more identifiers out of the global namespace and makes it more in line with the rest of the (mostly) namespaced Common code.
2018-07-09 19:47:50 -06:00
} // namespace Common
Reference in New Issue Copy Permalink