mirror of
https://github.com/wiiu-env/gdbstub_plugin.git
synced 2024-06-29 03:06:06 +02:00
1229 lines
33 KiB
Python
1229 lines
33 KiB
Python
|
|
from PyQt5.QtWidgets import *
|
|
from PyQt5.QtGui import *
|
|
from PyQt5.QtCore import *
|
|
import socket
|
|
import struct
|
|
import string
|
|
import sys
|
|
import os
|
|
|
|
import disassemble
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Signals
|
|
"""""""""""""""""""""""""""
|
|
|
|
class EventHolder(QObject):
|
|
Connected = pyqtSignal()
|
|
Closed = pyqtSignal()
|
|
BreakPointChanged = pyqtSignal()
|
|
Exception = pyqtSignal(object)
|
|
Continue = pyqtSignal(object)
|
|
Step = pyqtSignal(object)
|
|
events = EventHolder()
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Debugger client
|
|
"""""""""""""""""""""""""""
|
|
|
|
class ExceptionState:
|
|
|
|
exceptionNames = ["DSI", "ISI", "Program"]
|
|
|
|
def __init__(self, message):
|
|
#Convert tuple to list to make it mutable
|
|
data = message.data
|
|
self.gpr = list(struct.unpack_from(">32I", data, 8))
|
|
self.cr, self.lr, self.ctr, self.xer = struct.unpack_from(">4I", data, 0x88)
|
|
self.srr0, self.srr1, self.ex0, self.ex1 = struct.unpack_from(">4I", data, 0x98)
|
|
self.fpr = list(struct.unpack_from(">32d", data, 0xB8))
|
|
self.gqr = list(struct.unpack_from(">8I", data, 0x1BC))
|
|
self.psf = list(struct.unpack_from(">32d", data, 0x1E0))
|
|
|
|
self.thread = message.arg
|
|
|
|
self.exceptionName = self.exceptionNames[message.type]
|
|
|
|
self.stepping = False
|
|
|
|
def isBreakPoint(self):
|
|
return self.exceptionName == "Program" and self.srr1 & 0x20000
|
|
|
|
def isFatal(self):
|
|
return not self.isBreakPoint()
|
|
|
|
|
|
class Message:
|
|
#Server messages
|
|
DSI = 0
|
|
ISI = 1
|
|
Program = 2
|
|
|
|
#Client messages
|
|
Continue = 0
|
|
Step = 1
|
|
StepOver = 2
|
|
|
|
def __init__(self, type, data, arg):
|
|
self.type = type
|
|
self.data = data
|
|
self.arg = arg
|
|
|
|
|
|
class Thread:
|
|
|
|
cores = {
|
|
1: "Core 0",
|
|
2: "Core 1",
|
|
4: "Core 2"
|
|
}
|
|
|
|
def __init__(self, data, offs=0):
|
|
self.handle = struct.unpack_from(">I", data, offs)[0]
|
|
self.core = self.cores[struct.unpack_from(">I", data, offs + 4)[0]]
|
|
self.priority = struct.unpack_from(">I", data, offs + 8)[0]
|
|
self.stackBase = struct.unpack_from(">I", data, offs + 12)[0]
|
|
self.stackEnd = struct.unpack_from(">I", data, offs + 16)[0]
|
|
self.entryPoint = struct.unpack_from(">I", data, offs + 20)[0]
|
|
self.namelen = struct.unpack_from(">I", data, offs + 24)[0]
|
|
self.name = data[offs + 28 : offs + 28 + self.namelen].decode("shift-jis")
|
|
|
|
|
|
class Module:
|
|
def __init__(self, data, offs=0):
|
|
self.textAddr = struct.unpack_from(">I", data, offs)[0]
|
|
self.textSize = struct.unpack_from(">I", data, offs + 4)[0]
|
|
self.dataAddr = struct.unpack_from(">I", data, offs + 8)[0]
|
|
self.dataSize = struct.unpack_from(">I", data, offs + 12)[0]
|
|
self.entryPoint = struct.unpack_from(">I", data, offs + 16)[0]
|
|
|
|
self.namelen = struct.unpack_from(">I", data, offs + 20)[0]
|
|
self.name = data[offs + 24 : offs + 24 + self.namelen].decode("ascii")
|
|
|
|
|
|
COMMAND_CLOSE = 0
|
|
COMMAND_READ = 1
|
|
COMMAND_WRITE = 2
|
|
COMMAND_WRITE_CODE = 3
|
|
COMMAND_GET_MODULE_NAME = 4
|
|
COMMAND_GET_MODULE_LIST = 5
|
|
COMMAND_GET_THREAD_LIST = 6
|
|
COMMAND_GET_STACK_TRACE = 7
|
|
COMMAND_TOGGLE_BREAKPOINT = 8
|
|
COMMAND_POKE_REGISTERS = 9
|
|
COMMAND_RECEIVE_MESSAGES = 10
|
|
COMMAND_SEND_MESSAGE = 11
|
|
|
|
class Debugger:
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
self.reset()
|
|
|
|
self.messageHandlers = {
|
|
Message.DSI: self.handleException,
|
|
Message.ISI: self.handleException,
|
|
Message.Program: self.handleException
|
|
}
|
|
|
|
def reset(self):
|
|
self.connected = False
|
|
self.breakpoints = []
|
|
self.trapEvents = []
|
|
self.crashEvents = []
|
|
self.threads = []
|
|
|
|
def connect(self, host):
|
|
self.s = socket.socket()
|
|
self.s.settimeout(4)
|
|
self.s.connect((host, 1560))
|
|
self.connected = True
|
|
events.Connected.emit()
|
|
|
|
def handleClose(self):
|
|
self.reset()
|
|
events.Closed.emit()
|
|
|
|
def close(self):
|
|
self.sendbyte(COMMAND_CLOSE)
|
|
self.s.close()
|
|
self.handleClose()
|
|
|
|
def read(self, addr, num):
|
|
self.sendbyte(COMMAND_READ)
|
|
self.sendall(struct.pack(">II", addr, num))
|
|
data = self.recvall(num)
|
|
return data
|
|
|
|
def write(self, addr, data):
|
|
self.sendbyte(COMMAND_WRITE)
|
|
self.sendall(struct.pack(">II", addr, len(data)))
|
|
self.sendall(data)
|
|
|
|
def writeCode(self, addr, data):
|
|
self.sendbyte(COMMAND_WRITE_CODE)
|
|
self.sendall(struct.pack(">II", addr, len(data)))
|
|
self.sendall(data)
|
|
|
|
def writeInstr(self, addr, value):
|
|
self.writeCode(addr, struct.pack(">I", value))
|
|
|
|
def getModuleName(self):
|
|
self.sendbyte(COMMAND_GET_MODULE_NAME)
|
|
length = struct.unpack(">I", self.recvall(4))[0]
|
|
return self.recvall(length).decode("ascii") + ".rpx"
|
|
|
|
def getModuleList(self):
|
|
self.sendbyte(COMMAND_GET_MODULE_LIST)
|
|
length = struct.unpack(">I", self.recvall(4))[0]
|
|
data = self.recvall(length)
|
|
|
|
offset = 0
|
|
modules = []
|
|
while offset < length:
|
|
module = Module(data, offset)
|
|
modules.append(module)
|
|
offset += 24 + len(module.name)
|
|
return sorted(modules, key=lambda m: m.textAddr)
|
|
|
|
def getThreadList(self):
|
|
self.sendbyte(COMMAND_GET_THREAD_LIST)
|
|
length = struct.unpack(">I", self.recvall(4))[0]
|
|
data = self.recvall(length)
|
|
|
|
offset = 0
|
|
self.threads = []
|
|
while offset < length:
|
|
thread = Thread(data, offset)
|
|
self.threads.append(thread)
|
|
offset += 28 + thread.namelen
|
|
return self.threads
|
|
|
|
def getStackTrace(self, state):
|
|
self.sendbyte(COMMAND_GET_STACK_TRACE)
|
|
self.sendall(struct.pack(">I", state.thread))
|
|
count = struct.unpack(">I", self.recvall(4))[0]
|
|
trace = struct.unpack(">%iI" %count, self.recvall(4 * count))
|
|
return trace
|
|
|
|
def toggleBreakPoint(self, addr):
|
|
if addr in self.breakpoints:
|
|
self.breakpoints.remove(addr)
|
|
else:
|
|
self.breakpoints.append(addr)
|
|
|
|
self.sendbyte(COMMAND_TOGGLE_BREAKPOINT)
|
|
self.sendall(struct.pack(">I", addr))
|
|
events.BreakPointChanged.emit()
|
|
|
|
def pokeRegisters(self, state):
|
|
self.sendbyte(COMMAND_POKE_REGISTERS)
|
|
self.sendall(struct.pack(">I", state.thread))
|
|
self.sendall(struct.pack(">32I32d", *state.gpr, *state.fpr))
|
|
|
|
def updateMessages(self):
|
|
self.sendbyte(COMMAND_RECEIVE_MESSAGES)
|
|
count = struct.unpack(">I", self.recvall(4))[0]
|
|
for i in range(count):
|
|
type, ptr, length, arg = struct.unpack(">IIII", self.recvall(16))
|
|
data = None
|
|
if length:
|
|
data = self.recvall(length)
|
|
self.messageHandlers[type](Message(type, data, arg))
|
|
|
|
def sendMessage(self, message, data0=0, data1=0, data2=0):
|
|
self.sendbyte(COMMAND_SEND_MESSAGE)
|
|
self.sendall(struct.pack(">IIII", message, data0, data1, data2))
|
|
|
|
def handleException(self, msg):
|
|
state = ExceptionState(msg)
|
|
events.Exception.emit(state)
|
|
|
|
def continueThread(self, state): self.sendCrashMessage(Message.Continue, state)
|
|
def stepInto(self, state): self.sendCrashMessage(Message.Step, state)
|
|
def stepOver(self, state): self.sendCrashMessage(Message.StepOver, state)
|
|
|
|
def sendCrashMessage(self, message, state):
|
|
self.sendMessage(message, state.thread)
|
|
if message == Message.Continue:
|
|
state.stepping = False
|
|
events.Continue.emit(state)
|
|
else:
|
|
state.stepping = True
|
|
events.Step.emit(state)
|
|
|
|
def _findThread(self, handle):
|
|
for thread in self.threads:
|
|
if thread.handle == handle:
|
|
return thread
|
|
|
|
def findThread(self, handle):
|
|
thread = self._findThread(handle)
|
|
if not thread:
|
|
self.getThreadList()
|
|
thread = self._findThread(handle)
|
|
return thread
|
|
|
|
def sendbyte(self, byte):
|
|
self.sendall(bytes([byte]))
|
|
|
|
def sendall(self, data):
|
|
if self.connected:
|
|
try:
|
|
self.s.sendall(data)
|
|
except socket.error:
|
|
self.handleClose()
|
|
|
|
def recvall(self, num):
|
|
if not self.connected:
|
|
return bytes(num)
|
|
|
|
try:
|
|
data = b""
|
|
while len(data) < num:
|
|
chunk = self.s.recv(num - len(data))
|
|
if not chunk:
|
|
self.handleClose()
|
|
return bytes(num)
|
|
data += chunk
|
|
except socket.error:
|
|
self.handleClose()
|
|
return bytes(num)
|
|
|
|
return data
|
|
debugger = Debugger()
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Custom widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class HexSpinBox(QAbstractSpinBox):
|
|
def __init__(self, stepSize = 1):
|
|
super().__init__()
|
|
self._value = 0
|
|
self.stepSize = stepSize
|
|
|
|
def validate(self, text, pos):
|
|
if all([char in "0123456789abcdefABCDEF" for char in text]):
|
|
if not text:
|
|
return QValidator.Intermediate, text.upper(), pos
|
|
|
|
value = int(text, 16)
|
|
if value <= 0xFFFFFFFF:
|
|
self._value = value
|
|
if value % self.stepSize:
|
|
self._value -= value % self.stepSize
|
|
return QValidator.Acceptable, text.upper(), pos
|
|
return QValidator.Acceptable, text.upper(), pos
|
|
|
|
return QValidator.Invalid, text.upper(), pos
|
|
|
|
def stepBy(self, steps):
|
|
self._value = min(max(self._value + steps * self.stepSize, 0), 0x100000000 - self.stepSize)
|
|
self.lineEdit().setText("%X" %self._value)
|
|
|
|
def stepEnabled(self):
|
|
return QAbstractSpinBox.StepUpEnabled | QAbstractSpinBox.StepDownEnabled
|
|
|
|
def setValue(self, value):
|
|
self._value = value
|
|
self.lineEdit().setText("%X" %self._value)
|
|
|
|
def value(self):
|
|
return self._value
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Memory widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
def format_hex(blob, offs):
|
|
return "%02X" %blob[offs]
|
|
|
|
def format_ascii(blob, offs):
|
|
char = chr(blob[offs])
|
|
if char in string.ascii_letters + string.digits + string.punctuation + " ":
|
|
return char
|
|
return "?"
|
|
|
|
def format_float(blob, offs):
|
|
value = struct.unpack_from(">f", blob, offs)[0]
|
|
if abs(value) >= 1000000 or 0 < abs(value) < 0.000001:
|
|
return "%e" %value
|
|
return ("%.8f" %value).rstrip("0")
|
|
|
|
|
|
class MemoryViewer(QWidget):
|
|
|
|
class Format:
|
|
Hex = 0
|
|
Ascii = 1
|
|
Float = 2
|
|
|
|
Width = 1, 1, 4
|
|
Funcs = format_hex, format_ascii, format_float
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
self.layout = QGridLayout()
|
|
|
|
for i in range(16):
|
|
self.layout.addWidget(QLabel("%X" %i, self), 0, i + 1)
|
|
self.addrLabels = []
|
|
for i in range(16):
|
|
label = QLabel("%X" %(i * 0x10), self)
|
|
self.layout.addWidget(label, i + 1, 0)
|
|
self.addrLabels.append(label)
|
|
self.dataCells = []
|
|
|
|
self.base = 0
|
|
self.format = self.Format.Hex
|
|
self.updateData()
|
|
|
|
self.setLayout(self.layout)
|
|
|
|
events.Connected.connect(self.connected)
|
|
|
|
def connected(self):
|
|
self.setBase(0x10000000)
|
|
|
|
def setFormat(self, format):
|
|
self.format = format
|
|
self.updateData()
|
|
|
|
def setBase(self, base):
|
|
window.mainWidget.tabWidget.memoryTab.memoryInfo.baseBox.setValue(base)
|
|
self.base = base
|
|
for i in range(16):
|
|
self.addrLabels[i].setText("%X" %(self.base + i * 0x10))
|
|
self.updateData()
|
|
|
|
def updateData(self):
|
|
for cell in self.dataCells:
|
|
self.layout.removeWidget(cell)
|
|
cell.setParent(None)
|
|
|
|
if debugger.connected:
|
|
blob = debugger.read(self.base, 0x100)
|
|
else:
|
|
blob = b"\x00" * 0x100
|
|
|
|
width = self.Width[self.format]
|
|
func = self.Funcs[self.format]
|
|
for i in range(16 // width):
|
|
for j in range(16):
|
|
label = QLabel(func(blob, j * 0x10 + i * width), self)
|
|
self.layout.addWidget(label, j + 1, i * width + 1, 1, width)
|
|
self.dataCells.append(label)
|
|
|
|
|
|
class MemoryInfo(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.dataTypeLabel = QLabel("Data type:")
|
|
self.dataTypeBox = QComboBox()
|
|
self.dataTypeBox.addItems(["Hex", "Ascii", "Float"])
|
|
self.dataTypeBox.currentIndexChanged.connect(self.updateDataType)
|
|
|
|
self.baseLabel = QLabel("Address:")
|
|
self.baseBox = HexSpinBox(0x10)
|
|
self.baseButton = QPushButton("Update", self)
|
|
self.baseButton.clicked.connect(self.updateMemoryBase)
|
|
|
|
self.pokeAddr = HexSpinBox(4)
|
|
self.pokeValue = HexSpinBox()
|
|
self.pokeButton = QPushButton("Poke", self)
|
|
self.pokeButton.clicked.connect(self.pokeMemory)
|
|
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.baseLabel, 0, 0)
|
|
self.layout.addWidget(self.baseBox, 0, 1)
|
|
self.layout.addWidget(self.baseButton, 0, 2)
|
|
self.layout.addWidget(self.pokeAddr, 1, 0)
|
|
self.layout.addWidget(self.pokeValue, 1, 1)
|
|
self.layout.addWidget(self.pokeButton, 1, 2)
|
|
self.layout.addWidget(self.dataTypeLabel, 2, 0)
|
|
self.layout.addWidget(self.dataTypeBox, 2, 1, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
def updateDataType(self, index):
|
|
window.mainWidget.tabWidget.memoryTab.memoryViewer.setFormat(index)
|
|
|
|
def updateMemoryBase(self):
|
|
window.mainWidget.tabWidget.memoryTab.memoryViewer.setBase(self.baseBox.value())
|
|
|
|
def pokeMemory(self):
|
|
debugger.write(self.pokeAddr.value(), struct.pack(">I", self.pokeValue.value()))
|
|
window.mainWidget.tabWidget.memoryTab.memoryViewer.updateData()
|
|
|
|
|
|
class MemoryTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.memoryInfo = MemoryInfo()
|
|
self.memoryViewer = MemoryViewer()
|
|
self.layout = QHBoxLayout()
|
|
self.layout.addWidget(self.memoryInfo)
|
|
self.layout.addWidget(self.memoryViewer)
|
|
self.setLayout(self.layout)
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Disassembly widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class DisassemblyWidget(QTextEdit):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.setTextInteractionFlags(Qt.NoTextInteraction)
|
|
|
|
self.setMinimumWidth(500)
|
|
|
|
self.currentInstruction = None
|
|
self.selectedAddress = 0
|
|
self.setBase(0)
|
|
|
|
events.Closed.connect(self.updateHighlight)
|
|
events.BreakPointChanged.connect(self.updateHighlight)
|
|
|
|
def setCurrentInstruction(self, instr):
|
|
self.currentInstruction = instr
|
|
if instr is not None:
|
|
self.setBase(instr - 0x20)
|
|
else:
|
|
self.updateHighlight()
|
|
|
|
def setBase(self, base):
|
|
self.base = base
|
|
self.updateText()
|
|
self.updateHighlight()
|
|
|
|
def updateText(self):
|
|
if debugger.connected:
|
|
blob = debugger.read(self.base, 0x60)
|
|
else:
|
|
blob = b"\x00" * 0x60
|
|
|
|
text = ""
|
|
for i in range(24):
|
|
address = self.base + i * 4
|
|
value = struct.unpack_from(">I", blob, i * 4)[0]
|
|
instr = disassemble.disassemble(value, address)
|
|
text += "%08X: %08X %s\n" %(address, value, instr)
|
|
self.setPlainText(text)
|
|
|
|
def updateHighlight(self):
|
|
selections = []
|
|
for i in range(24):
|
|
address = self.base + i * 4
|
|
|
|
color = self.getColor(address)
|
|
if color:
|
|
cursor = self.textCursor()
|
|
cursor.movePosition(QTextCursor.Down, n=i)
|
|
cursor.select(QTextCursor.LineUnderCursor)
|
|
format = QTextCharFormat()
|
|
format.setBackground(QBrush(QColor(color)))
|
|
selection = QTextEdit.ExtraSelection()
|
|
selection.cursor = cursor
|
|
selection.format = format
|
|
selections.append(selection)
|
|
self.setExtraSelections(selections)
|
|
|
|
def getColor(self, addr):
|
|
colors = []
|
|
if addr in debugger.breakpoints:
|
|
colors.append((255, 0, 0))
|
|
if addr == self.currentInstruction:
|
|
colors.append((0, 255, 0))
|
|
if addr == self.selectedAddress:
|
|
colors.append((128, 128, 255))
|
|
|
|
if not colors:
|
|
return None
|
|
|
|
color = [sum(l)//len(colors) for l in zip(*colors)]
|
|
return "#%02X%02X%02X" %tuple(color)
|
|
|
|
def mousePressEvent(self, e):
|
|
super().mousePressEvent(e)
|
|
line = self.cursorForPosition(e.pos()).blockNumber()
|
|
self.selectedAddress = self.base + line * 4
|
|
if e.button() == Qt.MidButton:
|
|
debugger.toggleBreakPoint(self.selectedAddress)
|
|
self.updateHighlight()
|
|
|
|
|
|
class DisassemblyInfo(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.baseLabel = QLabel("Address:")
|
|
self.baseBox = HexSpinBox(4)
|
|
self.baseButton = QPushButton("Update", self)
|
|
self.baseButton.clicked.connect(self.updateDisassemblyBase)
|
|
|
|
self.pokeBox = HexSpinBox()
|
|
self.pokeButton = QPushButton("Poke", self)
|
|
self.pokeButton.clicked.connect(self.poke)
|
|
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.baseLabel, 0, 0)
|
|
self.layout.addWidget(self.baseBox, 0, 1)
|
|
self.layout.addWidget(self.baseButton, 0, 2)
|
|
self.layout.addWidget(self.pokeBox, 1, 0)
|
|
self.layout.addWidget(self.pokeButton, 1, 1, 1, 2)
|
|
self.setLayout(self.layout)
|
|
self.setMinimumWidth(300)
|
|
|
|
def updateDisassemblyBase(self):
|
|
window.mainWidget.tabWidget.disassemblyTab.disassemblyWidget.setBase(self.baseBox.value())
|
|
|
|
def poke(self):
|
|
disassembly = window.mainWidget.tabWidget.disassemblyTab.disassemblyWidget
|
|
if disassembly.selectedAddress:
|
|
debugger.writeInstr(disassembly.selectedAddress, self.pokeBox.value())
|
|
disassembly.updateText()
|
|
|
|
|
|
class DisassemblyTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.disassemblyInfo = DisassemblyInfo()
|
|
self.disassemblyWidget = DisassemblyWidget()
|
|
self.layout = QHBoxLayout()
|
|
self.layout.addWidget(self.disassemblyInfo)
|
|
self.layout.addWidget(self.disassemblyWidget)
|
|
self.setLayout(self.layout)
|
|
|
|
events.Connected.connect(self.connected)
|
|
|
|
def connected(self):
|
|
self.disassemblyWidget.setBase(0x10000000)
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Thread widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class ThreadList(QTableWidget):
|
|
def __init__(self):
|
|
super().__init__(0, 5)
|
|
self.setHorizontalHeaderLabels(["Name", "Priority", "Core", "Stack", "Entry Point"])
|
|
self.setEditTriggers(self.NoEditTriggers)
|
|
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
|
|
|
|
events.Connected.connect(self.updateThreads)
|
|
|
|
def updateThreads(self):
|
|
threads = debugger.getThreadList()
|
|
self.setRowCount(len(threads))
|
|
for i in range(len(threads)):
|
|
thread = threads[i]
|
|
self.setItem(i, 0, QTableWidgetItem(thread.name))
|
|
self.setItem(i, 1, QTableWidgetItem(str(thread.priority)))
|
|
self.setItem(i, 2, QTableWidgetItem(thread.core))
|
|
self.setItem(i, 3, QTableWidgetItem("0x%X - 0x%X" %(thread.stackEnd, thread.stackBase)))
|
|
self.setItem(i, 4, QTableWidgetItem("0x%X" %thread.entryPoint))
|
|
|
|
|
|
class ThreadingTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.threadList = ThreadList()
|
|
self.updateButton = QPushButton("Update", self)
|
|
self.updateButton.clicked.connect(self.threadList.updateThreads)
|
|
self.layout = QVBoxLayout()
|
|
self.layout.addWidget(self.threadList)
|
|
self.layout.addWidget(self.updateButton)
|
|
self.setLayout(self.layout)
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Module widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class ModuleList(QTableWidget):
|
|
def __init__(self):
|
|
super().__init__(0, 4)
|
|
self.setHorizontalHeaderLabels(["Name", "Code", "Data", "Entry Point"])
|
|
self.setEditTriggers(self.NoEditTriggers)
|
|
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
|
|
|
|
events.Connected.connect(self.updateModules)
|
|
|
|
def updateModules(self):
|
|
modules = debugger.getModuleList()
|
|
self.setRowCount(len(modules))
|
|
for i in range(len(modules)):
|
|
module = modules[i]
|
|
textEnd = module.textAddr + module.textSize
|
|
dataEnd = module.dataAddr + module.dataSize
|
|
self.setItem(i, 0, QTableWidgetItem(module.name))
|
|
self.setItem(i, 1, QTableWidgetItem("%X - %X" %(module.textAddr, textEnd)))
|
|
self.setItem(i, 2, QTableWidgetItem("%X - %X" %(module.dataAddr, dataEnd)))
|
|
self.setItem(i, 3, QTableWidgetItem("%X" %module.entryPoint))
|
|
|
|
|
|
class ModuleTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.moduleList = ModuleList()
|
|
self.updateButton = QPushButton("Update", self)
|
|
self.updateButton.clicked.connect(self.moduleList.updateModules)
|
|
self.layout = QVBoxLayout()
|
|
self.layout.addWidget(self.moduleList)
|
|
self.layout.addWidget(self.updateButton)
|
|
self.setLayout(self.layout)
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Breakpoint widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class BreakPointList(QListWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.itemDoubleClicked.connect(self.goToDisassembly)
|
|
events.BreakPointChanged.connect(self.updateList)
|
|
|
|
def updateList(self):
|
|
self.clear()
|
|
for bp in debugger.breakpoints:
|
|
self.addItem("0x%08X" %bp)
|
|
|
|
def goToDisassembly(self, item):
|
|
address = debugger.breakpoints[self.row(item)]
|
|
window.mainWidget.tabWidget.disassemblyTab.disassemblyWidget.setBase(address)
|
|
window.mainWidget.tabWidget.setCurrentIndex(1)
|
|
|
|
|
|
class BreakPointTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.list = BreakPointList()
|
|
self.button = QPushButton("Remove")
|
|
self.button.clicked.connect(self.removeBreakPoint)
|
|
self.layout = QVBoxLayout()
|
|
self.layout.addWidget(self.list)
|
|
self.layout.addWidget(self.button)
|
|
self.setLayout(self.layout)
|
|
|
|
def removeBreakPoint(self):
|
|
if self.list.currentRow() != -1:
|
|
debugger.toggleBreakPoint(debugger.breakpoints[self.list.currentRow()])
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Exception widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class ExceptionThreadList(QTableWidget):
|
|
|
|
itemSelected = pyqtSignal(object)
|
|
|
|
def __init__(self, title):
|
|
super().__init__(0, 1)
|
|
|
|
self.setHorizontalHeaderLabels([title])
|
|
|
|
self.setEditTriggers(self.NoEditTriggers)
|
|
self.setSelectionMode(QAbstractItemView.NoSelection)
|
|
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
|
|
self.verticalHeader().hide()
|
|
|
|
self.currentItem = None
|
|
self.itemDoubleClicked.connect(self.selectItem)
|
|
|
|
self.threads = []
|
|
|
|
events.Closed.connect(self.handleClose)
|
|
|
|
def getItem(self, state):
|
|
if state.thread in self.threads:
|
|
return self.item(self.threads.index(state.thread), 0)
|
|
|
|
def addItem(self, state):
|
|
if state.thread not in self.threads:
|
|
thread = debugger.findThread(state.thread)
|
|
if thread and thread.name:
|
|
name = thread.name
|
|
else:
|
|
name = "<%08X>"
|
|
item = QTableWidgetItem(name)
|
|
item.state = state
|
|
self.setRowCount(self.rowCount() + 1)
|
|
self.setItem(self.rowCount() - 1, 0, item)
|
|
self.threads.append(state.thread)
|
|
return item
|
|
else:
|
|
item = self.getItem(state)
|
|
item.state = state
|
|
return item
|
|
|
|
def removeItem(self, state):
|
|
if state.thread in self.threads:
|
|
index = self.threads.index(state.thread)
|
|
item = self.item(index, 0)
|
|
if item == self.currentItem:
|
|
self.currentItem = None
|
|
self.itemSelected.emit(None)
|
|
self.removeRow(self.threads.index(state.thread))
|
|
self.threads.remove(state.thread)
|
|
|
|
def selectItem(self, item):
|
|
if item != self.currentItem:
|
|
self.resetSelection()
|
|
item.setBackground(QBrush(QColor(128, 128, 255)))
|
|
self.currentItem = item
|
|
self.itemSelected.emit(item)
|
|
|
|
def resetSelection(self):
|
|
if self.currentItem:
|
|
self.currentItem.setBackground(QBrush())
|
|
self.currentItem = None
|
|
|
|
def handleClose(self):
|
|
self.threads = []
|
|
self.currentItem = None
|
|
self.clearContents()
|
|
self.setRowCount(0)
|
|
|
|
|
|
class ExceptionThreads(QWidget):
|
|
|
|
itemSelected = pyqtSignal(object)
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
self.pausedThreads = ExceptionThreadList("Paused threads")
|
|
self.pausedThreads.itemSelected.connect(self.handlePauseSelect)
|
|
self.crashedThreads = ExceptionThreadList("Crashed threads")
|
|
self.crashedThreads.itemSelected.connect(self.handleCrashSelect)
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.addWidget(self.pausedThreads)
|
|
layout.addWidget(self.crashedThreads)
|
|
|
|
events.Exception.connect(self.handleException)
|
|
events.Continue.connect(self.handleContinue)
|
|
|
|
def handlePauseSelect(self, item):
|
|
if item:
|
|
self.crashedThreads.resetSelection()
|
|
self.itemSelected.emit(item)
|
|
|
|
def handleCrashSelect(self, item):
|
|
if item:
|
|
self.pausedThreads.resetSelection()
|
|
self.itemSelected.emit(item)
|
|
|
|
def handleException(self, state):
|
|
if state.isFatal():
|
|
self.pausedThreads.removeItem(state)
|
|
item = self.crashedThreads.addItem(state)
|
|
self.crashedThreads.selectItem(item)
|
|
else:
|
|
self.crashedThreads.removeItem(state)
|
|
item = self.pausedThreads.addItem(state)
|
|
self.pausedThreads.selectItem(item)
|
|
|
|
def handleContinue(self, state):
|
|
self.pausedThreads.removeItem(state)
|
|
self.crashedThreads.removeItem(state)
|
|
|
|
|
|
class ExceptionInfo(QGroupBox):
|
|
def __init__(self):
|
|
super().__init__("Info")
|
|
self.typeLabel = QLabel()
|
|
|
|
self.layout = QVBoxLayout(self)
|
|
self.layout.addWidget(self.typeLabel)
|
|
|
|
def setState(self, state):
|
|
self.typeLabel.setText("Type: %s" %state.exceptionName)
|
|
|
|
|
|
class SpecialRegisters(QGroupBox):
|
|
def __init__(self):
|
|
super().__init__("Special registers")
|
|
self.cr = QLabel()
|
|
self.lr = QLabel()
|
|
self.ctr = QLabel()
|
|
self.xer = QLabel()
|
|
self.srr0 = QLabel()
|
|
self.srr1 = QLabel()
|
|
self.ex0 = QLabel()
|
|
self.ex1 = QLabel()
|
|
|
|
self.userLayout = QFormLayout()
|
|
self.kernelLayout = QFormLayout()
|
|
|
|
self.userLayout.addRow("CR:", self.cr)
|
|
self.userLayout.addRow("LR:", self.lr)
|
|
self.userLayout.addRow("CTR:", self.ctr)
|
|
self.userLayout.addRow("XER:", self.xer)
|
|
|
|
self.kernelLayout = QFormLayout()
|
|
self.kernelLayout.addRow("SRR0:", self.srr0)
|
|
self.kernelLayout.addRow("SRR1:", self.srr1)
|
|
self.kernelLayout.addRow("EX0:", self.ex0)
|
|
self.kernelLayout.addRow("EX1:", self.ex1)
|
|
|
|
self.layout = QHBoxLayout(self)
|
|
self.layout.addLayout(self.userLayout)
|
|
self.layout.addLayout(self.kernelLayout)
|
|
|
|
def setState(self, state):
|
|
self.cr.setText("%08X" %state.cr)
|
|
self.lr.setText("%08X" %state.lr)
|
|
self.ctr.setText("%08X" %state.ctr)
|
|
self.xer.setText("%08X" %state.xer)
|
|
self.srr0.setText("%08X" %state.srr0)
|
|
self.srr1.setText("%08X" %state.srr1)
|
|
self.ex0.setText("%08X" %state.ex0)
|
|
self.ex1.setText("%08X" %state.ex1)
|
|
|
|
|
|
class ExceptionInfoTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.exceptionInfo = ExceptionInfo()
|
|
self.specialRegisters = SpecialRegisters()
|
|
|
|
self.layout = QHBoxLayout(self)
|
|
self.layout.addWidget(self.exceptionInfo)
|
|
self.layout.addWidget(self.specialRegisters)
|
|
|
|
def setState(self, state):
|
|
self.exceptionInfo.setState(state)
|
|
self.specialRegisters.setState(state)
|
|
|
|
|
|
class RegisterTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.gprLabels = []
|
|
self.gprBoxes = []
|
|
self.fprLabels = []
|
|
self.fprBoxes = []
|
|
for i in range(32):
|
|
self.gprLabels.append(QLabel("r%i" %i))
|
|
self.fprLabels.append(QLabel("f%i" % i))
|
|
gprBox = HexSpinBox()
|
|
fprBox = QDoubleSpinBox()
|
|
fprBox.setRange(float("-inf"), float("inf"))
|
|
self.gprBoxes.append(gprBox)
|
|
self.fprBoxes.append(fprBox)
|
|
|
|
self.layout = QGridLayout(self)
|
|
for i in range(32):
|
|
self.layout.addWidget(self.gprLabels[i], i % 16, i // 16 * 2)
|
|
self.layout.addWidget(self.gprBoxes[i], i % 16, i // 16 * 2 + 1)
|
|
self.layout.addWidget(self.fprLabels[i], i % 16, i // 16 * 2 + 4)
|
|
self.layout.addWidget(self.fprBoxes[i], i % 16, i // 16 * 2 + 5)
|
|
|
|
self.pokeButton = QPushButton("Poke")
|
|
self.resetButton = QPushButton("Reset")
|
|
self.pokeButton.clicked.connect(self.pokeRegisters)
|
|
self.resetButton.clicked.connect(self.updateRegisters)
|
|
self.layout.addWidget(self.pokeButton, 16, 0, 1, 4)
|
|
self.layout.addWidget(self.resetButton, 16, 4, 1, 4)
|
|
|
|
self.setEditEnabled(False)
|
|
|
|
events.Step.connect(self.handleStep)
|
|
|
|
def setState(self, state):
|
|
self.state = state
|
|
self.updateRegisters()
|
|
self.setEditEnabled(state.isBreakPoint() and not state.stepping)
|
|
|
|
def handleStep(self, state):
|
|
if state == self.state:
|
|
self.setEditEnabled(False)
|
|
|
|
def setEditEnabled(self, enabled):
|
|
for i in range(32):
|
|
self.gprBoxes[i].setEnabled(enabled)
|
|
self.fprBoxes[i].setEnabled(enabled)
|
|
self.pokeButton.setEnabled(enabled)
|
|
self.resetButton.setEnabled(enabled)
|
|
|
|
def updateRegisters(self):
|
|
for i in range(32):
|
|
self.gprBoxes[i].setValue(self.state.gpr[i])
|
|
self.fprBoxes[i].setValue(self.state.fpr[i])
|
|
|
|
def pokeRegisters(self):
|
|
for i in range(32):
|
|
self.state.gpr[i] = self.gprBoxes[i].value()
|
|
self.state.fpr[i] = self.fprBoxes[i].value()
|
|
debugger.pokeRegisters(self.state)
|
|
|
|
|
|
class StackTrace(QListWidget):
|
|
def setState(self, state):
|
|
self.clear()
|
|
stackTrace = debugger.getStackTrace(state)
|
|
for address in (state.srr0, state.lr) + stackTrace:
|
|
self.addItem("%X" %address)
|
|
|
|
class StackTraceTab(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.stackTrace = StackTrace()
|
|
self.disassembly = DisassemblyWidget()
|
|
|
|
layout = QHBoxLayout(self)
|
|
layout.addWidget(self.stackTrace)
|
|
layout.addWidget(self.disassembly)
|
|
|
|
self.stackTrace.itemDoubleClicked.connect(self.jumpDisassembly)
|
|
|
|
events.Step.connect(self.handleStep)
|
|
|
|
def handleStep(self, state):
|
|
self.disassembly.setCurrentInstruction(None)
|
|
|
|
def setState(self, state):
|
|
self.stackTrace.setState(state)
|
|
if not state.stepping:
|
|
self.disassembly.setCurrentInstruction(state.srr0)
|
|
else:
|
|
self.disassembly.setCurrentInstruction(None)
|
|
|
|
def jumpDisassembly(self, item):
|
|
self.disassembly.setCurrentInstruction(int(item.text(), 16))
|
|
|
|
|
|
class ExceptionStateTabs(QTabWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.infoTab = ExceptionInfoTab()
|
|
self.registerTab = RegisterTab()
|
|
self.stackTab = StackTraceTab()
|
|
self.addTab(self.infoTab, "General")
|
|
self.addTab(self.registerTab, "Registers")
|
|
self.addTab(self.stackTab, "Stack trace")
|
|
|
|
def setState(self, state):
|
|
self.infoTab.setState(state)
|
|
self.registerTab.setState(state)
|
|
self.stackTab.setState(state)
|
|
|
|
|
|
class BreakpointActions(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
self.continueButton = QPushButton("Continue")
|
|
self.continueButton.clicked.connect(self.continueThread)
|
|
self.stepButton = QPushButton("Step")
|
|
self.stepButton.clicked.connect(self.stepInto)
|
|
self.stepOverButton = QPushButton("Step over")
|
|
self.stepOverButton.clicked.connect(self.stepOver)
|
|
|
|
layout = QHBoxLayout(self)
|
|
layout.addWidget(self.continueButton)
|
|
layout.addWidget(self.stepButton)
|
|
layout.addWidget(self.stepOverButton)
|
|
|
|
self.state = None
|
|
|
|
def setState(self, state):
|
|
self.state = state
|
|
if state.isFatal():
|
|
self.continueButton.hide()
|
|
self.stepButton.hide()
|
|
self.stepOverButton.hide()
|
|
else:
|
|
self.continueButton.show()
|
|
self.stepButton.show()
|
|
self.stepOverButton.show()
|
|
|
|
def continueThread(self): debugger.continueThread(self.state)
|
|
def stepInto(self): debugger.stepInto(self.state)
|
|
def stepOver(self): debugger.stepOver(self.state)
|
|
|
|
|
|
class ExceptionStateWidget(QTabWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
self.exceptionTabs = ExceptionStateTabs()
|
|
self.breakpointActions = BreakpointActions()
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.addWidget(self.exceptionTabs)
|
|
layout.addWidget(self.breakpointActions)
|
|
|
|
events.Step.connect(self.handleStep)
|
|
|
|
def setState(self, state):
|
|
self.exceptionTabs.setState(state)
|
|
self.breakpointActions.setState(state)
|
|
self.breakpointActions.setEnabled(not state.stepping)
|
|
|
|
def handleStep(self, state):
|
|
self.breakpointActions.setEnabled(False)
|
|
|
|
|
|
class ExceptionTab(QSplitter):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.threadList = ExceptionThreads()
|
|
self.threadList.itemSelected.connect(self.handleItemSelected)
|
|
self.stateWidget = ExceptionStateWidget()
|
|
self.stateWidget.setEnabled(False)
|
|
self.addWidget(self.threadList)
|
|
self.addWidget(self.stateWidget)
|
|
|
|
self.setSizes([100, 400])
|
|
|
|
events.Closed.connect(self.handleClose)
|
|
|
|
def handleItemSelected(self, item):
|
|
if item:
|
|
self.stateWidget.setState(item.state)
|
|
self.stateWidget.setEnabled(True)
|
|
else:
|
|
self.stateWidget.setEnabled(False)
|
|
|
|
def handleClose(self):
|
|
self.stateWidget.setEnabled(False)
|
|
|
|
|
|
"""""""""""""""""""""""""""
|
|
Main widgets
|
|
"""""""""""""""""""""""""""
|
|
|
|
class DebuggerTabs(QTabWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.memoryTab = MemoryTab()
|
|
self.disassemblyTab = DisassemblyTab()
|
|
self.threadingTab = ThreadingTab()
|
|
self.moduleTab = ModuleTab()
|
|
self.breakPointTab = BreakPointTab()
|
|
self.exceptionTab = ExceptionTab()
|
|
self.addTab(self.memoryTab, "Memory")
|
|
self.addTab(self.disassemblyTab, "Disassembly")
|
|
self.addTab(self.threadingTab, "Threads")
|
|
self.addTab(self.moduleTab, "Modules")
|
|
self.addTab(self.breakPointTab, "Breakpoints")
|
|
self.addTab(self.exceptionTab, "Exceptions")
|
|
|
|
events.Exception.connect(self.exceptionOccurred)
|
|
events.Connected.connect(self.connected)
|
|
events.Closed.connect(self.disconnected)
|
|
|
|
def exceptionOccurred(self, state):
|
|
self.setCurrentIndex(5) #Exceptions
|
|
|
|
def connected(self):
|
|
self.setEnabled(True)
|
|
|
|
def disconnected(self):
|
|
self.setEnabled(False)
|
|
|
|
|
|
class StatusWidget(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.serverLabel = QLabel("Wii U IP:")
|
|
self.serverBox = QLineEdit(self)
|
|
self.serverBox.returnPressed.connect(self.connect)
|
|
self.connectButton = QPushButton("Connect", self)
|
|
self.connectButton.clicked.connect(self.connect)
|
|
self.disconnectButton = QPushButton("Disconnect", self)
|
|
self.disconnectButton.clicked.connect(debugger.close)
|
|
self.disconnectButton.setEnabled(False)
|
|
|
|
self.statusInfo = QLabel("Disconnected", self)
|
|
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.serverLabel, 0, 0)
|
|
self.layout.addWidget(self.serverBox, 1, 0)
|
|
self.layout.addWidget(self.connectButton, 0, 1)
|
|
self.layout.addWidget(self.disconnectButton, 1, 1)
|
|
self.layout.addWidget(self.statusInfo, 3, 0, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
events.Connected.connect(self.connected)
|
|
events.Closed.connect(self.disconnected)
|
|
|
|
def connect(self):
|
|
try:
|
|
address = self.serverBox.text()
|
|
debugger.connect(address)
|
|
except:
|
|
pass
|
|
|
|
def connected(self):
|
|
self.statusInfo.setText("Connected")
|
|
self.connectButton.setEnabled(False)
|
|
self.serverBox.setEnabled(False)
|
|
self.disconnectButton.setEnabled(True)
|
|
|
|
def disconnected(self):
|
|
self.statusInfo.setText("Disconnected")
|
|
self.connectButton.setEnabled(True)
|
|
self.serverBox.setEnabled(True)
|
|
self.disconnectButton.setEnabled(False)
|
|
|
|
|
|
class MainWidget(QWidget):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.tabWidget = DebuggerTabs()
|
|
self.statusWidget = StatusWidget()
|
|
self.layout = QVBoxLayout()
|
|
self.layout.addWidget(self.tabWidget)
|
|
self.layout.addWidget(self.statusWidget)
|
|
self.tabWidget.setEnabled(False)
|
|
self.setLayout(self.layout)
|
|
|
|
|
|
class MainWindow(QMainWindow):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.setWindowTitle("DiiBugger")
|
|
self.resize(1080, 720)
|
|
|
|
self.mainWidget = MainWidget()
|
|
self.setCentralWidget(self.mainWidget)
|
|
|
|
self.timer = QTimer(self)
|
|
self.timer.setInterval(100)
|
|
self.timer.timeout.connect(self.updateMessages)
|
|
self.timer.start()
|
|
|
|
events.Connected.connect(self.updateTitle)
|
|
events.Closed.connect(self.updateTitle)
|
|
|
|
def updateTitle(self):
|
|
if debugger.connected:
|
|
name = debugger.getModuleName()
|
|
self.setWindowTitle("DiiBugger - %s" %name)
|
|
else:
|
|
self.setWindowTitle("DiiBugger")
|
|
|
|
def updateMessages(self):
|
|
if debugger.connected:
|
|
debugger.updateMessages()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
app = QApplication(sys.argv)
|
|
app.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont))
|
|
window = MainWindow()
|
|
window.show()
|
|
app.exec()
|