ppsspp/Windows/GEDebugger/GEDebugger.cpp

497 lines
13 KiB
C++
Raw Normal View History

// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#include <vector>
#include <string>
#include <set>
#include "native/base/mutex.h"
2013-09-22 18:03:29 +00:00
#include "Windows/GEDebugger/GEDebugger.h"
#include "Windows/GEDebugger/SimpleGLWindow.h"
2013-09-25 13:24:53 +00:00
#include "Windows/GEDebugger/CtrlDisplayListView.h"
#include "Windows/GEDebugger/TabDisplayLists.h"
#include "Windows/GEDebugger/TabState.h"
#include "Windows/WindowsHost.h"
2013-09-27 11:11:11 +00:00
#include "Windows/WndMainWindow.h"
#include "Windows/main.h"
#include "GPU/GPUInterface.h"
#include "GPU/Common/GPUDebugInterface.h"
#include "GPU/GPUState.h"
2013-09-28 14:04:56 +00:00
#include "Core/Config.h"
2013-09-27 11:11:11 +00:00
#include <windowsx.h>
#include <commctrl.h>
enum PauseAction {
PAUSE_CONTINUE,
PAUSE_GETFRAMEBUF,
PAUSE_GETDEPTHBUF,
PAUSE_GETSTENCILBUF,
PAUSE_GETTEX,
};
static bool attached = false;
// TODO
static bool textureCaching = true;
static recursive_mutex pauseLock;
static condition_variable pauseWait;
static PauseAction pauseAction = PAUSE_CONTINUE;
static recursive_mutex actionLock;
static condition_variable actionWait;
static recursive_mutex breaksLock;
static std::vector<bool> breakCmds;
static std::set<u32> breakPCs;
static u32 tempBreakpoint = -1;
static std::set<u32> breakTextures;
static bool breakNextOp = false;
static bool breakNextDraw = false;
static bool bufferResult;
static GPUDebugBuffer bufferFrame;
static GPUDebugBuffer bufferDepth;
static GPUDebugBuffer bufferStencil;
static GPUDebugBuffer bufferTex;
// TODO: Simplify and move out of windows stuff, just block in a common way for everyone.
void CGEDebugger::Init() {
SimpleGLWindow::RegisterClass();
2013-09-25 13:24:53 +00:00
CtrlDisplayListView::registerClass();
}
2013-10-01 10:05:19 +00:00
bool CGEDebugger::IsAddressBreakPoint(u32 pc) {
lock_guard guard(breaksLock);
2013-10-01 10:05:19 +00:00
return breakPCs.find(pc) != breakPCs.end();
}
bool CGEDebugger::IsOpBreakPoint(u32 op) {
u8 cmd = op >> 24;
return breakCmds[cmd];
}
bool CGEDebugger::IsTextureBreakPoint(u32 op) {
u8 cmd = op >> 24;
bool interesting = (cmd >= GE_CMD_TEXADDR0 && cmd <= GE_CMD_TEXADDR7);
interesting = interesting || (cmd >= GE_CMD_TEXBUFWIDTH0 && cmd <= GE_CMD_TEXBUFWIDTH7);
if (!interesting || !gpuDebug) {
return false;
}
// Okay, so we just set a texture of some sort, check if it was one we were waiting for.
auto state = gpuDebug->GetGState();
int level = cmd <= GE_CMD_TEXADDR7 ? cmd - GE_CMD_TEXADDR0 : cmd - GE_CMD_TEXBUFWIDTH0;
lock_guard guard(breaksLock);
return breakTextures.find(state.getTextureAddress(level)) != breakTextures.end();
}
bool CGEDebugger::IsOpOrTextureBreakPoint(u32 op) {
return IsOpBreakPoint(op) || IsTextureBreakPoint(op);
}
static void SetPauseAction(PauseAction act) {
{
lock_guard guard(pauseLock);
actionLock.lock();
pauseAction = act;
}
pauseWait.notify_one();
actionWait.wait(actionLock);
actionLock.unlock();
}
static void RunPauseAction() {
lock_guard guard(actionLock);
switch (pauseAction) {
case PAUSE_CONTINUE:
// Don't notify, just go back, woke up by accident.
return;
case PAUSE_GETFRAMEBUF:
bufferResult = gpuDebug->GetCurrentFramebuffer(bufferFrame);
break;
case PAUSE_GETDEPTHBUF:
bufferResult = gpuDebug->GetCurrentDepthbuffer(bufferDepth);
break;
case PAUSE_GETSTENCILBUF:
bufferResult = gpuDebug->GetCurrentStencilbuffer(bufferStencil);
break;
case PAUSE_GETTEX:
bufferResult = gpuDebug->GetCurrentTexture(bufferTex);
break;
}
actionWait.notify_one();
pauseAction = PAUSE_CONTINUE;
}
static void ForceUnpause() {
lock_guard guard(pauseLock);
lock_guard actionGuard(actionLock);
pauseAction = PAUSE_CONTINUE;
pauseWait.notify_one();
}
CGEDebugger::CGEDebugger(HINSTANCE _hInstance, HWND _hParent)
: Dialog((LPCSTR)IDD_GEDEBUGGER, _hInstance, _hParent), primaryDisplay(PRIMARY_FRAMEBUF), frameWindow(NULL), texWindow(NULL) {
breakCmds.resize(256, false);
Core_ListenShutdown(ForceUnpause);
2013-09-28 14:04:56 +00:00
// minimum size = a little more than the default
RECT windowRect;
GetWindowRect(m_hDlg,&windowRect);
minWidth = windowRect.right-windowRect.left+10;
minHeight = windowRect.bottom-windowRect.top+10;
// it's ugly, but .rc coordinates don't match actual pixels and it screws
// up both the size and the aspect ratio
// TODO: Could be scrollable in case the framebuf is larger? Also should be better positioned.
RECT frameRect;
HWND frameWnd = GetDlgItem(m_hDlg,IDC_GEDBG_FRAME);
GetWindowRect(frameWnd,&frameRect);
MapWindowPoints(HWND_DESKTOP,m_hDlg,(LPPOINT)&frameRect,2);
MoveWindow(frameWnd,frameRect.left,frameRect.top,512,272,TRUE);
2013-09-27 11:11:11 +00:00
2013-09-28 18:57:02 +00:00
tabs = new TabControl(GetDlgItem(m_hDlg,IDC_GEDBG_MAINTAB));
HWND wnd = tabs->AddTabWindow(L"CtrlDisplayListView",L"Display List");
2013-09-27 16:03:08 +00:00
displayList = CtrlDisplayListView::getFrom(wnd);
2013-09-28 14:04:56 +00:00
flags = new TabStateFlags(_hInstance, m_hDlg);
tabs->AddTabDialog(flags, L"Flags");
2013-09-30 08:13:06 +00:00
lighting = new TabStateLighting(_hInstance, m_hDlg);
tabs->AddTabDialog(lighting, L"Lighting");
textureState = new TabStateTexture(_hInstance, m_hDlg);
tabs->AddTabDialog(textureState, L"Texture");
2013-09-30 08:13:06 +00:00
settings = new TabStateSettings(_hInstance, m_hDlg);
tabs->AddTabDialog(settings, L"Settings");
lists = new TabDisplayLists(_hInstance, m_hDlg);
tabs->AddTabDialog(lists, L"Lists");
tabs->ShowTab(0, true);
2013-09-28 23:02:05 +00:00
2013-09-28 14:04:56 +00:00
// set window position
int x = g_Config.iGEWindowX == -1 ? windowRect.left : g_Config.iGEWindowX;
int y = g_Config.iGEWindowY == -1 ? windowRect.top : g_Config.iGEWindowY;
int w = g_Config.iGEWindowW == -1 ? minWidth : g_Config.iGEWindowW;
int h = g_Config.iGEWindowH == -1 ? minHeight : g_Config.iGEWindowH;
MoveWindow(m_hDlg,x,y,w,h,FALSE);
}
CGEDebugger::~CGEDebugger() {
delete flags;
2013-09-30 08:13:06 +00:00
delete lighting;
delete textureState;
2013-09-30 08:13:06 +00:00
delete settings;
delete lists;
delete tabs;
}
void CGEDebugger::SetupPreviews() {
if (frameWindow == NULL) {
frameWindow = SimpleGLWindow::GetFrom(GetDlgItem(m_hDlg, IDC_GEDBG_FRAME));
frameWindow->Initialize(SimpleGLWindow::ALPHA_IGNORE | SimpleGLWindow::RESIZE_SHRINK_CENTER);
frameWindow->Clear();
}
if (texWindow == NULL) {
texWindow = SimpleGLWindow::GetFrom(GetDlgItem(m_hDlg, IDC_GEDBG_TEX));
texWindow->Initialize(SimpleGLWindow::ALPHA_BLEND | SimpleGLWindow::RESIZE_SHRINK_CENTER);
texWindow->Clear();
}
}
void CGEDebugger::UpdatePreviews() {
// TODO: Do something different if not paused?
wchar_t desc[256];
GPUDebugBuffer *primaryBuffer = NULL;
GPUgstate state;
bufferResult = false;
if (gpuDebug != NULL) {
state = gpuDebug->GetGState();
}
switch (primaryDisplay) {
case PRIMARY_FRAMEBUF:
SetPauseAction(PAUSE_GETFRAMEBUF);
primaryBuffer = &bufferFrame;
_snwprintf(desc, ARRAY_SIZE(desc), L"Color: 0x%08x (%dx%d)", state.getFrameBufRawAddress(), primaryBuffer->GetStride(), primaryBuffer->GetHeight());
break;
case PRIMARY_DEPTHBUF:
SetPauseAction(PAUSE_GETDEPTHBUF);
primaryBuffer = &bufferDepth;
_snwprintf(desc, ARRAY_SIZE(desc), L"Depth: 0x%08x (%dx%d)", state.getDepthBufRawAddress(), primaryBuffer->GetStride(), primaryBuffer->GetHeight());
break;
case PRIMARY_STENCILBUF:
SetPauseAction(PAUSE_GETSTENCILBUF);
primaryBuffer = &bufferStencil;
_snwprintf(desc, ARRAY_SIZE(desc), L"Stencil: 0x%08x (%dx%d)", state.getFrameBufRawAddress(), primaryBuffer->GetStride(), primaryBuffer->GetHeight());
break;
}
if (bufferResult && primaryBuffer != NULL) {
auto fmt = SimpleGLWindow::Format(primaryBuffer->GetFormat());
frameWindow->Draw(primaryBuffer->GetData(), primaryBuffer->GetStride(), primaryBuffer->GetHeight(), primaryBuffer->GetFlipped(), fmt);
SetDlgItemText(m_hDlg, IDC_GEDBG_FRAMEBUFADDR, desc);
} else {
frameWindow->Clear();
SetDlgItemText(m_hDlg, IDC_GEDBG_FRAMEBUFADDR, L"Failed");
}
bufferResult = false;
SetPauseAction(PAUSE_GETTEX);
if (bufferResult) {
auto fmt = SimpleGLWindow::Format(bufferTex.GetFormat());
texWindow->Draw(bufferTex.GetData(), bufferTex.GetStride(), bufferTex.GetHeight(), bufferTex.GetFlipped(), fmt);
if (gpuDebug != NULL) {
if (state.isTextureAlphaUsed()) {
texWindow->SetFlags(SimpleGLWindow::ALPHA_BLEND | SimpleGLWindow::RESIZE_SHRINK_CENTER);
} else {
texWindow->SetFlags(SimpleGLWindow::RESIZE_SHRINK_CENTER);
}
_snwprintf(desc, ARRAY_SIZE(desc), L"Texture: 0x%08x (%dx%d)", state.getTextureAddress(0), state.getTextureWidth(0), state.getTextureHeight(0));
SetDlgItemText(m_hDlg, IDC_GEDBG_TEXADDR, desc);
}
} else {
texWindow->Clear();
if (gpuDebug == NULL || state.isTextureMapEnabled()) {
SetDlgItemText(m_hDlg, IDC_GEDBG_TEXADDR, L"Texture: failed");
} else {
SetDlgItemText(m_hDlg, IDC_GEDBG_TEXADDR, L"Texture: disabled");
}
}
DisplayList list;
if (gpuDebug != NULL && gpuDebug->GetCurrentDisplayList(list)) {
displayList->setDisplayList(list);
}
2013-09-28 23:02:05 +00:00
flags->Update();
2013-09-30 08:13:06 +00:00
lighting->Update();
textureState->Update();
2013-09-30 08:13:06 +00:00
settings->Update();
2013-09-28 23:02:05 +00:00
lists->Update();
}
2013-09-28 14:04:56 +00:00
void CGEDebugger::UpdateSize(WORD width, WORD height)
{
// only resize the tab for now
HWND tabControl = GetDlgItem(m_hDlg, IDC_GEDBG_MAINTAB);
RECT tabRect;
GetWindowRect(tabControl,&tabRect);
MapWindowPoints(HWND_DESKTOP,m_hDlg,(LPPOINT)&tabRect,2);
tabRect.right = tabRect.left + (width-tabRect.left*2); // assume same gap on both sides
tabRect.bottom = tabRect.top + (height-tabRect.top-tabRect.left); // assume same gap on bottom too
MoveWindow(tabControl,tabRect.left,tabRect.top,tabRect.right-tabRect.left,tabRect.bottom-tabRect.top,TRUE);
}
void CGEDebugger::SavePosition()
{
RECT rc;
if (GetWindowRect(m_hDlg, &rc))
{
g_Config.iGEWindowX = rc.left;
g_Config.iGEWindowY = rc.top;
g_Config.iGEWindowW = rc.right - rc.left;
g_Config.iGEWindowH = rc.bottom - rc.top;
}
}
2013-09-27 16:03:08 +00:00
BOOL CGEDebugger::DlgProc(UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_INITDIALOG:
return TRUE;
2013-09-28 14:04:56 +00:00
case WM_GETMINMAXINFO:
{
MINMAXINFO* minmax = (MINMAXINFO*) lParam;
minmax->ptMinTrackSize.x = minWidth;
minmax->ptMinTrackSize.y = minHeight;
}
return TRUE;
case WM_SIZE:
2013-09-28 14:04:56 +00:00
UpdateSize(LOWORD(lParam), HIWORD(lParam));
SavePosition();
return TRUE;
case WM_MOVE:
SavePosition();
return TRUE;
case WM_CLOSE:
Show(false);
return TRUE;
case WM_SHOWWINDOW:
SetupPreviews();
break;
case WM_ACTIVATE:
if (wParam == WA_ACTIVE || wParam == WA_CLICKACTIVE) {
g_activeWindow = WINDOW_GEDEBUGGER;
}
break;
2013-09-27 11:11:11 +00:00
case WM_NOTIFY:
switch (wParam)
{
case IDC_GEDBG_MAINTAB:
2013-09-28 18:57:02 +00:00
tabs->HandleNotify(lParam);
2013-09-27 11:11:11 +00:00
break;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_GEDBG_STEPDRAW:
attached = true;
SetupPreviews();
2013-09-25 13:24:53 +00:00
pauseWait.notify_one();
breakNextOp = false;
breakNextDraw = true;
break;
case IDC_GEDBG_STEP:
SendMessage(m_hDlg,WM_GEDBG_STEPDISPLAYLIST,0,0);
break;
case IDC_GEDBG_RESUME:
frameWindow->Clear();
texWindow->Clear();
SetDlgItemText(m_hDlg, IDC_GEDBG_FRAMEBUFADDR, L"");
SetDlgItemText(m_hDlg, IDC_GEDBG_TEXADDR, L"");
// TODO: detach? Should probably have separate UI, or just on activate?
breakNextOp = false;
breakNextDraw = false;
pauseWait.notify_one();
break;
}
break;
case WM_GEDBG_BREAK_CMD:
{
u32 pc = (u32)wParam;
tempBreakpoint = -1;
auto info = gpuDebug->DissassembleOp(pc);
NOTICE_LOG(COMMON, "Waiting at %08x, %s", pc, info.desc.c_str());
UpdatePreviews();
}
break;
case WM_GEDBG_BREAK_DRAW:
{
NOTICE_LOG(COMMON, "Waiting at a draw");
UpdatePreviews();
}
break;
case WM_GEDBG_STEPDISPLAYLIST:
attached = true;
SetupPreviews();
pauseWait.notify_one();
breakNextOp = true;
breakNextDraw = false;
break;
2013-10-01 10:05:19 +00:00
case WM_GEDBG_TOGGLEPCBREAKPOINT:
{
lock_guard guard(breaksLock);
u32 pc = (u32)wParam;
2013-10-01 10:05:19 +00:00
auto iter = breakPCs.find(pc);
if (iter != breakPCs.end())
breakPCs.erase(iter);
else
breakPCs.insert(pc);
}
break;
case WM_GEDBG_RUNTOWPARAM:
{
lock_guard guard(breaksLock);
u32 pc = (u32)wParam;
tempBreakpoint = pc;
SendMessage(m_hDlg,WM_COMMAND,IDC_GEDBG_RESUME,0);
}
break;
}
return FALSE;
}
// The below WindowsHost methods are called on the GPU thread.
bool WindowsHost::GPUDebuggingActive() {
return attached;
}
static void PauseWithMessage(UINT msg, WPARAM wParam = NULL, LPARAM lParam = NULL) {
lock_guard guard(pauseLock);
if (coreState != CORE_RUNNING && coreState != CORE_NEXTFRAME) {
return;
}
PostMessage(geDebuggerWindow->GetDlgHandle(), msg, wParam, lParam);
do {
RunPauseAction();
pauseWait.wait(pauseLock);
} while (pauseAction != PAUSE_CONTINUE);
}
void WindowsHost::GPUNotifyCommand(u32 pc) {
u32 op = Memory::ReadUnchecked_U32(pc);
u8 cmd = op >> 24;
if (breakNextOp || CGEDebugger::IsOpOrTextureBreakPoint(op) || CGEDebugger::IsAddressBreakPoint(pc) || pc == tempBreakpoint) {
PauseWithMessage(WM_GEDBG_BREAK_CMD, (WPARAM) pc);
}
}
void WindowsHost::GPUNotifyDisplay(u32 framebuf, u32 stride, int format) {
}
void WindowsHost::GPUNotifyDraw() {
if (breakNextDraw) {
PauseWithMessage(WM_GEDBG_BREAK_DRAW);
}
}
void WindowsHost::GPUNotifyTextureAttachment(u32 addr) {
}
bool WindowsHost::GPUAllowTextureCache(u32 addr) {
return textureCaching;
}