symbol_provider.h

Go to the documentation of this file.

#ifndef YAZE_APP_EMU_DEBUG_SYMBOL_PROVIDER_H_
#define YAZE_APP_EMU_DEBUG_SYMBOL_PROVIDER_H_
 
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
namespace yaze {
namespace emu {
namespace debug {
 
struct Symbol {
  std::string name;         // Symbol name (e.g., "MainGameLoop", "Reset")
  uint32_t address;         // 24-bit SNES address
  std::string file;         // Source file (if known)
  int line = 0;             // Line number (if known)
  std::string comment;      // Optional comment or description
  bool is_local = false;    // True for local labels (starting with .)
 
  Symbol() = default;
  Symbol(const std::string& n, uint32_t addr)
      : name(n), address(addr) {}
  Symbol(const std::string& n, uint32_t addr, const std::string& f, int l)
      : name(n), address(addr), file(f), line(l) {}
};
 
enum class SymbolFormat {
  kAuto,      // Auto-detect based on file extension/content
  kAsar,      // Asar-style .asm/.sym files (label: at address #_XXXXXX:)
  kWlaDx,     // WLA-DX .sym format (bank:address name)
  kMesen,     // Mesen .mlb format (address:name)
  kBsnes,     // bsnes .sym format (address name)
  kNo$snes,   // No$snes .sym format (bank:addr name)
  kSourceMap, // JSON source map format (address, file, line)
};
 
class SymbolProvider {
 public:
  SymbolProvider() = default;
 
  absl::Status LoadAsarAsmFile(const std::string& path);
 
  absl::Status LoadAsarAsmDirectory(const std::string& directory_path);
 
  absl::Status LoadSymbolFile(const std::string& path,
                               SymbolFormat format = SymbolFormat::kAuto);
 
  void AddSymbol(const Symbol& symbol);
 
  void AddAsarSymbols(const std::vector<Symbol>& symbols);
 
  void Clear();
 
  std::string GetSymbolName(uint32_t address) const;
 
  std::optional<Symbol> GetSymbol(uint32_t address) const;
 
  std::vector<Symbol> GetSymbolsAtAddress(uint32_t address) const;
 
  std::optional<Symbol> FindSymbol(const std::string& name) const;
 
  std::vector<Symbol> FindSymbolsMatching(const std::string& pattern) const;
 
  std::vector<Symbol> GetSymbolsInRange(uint32_t start, uint32_t end) const;
 
  std::optional<Symbol> GetNearestSymbol(uint32_t address) const;
 
  std::string FormatAddress(uint32_t address,
                             uint32_t max_offset = 0x100) const;
 
  std::string GetSourceLocation(uint32_t address) const;
 
  size_t GetSymbolCount() const { return symbols_by_address_.size(); }
 
  bool HasSymbols() const { return !symbols_by_address_.empty(); }
 
  std::function<std::string(uint32_t)> CreateResolver() const;
 
  absl::StatusOr<std::string> ExportSymbols(SymbolFormat format) const;
 
 private:
  // Parse different symbol file formats
  absl::Status ParseAsarAsmContent(const std::string& content,
                                    const std::string& filename);
  absl::Status ParseWlaDxSymFile(const std::string& content);
  absl::Status ParseMesenMlbFile(const std::string& content);
  absl::Status ParseBsnesSymFile(const std::string& content);
  absl::Status ParseSourceMapJson(const std::string& content);
 
  // Detect format from file content
  SymbolFormat DetectFormat(const std::string& content,
                            const std::string& extension) const;
 
  // Primary storage: address -> symbols (may have multiple per address)
  std::multimap<uint32_t, Symbol> symbols_by_address_;
 
  // Secondary index: name -> symbol (for reverse lookup)
  std::map<std::string, Symbol> symbols_by_name_;
};
 
}  // namespace debug
}  // namespace emu
}  // namespace yaze
 
#endif  // YAZE_APP_EMU_DEBUG_SYMBOL_PROVIDER_H_