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 "absl/strings/str_format.h"
#include "app/emu/cpu/cpu.h"
#include "app/gfx/core/bitmap.h"
#include "app/gui/core/icons.h"
#include "rom/rom.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_