breakpoint_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EMU_DEBUG_BREAKPOINT_MANAGER_H
#define YAZE_APP_EMU_DEBUG_BREAKPOINT_MANAGER_H
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace yaze {
namespace emu {
 
class BreakpointManager {
 public:
  enum class Type {
    EXECUTE,     // Break when PC reaches this address
    READ,        // Break when this address is read
    WRITE,       // Break when this address is written
    ACCESS,      // Break when this address is read OR written
    CONDITIONAL  // Break when condition evaluates to true
  };
  
  enum class CpuType {
    CPU_65816,   // Main CPU
    SPC700       // Audio CPU
  };
  
  struct Breakpoint {
    uint32_t id;
    uint32_t address;
    Type type;
    CpuType cpu;
    bool enabled;
    std::string condition;  // For conditional breakpoints (e.g., "A > 0x10")
    uint32_t hit_count;
    std::string description;  // User-friendly label
    
    // Optional callback for advanced logic
    std::function<bool(uint32_t pc, uint32_t address, uint8_t value)> callback;
  };
  
  BreakpointManager() = default;
  ~BreakpointManager() = default;
  
  uint32_t AddBreakpoint(uint32_t address, Type type, CpuType cpu,
                         const std::string& condition = "",
                         const std::string& description = "");
  
  void RemoveBreakpoint(uint32_t id);
  
  void SetEnabled(uint32_t id, bool enabled);
  
  bool ShouldBreakOnExecute(uint32_t pc, CpuType cpu);
  
  bool ShouldBreakOnMemoryAccess(uint32_t address, bool is_write, 
                                  uint8_t value, uint32_t pc);
  
  std::vector<Breakpoint> GetAllBreakpoints() const;
  
  std::vector<Breakpoint> GetBreakpoints(CpuType cpu) const;
  
  void ClearAll();
  
  void ClearAll(CpuType cpu);
  
  const Breakpoint* GetLastHit() const { return last_hit_; }
  
  void ResetHitCounts();
  
 private:
  std::unordered_map<uint32_t, Breakpoint> breakpoints_;
  uint32_t next_id_ = 1;
  const Breakpoint* last_hit_ = nullptr;
  
  bool EvaluateCondition(const std::string& condition, uint32_t pc, 
                         uint32_t address, uint8_t value);
};
 
}  // namespace emu
}  // namespace yaze
 
#endif  // YAZE_APP_EMU_DEBUG_BREAKPOINT_MANAGER_H