CPUDebug.hpp

Go to the documentation of this file.

//
// Created by anonymus-raccoon on 2/14/20.
//
 
#pragma once
 
#include "Debugger/ClosableWindow.hpp"
#include "Exceptions/DebuggableError.hpp"
#include "ui/ui_cpuView.h"
#include "Models/Ints.hpp"
#include "Memory/MemoryBus.hpp"
#include "CPU/Instruction.hpp"
#include <QtWidgets/QStyledItemDelegate>
#include <filesystem>
#include <optional>
#include <QTimer>
 
namespace ComSquare
{
    class SNES;
 
    namespace CPU
    {
        class CPU;
    }
 
    namespace Debugger::CPU
    {
        class CPUDebug;
 
        struct ExecutedInstruction
        {
            uint8_t opcode;
            std::string name;
            std::string params;
            std::string proceededParams;
        };
 
        class StackModel : public QAbstractTableModel
        {
        Q_OBJECT
        private:
            Memory::IMemoryBus &_bus;
            CPUDebug &_cpu;
 
        public:
            explicit StackModel(Memory::IMemoryBus &bus, CPUDebug &cpu);
            StackModel(const StackModel &) = delete;
            const StackModel &operator=(const StackModel &) = delete;
            ~StackModel() override = default;
 
            [[nodiscard]] int rowCount(const QModelIndex &parent) const override;
            [[nodiscard]] int columnCount(const QModelIndex &parent) const override;
            [[nodiscard]] QVariant data(const QModelIndex &index, int role) const override;
            [[nodiscard]] QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
        };
 
        class HistoryModel : public QAbstractTableModel
        {
        Q_OBJECT
        private:
            std::vector<ExecutedInstruction> _instructions = {};
 
        public:
            HistoryModel();
            HistoryModel(const HistoryModel &) = delete;
            const HistoryModel &operator=(const HistoryModel &) = delete;
            ~HistoryModel() override = default;
 
            void log(const ExecutedInstruction &);
            void clear();
 
            [[nodiscard]] int rowCount(const QModelIndex &parent) const override;
            [[nodiscard]] int columnCount(const QModelIndex &parent) const override;
            [[nodiscard]] QVariant data(const QModelIndex &index, int role) const override;
            [[nodiscard]] QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
        };
 
        class DisassemblyModel : public QAbstractTableModel
        {
        Q_OBJECT
        private:
            CPUDebug &_cpu;
 
        public:
            explicit DisassemblyModel(CPUDebug &cpu);
            DisassemblyModel(const DisassemblyModel &) = delete;
            const DisassemblyModel &operator=(const DisassemblyModel &) = delete;
            ~DisassemblyModel() override = default;
 
            [[nodiscard]] int rowCount(const QModelIndex &parent) const override;
            [[nodiscard]] int columnCount(const QModelIndex &parent) const override;
            [[nodiscard]] QVariant data(const QModelIndex &index, int role) const override;
            [[nodiscard]] QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
        };
 
        class RowPainter : public QStyledItemDelegate
        {
        Q_OBJECT
        private:
            CPUDebug &_cpu;
 
        public:
            explicit RowPainter(CPUDebug &cpu, QObject *parent = nullptr);
            RowPainter &operator=(const RowPainter &) = delete;
            ~RowPainter() override = default;
 
        protected:
            [[nodiscard]] QSize sizeHint(const QStyleOptionViewItem &options, const QModelIndex &index) const override;
            void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
        };
 
        enum TrustLevel
        {
            Safe,
            Unsafe,
            Compromised
        };
 
        struct DisassemblyContext
        {
            bool mFlag = true;
            bool xFlag = true;
            bool isEmulationMode = true;
            TrustLevel level = Safe;
        };
 
        struct DisassembledInstruction : public ComSquare::CPU::Instruction
        {
            uint24_t address;
            std::string argument;
            uint8_t opcode;
            TrustLevel level;
 
            DisassembledInstruction(const ComSquare::CPU::Instruction &instruction,
                                    uint24_t address,
                                    std::string argument,
                                    uint8_t opcode);
            DisassembledInstruction(const DisassembledInstruction &) = default;
            DisassembledInstruction &operator=(const DisassembledInstruction &) = default;
            ~DisassembledInstruction() = default;
        };
 
        struct Breakpoint
        {
            uint24_t address;
            bool oneTime;
        };
 
        struct Label
        {
            uint24_t address;
            std::string name;
            std::optional<unsigned> size;
        };
 
        class CPUDebug : public QObject
        {
        Q_OBJECT
        private:
            ComSquare::CPU::CPU &_cpu;
            ClosableWindow *_window;
            QTimer _timer;
            Ui::CPUView _ui;
            DisassemblyModel _model;
            RowPainter _painter;
            StackModel _stackModel;
            HistoryModel _historyModel;
            bool _isPaused = true;
            bool _isStepping = false;
            SNES &_snes;
            std::vector<Label> _labels;
            int _callback;
 
            void _loadLabels(std::filesystem::path romPath);
            void _logInstruction();
            DisassemblyContext _getDisassemblyContext();
            std::vector<DisassembledInstruction> _disassemble(uint24_t startAddr, uint24_t size,
                                                              DisassemblyContext &ctx);
            void _updateDisassembly(uint24_t start, uint24_t refreshSize = 0xFF);
            DisassembledInstruction _parseInstruction(uint24_t pc, DisassemblyContext &ctx) const;
            std::string _getInstructionParameter(const ComSquare::CPU::Instruction &instruction,
                                                 uint24_t pc,
                                                 DisassemblyContext &ctx) const;
            void _updateRegistersPanel();
 
            [[nodiscard]] std::string _getImmediateValue(uint24_t pc, bool dual) const;
            [[nodiscard]] std::string _getAbsoluteValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteLongValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndirectValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndirectLongValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteIndexByXValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteIndexByXLongValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteIndexByYValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndexedByXValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndexedByYValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndexedByXIndirectValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndirectIndexedByYValue(uint24_t pc) const;
            [[nodiscard]] std::string _getDirectIndirectIndexedByYLongValue(uint24_t pc) const;
            [[nodiscard]] std::string _getStackRelativeValue(uint24_t pc) const;
            [[nodiscard]] std::string _getStackRelativeIndirectIndexedByYValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteIndirectValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteIndirectIndexedByXValue(uint24_t pc) const;
            [[nodiscard]] std::string _getAbsoluteIndirectLongValue(uint24_t pc) const;
 
        public slots:
            unsigned update();
        public:
            static void showError(const DebuggableError &error);
            void pause(bool forcePause = false);
            void step();
            void next();
            void clearHistory();
            void toggleBreakpoint(int logicalIndex);
            std::vector<DisassembledInstruction> disassembled;
            std::vector<Breakpoint> breakpoints;
            [[nodiscard]] std::string getProceededParameters() const;
            [[nodiscard]] uint24_t getPC() const;
            [[nodiscard]] uint16_t getStackPointer() const;
            uint16_t initialStackPointer;
 
            CPUDebug(ComSquare::CPU::CPU &cpu, SNES &snes);
            CPUDebug(const CPUDebug &) = delete;
            CPUDebug &operator=(const CPUDebug &) = delete;
            ~CPUDebug() override;
 
            void focus();
        };
    }// namespace Debugger
}// namespace ComSquare