watchpoint_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EMU_DEBUG_WATCHPOINT_MANAGER_H
#define YAZE_APP_EMU_DEBUG_WATCHPOINT_MANAGER_H
 
#include <cstdint>
#include <deque>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace yaze {
namespace emu {
 
class WatchpointManager {
 public:
  struct AccessLog {
    uint32_t pc;              // Where the access happened (program counter)
    uint32_t address;         // What address was accessed
    uint8_t old_value;        // Value before write (0 for reads)
    uint8_t new_value;        // Value after write / value read
    bool is_write;            // True for write, false for read
    uint64_t cycle_count;     // When it happened (CPU cycle)
    std::string description;  // Optional description
  };
 
  struct Watchpoint {
    uint32_t id;
    uint32_t start_address;
    uint32_t end_address;  // For range watchpoints
    bool track_reads;
    bool track_writes;
    bool break_on_access;  // If true, pause emulation on access
    bool enabled;
    std::string description;
 
    // Access history for this watchpoint
    std::deque<AccessLog> history;
    static constexpr size_t kMaxHistorySize = 1000;
  };
 
  WatchpointManager() = default;
  ~WatchpointManager() = default;
 
  uint32_t AddWatchpoint(uint32_t start_address, uint32_t end_address,
                         bool track_reads, bool track_writes,
                         bool break_on_access = false,
                         const std::string& description = "");
 
  void RemoveWatchpoint(uint32_t id);
 
  void SetEnabled(uint32_t id, bool enabled);
 
  bool OnMemoryAccess(uint32_t pc, uint32_t address, bool is_write,
                      uint8_t old_value, uint8_t new_value,
                      uint64_t cycle_count);
 
  std::vector<Watchpoint> GetAllWatchpoints() const;
 
  std::vector<AccessLog> GetHistory(uint32_t address,
                                    int max_entries = 100) const;
 
  void ClearAll();
 
  void ClearHistory();
 
  bool ExportHistoryToCSV(const std::string& filepath) const;
 
 private:
  std::unordered_map<uint32_t, Watchpoint> watchpoints_;
  uint32_t next_id_ = 1;
 
  // Check if address is within watchpoint range
  bool IsInRange(const Watchpoint& wp, uint32_t address) const {
    return address >= wp.start_address && address <= wp.end_address;
  }
};
 
}  // namespace emu
}  // namespace yaze
 
#endif  // YAZE_APP_EMU_DEBUG_WATCHPOINT_MANAGER_H