Return to disasm.h CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0

nono 0.0.1

//
// nono
// Copyright (C) 2017 [email protected]
//

#pragma once

#include <string>
#include <vector>

class m68kcpu;

// 逆アセンブル
class Disasm
{
 public:
	Disasm();
	virtual ~Disasm();

	// 逆アセンブル文字列を返す (物理アクセス)
	std::string Disassemble(uint32 paddr) {
		return Disassemble(paddr, paddr);
	}
	// ダンプ付きの逆アセンブル文字列を返す (物理アクセス)
	std::string DisassembleWithDump(uint32 paddr) {
		return DisassembleWithDump(paddr, paddr);
	}

	// 逆アセンブル文字列を返す (論理アクセス)
	std::string Disassemble(uint32 laddr, uint32 paddr);
	// ダンプ付きの逆アセンブル文字列を返す (論理アクセス)
	std::string DisassembleWithDump(uint32 laddr, uint32 paddr);

	// 次の開始アドレスを取得する
	uint32 GetNextAddr() const { return pc; }
	// 今処理した命令のバイト数を取得する
	uint32 GetLength() const { return pc - pc0; }

 private:
	uint32 pc = 0;			// 現在の PC (論理アドレス)
	uint32 pc0 = 0;			// 命令先頭  (論理アドレス)
	uint32 phys_pc = 0;		// pc に対応する物理アドレス

	enum Reg {
		CCR,
		SR,
		PC,
		USP,

		MSP,
		ISP,
		VBR,
		SFC,
		DFC,
		CACR,
		CAAR,

		TC,
		MMUSR,
		SRP,
		CRP,
		TT0,
		TT1,

		FPCR,
		FPSR,
		FPIAR,

		URP,
		ITT0,
		ITT1,
		DTT0,
		DTT1,
	};

	// L/S/X/P/W/D/B/(Pk) は FMOVE <ea>,FPn の時の並び順。
	enum Size {
		L = 0,	// Long
		S,		// Single
		X,		// eXtended
		P,		// Packed
		W,		// Word
		D,		// Double
		B,		// Byte
		Pk,		// Packed with dynamic k-factor
		Q,		// Quad
		None,
	};

	virtual uint32 fetch16();
	virtual uint32 peek16();		// PC を進めずワードを取得 (IOCSコール用)
	uint32 fetch32();

	// 1行逆アセンブル前の初期化
	void init();

	std::string make_reg(Reg);

	std::string hex8(uint32);
	std::string hex16(uint32);
	std::string hex32(uint32);
	std::string shex8(uint32);
	std::string shex16(uint32);
	std::string shex32(uint32);
	std::string make_ea();
	std::string make_ea(uint);
	std::string make_eaix(std::string basereg);

	std::string addr16(uint32 addr);	// addr をワードアドレスとして
	std::string addr32(uint32 addr);	// addr をロングワードアドレスとして
	std::string addr16();		// フェッチした値をワードアドレスとして
	std::string addr32();		// フェッチした値をロングワードアドレスとして
	std::string disp16();		// フェッチしたワードディスプレースメント
	std::string disp32();		// フェッチしたロングワードディスプレースメント
	std::string imm8();
	std::string imm16();
	std::string imm32();
	std::string make_dn(uint);
	std::string make_an(uint);
	std::string make_rn(uint);
	std::string make_anin(uint);
	std::string make_anpd(uint);
	std::string make_anpi(uint);
	std::string make_q8();
	std::string make_reglist();
	void make_reglist_half(std::string& s, const char *reg, uint16 mask);
	std::string make_bf();
	std::string make_fc();
	std::string make_movec();
	std::string make_fpgen();
	std::string make_fpn(uint n);
	std::string make_fpcc(uint16 ir);
	uint make_fpctls(std::string& s);
	std::string make_fpnlist();

	static const char * const reg_names[];
	static const char * const size_str[];
	static const char * const conditions[];
	static const char * const fpconditions[];
	static const char * const btst_names[];
	static const char * const fpgen_names[0x3b];
	static const char * const fmovecr_text[];
	static const char * const x68k_doscall[256];
	static const char * const x68k_fpcall[256];
	static const char * const x68k_iocscall[256];
	void ops_cmp2chk2(Size sz);
	void ops_btst_movep();
	void ops_cas(Size sz);
	void ops_cas2(Size sz);
	void ops_moves(Size sz);
	void ops_movep();
	void ops_btst_imm_ea();
	void ops_move(Size sz);
	void ops_movem_ext(Size sz);
	void ops_scc();
	void ops_bcc();
	void ops_sub(Size sz);
	void ops_add(Size sz);
	void ops_eor_cmpm(Size sz);
	void ops_rotate(std::string dir, Size sz);
	void ops_pmove(Reg reg, Size sz);
	void ops_fpgen_fpn_fpn();
	void ops_fpgen_ea_fpn();
	void ops_fmovecr();
	void ops_fmove_fpn_ea();
	void ops_fmovem_ea_ctl();
	void ops_fmovem_ctl_ea();
	void ops_fmovem_ea_fpn();
	void ops_fmovem_fpn_ea();

	std::vector<uint16> ir {};

	std::string name;
	Size size {};
	std::string src;
	std::string dst;

#define OP_PROTO(name)	void __CONCAT(op_,name)()
#define OP_DEF(name)	void __CONCAT(Disasm::op_,name)()
#define OP_FUNC(name)	__CONCAT(op_,name)()
#include "m68030ops.h"
};

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.