disassembly_viewer.h

Go to the documentation of this file.

#ifndef YAZE_APP_EMU_DEBUG_DISASSEMBLY_VIEWER_H_
#define YAZE_APP_EMU_DEBUG_DISASSEMBLY_VIEWER_H_
 
#include <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include "app/emu/cpu/cpu.h"
#include "app/gfx/bitmap.h"
#include "app/gui/icons.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace emu {
namespace debug {
 
struct DisassemblyEntry {
  uint32_t address;           // Full 24-bit address (bank:offset)
  uint8_t opcode;             // The opcode byte
  std::vector<uint8_t> operands;  // Operand bytes (0-2 bytes)
  std::string mnemonic;       // Instruction mnemonic (e.g., "LDA", "STA")
  std::string operand_str;    // Formatted operand string (e.g., "#$00", "($10),Y")
  uint8_t size;               // Total instruction size in bytes
  uint64_t execution_count;   // How many times this instruction was executed
  bool is_breakpoint;         // Whether a breakpoint is set at this address
  bool is_current_pc;         // Whether this is the current PC location
  
  DisassemblyEntry() 
      : address(0), opcode(0), size(1), execution_count(0), 
        is_breakpoint(false), is_current_pc(false) {}
};
 
class DisassemblyViewer {
 public:
  DisassemblyViewer() = default;
  ~DisassemblyViewer() = default;
 
  void RecordInstruction(uint32_t address, uint8_t opcode,
                        const std::vector<uint8_t>& operands,
                        const std::string& mnemonic,
                        const std::string& operand_str);
 
  void Render(uint32_t current_pc, const std::vector<uint32_t>& breakpoints);
 
  void Clear();
 
  size_t GetInstructionCount() const { return instructions_.size(); }
 
  bool ExportToFile(const std::string& filepath) const;
 
  void JumpToAddress(uint32_t address);
 
  void SetAutoScroll(bool enabled) { auto_scroll_ = enabled; }
 
  std::vector<uint32_t> GetSortedAddresses() const;
 
  bool IsAvailable() const { return !instructions_.empty(); }
  
  void SetRecording(bool enabled) { recording_enabled_ = enabled; }
  bool IsRecording() const { return recording_enabled_; }
  
  void SetMaxInstructions(size_t max) { max_instructions_ = max; }
  
  void TrimToSize(size_t target_size);
 
 private:
  // Sparse storage: only store executed instructions
  std::map<uint32_t, DisassemblyEntry> instructions_;
  
  // Performance limits
  bool recording_enabled_ = true;
  size_t max_instructions_ = 10000;  // Limit to prevent memory bloat
  
  // UI state
  char search_filter_[256] = "";
  uint32_t selected_address_ = 0;
  uint32_t scroll_to_address_ = 0;
  bool auto_scroll_ = true;
  bool show_execution_counts_ = true;
  bool show_hex_dump_ = true;
  
  // Rendering helpers
  void RenderToolbar();
  void RenderDisassemblyTable(uint32_t current_pc, 
                              const std::vector<uint32_t>& breakpoints);
  void RenderContextMenu(uint32_t address);
  void RenderSearchBar();
  
  // Formatting helpers
  ImVec4 GetAddressColor(const DisassemblyEntry& entry, uint32_t current_pc) const;
  ImVec4 GetMnemonicColor(const DisassemblyEntry& entry) const;
  std::string FormatHexDump(const DisassemblyEntry& entry) const;
  
  // Filter helper
  bool PassesFilter(const DisassemblyEntry& entry) const;
};
 
}  // namespace debug
}  // namespace emu
}  // namespace yaze
 
#endif  // YAZE_APP_EMU_DEBUG_DISASSEMBLY_VIEWER_H_