6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-12-12 08:30:05 +00:00
Code Issues Projects Releases Wiki Activity
8b88d1294d
CLK/InstructionSets/M68k/Instruction.cpp

324 lines
10 KiB
C++
Raw Normal View History

Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
//
// Instruction.cpp
// Clock Signal
//
// Created by Thomas Harte on 12/05/2022.
// Copyright © 2022 Thomas Harte. All rights reserved.
//
#include "Instruction.hpp"
#include <cassert>
using namespace InstructionSet::M68k;
`Const` as many arguments as possible.
2024-10-14 01:34:01 +00:00
std::string Preinstruction::operand_description(const int index, const int opcode) const {
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
switch(mode(index)) {
default: assert(false);
case AddressingMode::None:
return "";
case AddressingMode::DataRegisterDirect:
return std::string("D") + std::to_string(reg(index));
case AddressingMode::AddressRegisterDirect:
return std::string("A") + std::to_string(reg(index));
case AddressingMode::AddressRegisterIndirect:
return std::string("(A") + std::to_string(reg(index)) + ")";
case AddressingMode::AddressRegisterIndirectWithPostincrement:
return std::string("(A") + std::to_string(reg(index)) + ")+";
case AddressingMode::AddressRegisterIndirectWithPredecrement:
return std::string("-(A") + std::to_string(reg(index)) + ")";
case AddressingMode::AddressRegisterIndirectWithDisplacement:
return std::string("(d16, A") + std::to_string(reg(index)) + ")";
case AddressingMode::AddressRegisterIndirectWithIndex8bitDisplacement:
return std::string("(d8, A") + std::to_string(reg(index)) + ", Xn)";
case AddressingMode::ProgramCounterIndirectWithDisplacement:
return "(d16, PC)";
case AddressingMode::ProgramCounterIndirectWithIndex8bitDisplacement:
return "(d8, PC, Xn)";
case AddressingMode::AbsoluteShort:
return "(xxx).w";
case AddressingMode::AbsoluteLong:
return "(xxx).l";
Output extension words as if immediates.
2022-10-25 13:58:01 +00:00
case AddressingMode::ExtensionWord:
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
case AddressingMode::ImmediateData:
return "#";
case AddressingMode::Quick:
if(opcode == -1) {
return "Q";
}
return std::to_string(int(quick(uint16_t(opcode), operation)));
}
}
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
namespace {
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
`Const` as many arguments as possible.
2024-10-14 01:34:01 +00:00
const char *_to_string(const Operation operation, const bool is_quick) {
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
switch(operation) {
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::Undefined: return "None";
case Operation::NOP: return "NOP";
case Operation::ABCD: return "ABCD";
case Operation::SBCD: return "SBCD";
case Operation::NBCD: return "NBCD";
case Operation::ADDb: return "ADD.b";
case Operation::ADDw: return "ADD.w";
case Operation::ADDl: return "ADD.l";
case Operation::ADDAw: return is_quick ? "ADD.w" : "ADDA.w";
case Operation::ADDAl: return is_quick ? "ADD.l" : "ADDA.l";
case Operation::ADDXb: return "ADDX.b";
case Operation::ADDXw: return "ADDX.w";
case Operation::ADDXl: return "ADDX.l";
case Operation::SUBb: return "SUB.b";
case Operation::SUBw: return "SUB.w";
case Operation::SUBl: return "SUB.l";
case Operation::SUBAw: return is_quick ? "SUB.w" : "SUBA.w";
case Operation::SUBAl: return is_quick ? "SUB.l" : "SUBA.l";
case Operation::SUBXb: return "SUBX.b";
case Operation::SUBXw: return "SUBX.w";
case Operation::SUBXl: return "SUBX.l";
case Operation::MOVEb: return "MOVE.b";
case Operation::MOVEw: return "MOVE.w";
case Operation::MOVEl: return is_quick ? "MOVE.q" : "MOVE.l";
case Operation::MOVEAw: return "MOVEA.w";
case Operation::MOVEAl: return "MOVEA.l";
Decode MOVES.
2022-10-26 17:34:01 +00:00
case Operation::MOVESb: return "MOVES.b";
case Operation::MOVESw: return "MOVES.w";
case Operation::MOVESl: return "MOVES.l";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::LEA: return "LEA";
case Operation::PEA: return "PEA";
case Operation::MOVEtoSR: return "MOVEtoSR";
case Operation::MOVEfromSR: return "MOVEfromSR";
case Operation::MOVEtoCCR: return "MOVEtoCCR";
Decode MOVE from CCR.
2022-10-26 16:39:40 +00:00
case Operation::MOVEfromCCR: return "MOVEfromCCR";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::MOVEtoUSP: return "MOVEtoUSP";
case Operation::MOVEfromUSP: return "MOVEfromUSP";
Decode MOVEC.
2022-10-26 16:50:15 +00:00
case Operation::MOVEtoC: return "MOVEtoC";
case Operation::MOVEfromC: return "MOVEfromC";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::ORItoSR: return "ORItoSR";
case Operation::ORItoCCR: return "ORItoCCR";
case Operation::ANDItoSR: return "ANDItoSR";
case Operation::ANDItoCCR: return "ANDItoCCR";
case Operation::EORItoSR: return "EORItoSR";
case Operation::EORItoCCR: return "EORItoCCR";
case Operation::BTST: return "BTST";
case Operation::BCLR: return "BCLR";
case Operation::BCHG: return "BCHG";
case Operation::BSET: return "BSET";
case Operation::CMPb: return "CMP.b";
case Operation::CMPw: return "CMP.w";
case Operation::CMPl: return "CMP.l";
case Operation::CMPAw: return "CMPA.w";
case Operation::CMPAl: return "CMPA.l";
case Operation::TSTb: return "TST.b";
case Operation::TSTw: return "TST.w";
case Operation::TSTl: return "TST.l";
case Operation::JMP: return "JMP";
case Operation::JSR: return "JSR";
case Operation::RTS: return "RTS";
Add text conversions.
2022-10-27 14:12:52 +00:00
case Operation::RTD: return "RTD";
case Operation::RTM: return "RTM";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::DBcc: return "DBcc";
case Operation::Scc: return "Scc";
Add text conversions.
2022-10-27 14:12:52 +00:00
case Operation::TRAPcc: return "TRAPcc";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::Bccb:
case Operation::Bccl:
case Operation::Bccw: return "Bcc";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::BSRb:
case Operation::BSRl:
case Operation::BSRw: return "BSR";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Decode CAS.
2022-10-28 17:57:00 +00:00
case Operation::CASb: return "CAS.b";
case Operation::CASw: return "CAS.w";
case Operation::CASl: return "CAS.l";
Decode CAS2.
2022-10-28 18:02:49 +00:00
case Operation::CAS2w: return "CAS2.w";
case Operation::CAS2l: return "CAS2.l";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::CLRb: return "CLR.b";
case Operation::CLRw: return "CLR.w";
case Operation::CLRl: return "CLR.l";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::NEGXb: return "NEGX.b";
case Operation::NEGXw: return "NEGX.w";
case Operation::NEGXl: return "NEGX.l";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::NEGb: return "NEG.b";
case Operation::NEGw: return "NEG.w";
case Operation::NEGl: return "NEG.l";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::ASLb: return "ASL.b";
case Operation::ASLw: return "ASL.w";
case Operation::ASLl: return "ASL.l";
case Operation::ASLm: return "ASL.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::ASRb: return "ASR.b";
case Operation::ASRw: return "ASR.w";
case Operation::ASRl: return "ASR.l";
case Operation::ASRm: return "ASR.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::LSLb: return "LSL.b";
case Operation::LSLw: return "LSL.w";
case Operation::LSLl: return "LSL.l";
case Operation::LSLm: return "LSL.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::LSRb: return "LSR.b";
case Operation::LSRw: return "LSR.w";
case Operation::LSRl: return "LSR.l";
case Operation::LSRm: return "LSR.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::ROLb: return "ROL.b";
case Operation::ROLw: return "ROL.w";
case Operation::ROLl: return "ROL.l";
case Operation::ROLm: return "ROL.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::RORb: return "ROR.b";
case Operation::RORw: return "ROR.w";
case Operation::RORl: return "ROR.l";
case Operation::RORm: return "ROR.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::ROXLb: return "ROXL.b";
case Operation::ROXLw: return "ROXL.w";
case Operation::ROXLl: return "ROXL.l";
case Operation::ROXLm: return "ROXL.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::ROXRb: return "ROXR.b";
case Operation::ROXRw: return "ROXR.w";
case Operation::ROXRl: return "ROXR.l";
case Operation::ROXRm: return "ROXR.w";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::MOVEMtoMl: return "MOVEM.l";
case Operation::MOVEMtoMw: return "MOVEM.w";
case Operation::MOVEMtoRl: return "MOVEM.l";
case Operation::MOVEMtoRw: return "MOVEM.w";
case Operation::MOVEPl: return "MOVEP.l";
case Operation::MOVEPw: return "MOVEP.w";
case Operation::ANDb: return "AND.b";
case Operation::ANDw: return "AND.w";
case Operation::ANDl: return "AND.l";
case Operation::EORb: return "EOR.b";
case Operation::EORw: return "EOR.w";
case Operation::EORl: return "EOR.l";
case Operation::NOTb: return "NOT.b";
case Operation::NOTw: return "NOT.w";
case Operation::NOTl: return "NOT.l";
case Operation::ORb: return "OR.b";
case Operation::ORw: return "OR.w";
case Operation::ORl: return "OR.l";
Introduce/extend 68k enums to cover 68020 instruction set.
2022-10-22 19:20:30 +00:00
case Operation::MULUw: return "MULU";
case Operation::MULSw: return "MULS";
Decode [MUL/DIV][U/S].l.
2022-10-30 15:32:36 +00:00
case Operation::MULSorMULUl: return "[MULS/MULU]{L}.l";
Introduce/extend 68k enums to cover 68020 instruction set.
2022-10-22 19:20:30 +00:00
case Operation::DIVUw: return "DIVU";
case Operation::DIVSw: return "DIVS";
Decode [MUL/DIV][U/S].l.
2022-10-30 15:32:36 +00:00
case Operation::DIVSorDIVUl: return "[DIVS/DIVU]{L}.l";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::RTE: return "RTE";
case Operation::RTR: return "RTR";
case Operation::TRAP: return "TRAP";
case Operation::TRAPV: return "TRAPV";
Attempt LINK.l and CHK.l.
2022-10-30 01:42:53 +00:00
Introduce/extend 68k enums to cover 68020 instruction set.
2022-10-22 19:20:30 +00:00
case Operation::CHKw: return "CHK";
Attempt LINK.l and CHK.l.
2022-10-30 01:42:53 +00:00
case Operation::CHKl: return "CHK.l";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
Parse and record duality of CHK2/CMP2.
2022-10-30 01:32:48 +00:00
case Operation::CHKorCMP2b: return "[CHK/CMP]2.b";
case Operation::CHKorCMP2w: return "[CHK/CMP]2.w";
case Operation::CHKorCMP2l: return "[CHK/CMP]2.l";
Decode CAS2.
2022-10-28 18:02:49 +00:00
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::EXG: return "EXG";
case Operation::SWAP: return "SWAP";
case Operation::TAS: return "TAS";
case Operation::EXTbtow: return "EXT.w";
case Operation::EXTwtol: return "EXT.l";
Decode EXTB.l.
2022-10-30 15:20:43 +00:00
case Operation::EXTbtol: return "EXTB.l";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::LINKw: return "LINK";
Attempt LINK.l and CHK.l.
2022-10-30 01:42:53 +00:00
case Operation::LINKl: return "LINK.l";
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
case Operation::UNLINK: return "UNLINK";
case Operation::STOP: return "STOP";
case Operation::RESET: return "RESET";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
Add BKPT and RTD.
2022-10-26 02:35:44 +00:00
case Operation::BKPT: return "BKPT";
Add text conversions.
2022-10-27 14:12:52 +00:00
case Operation::BFCHG: return "BFCHG";
case Operation::BFCLR: return "BFCLR";
case Operation::BFEXTS: return "BFEXTS";
case Operation::BFEXTU: return "BFEXTU";
case Operation::BFFFO: return "BFFFO";
case Operation::BFINS: return "BFINS";
case Operation::BFSET: return "BFSET";
case Operation::BFTST: return "BFTST";
case Operation::PACK: return "PACK";
case Operation::UNPK: return "UNPK";
Add BKPT and RTD.
2022-10-26 02:35:44 +00:00
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
default:
assert(false);
Avoid returning without value in release builds.
2022-09-09 20:48:12 +00:00
return "???";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
}
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
}
}
`Const` as many arguments as possible.
2024-10-14 01:34:01 +00:00
const char *InstructionSet::M68k::to_string(const Operation operation) {
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
return _to_string(operation, false);
}
`Const` as many arguments as possible.
2024-10-14 01:34:01 +00:00
std::string Preinstruction::to_string(const int opcode) const {
Provide a direct `to_string` on `Operation`.
2022-09-06 01:52:20 +00:00
if(operation == Operation::Undefined) return "None";
const char *const instruction = _to_string(operation, mode<0>() == AddressingMode::Quick);
const bool flip_operands = (operation == Operation::MOVEMtoRl) || (operation == Operation::MOVEMtoRw);
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
const std::string operand1 = operand_description(0 ^ int(flip_operands), opcode);
const std::string operand2 = operand_description(1 ^ int(flip_operands), opcode);
std::string result = instruction;
if(!operand1.empty()) result += std::string(" ") + operand1;
if(!operand2.empty()) result += std::string(", ") + operand2;
Support up to 15 extension words on a Preinstruction; use that to describe PACK/UNPK. TODO: reconcile when to use that field versus the ExtensionWord operand. Probably only when operands are full?
2022-10-28 17:36:40 +00:00
const int extension_words = additional_extension_words();
if(extension_words) result += std::string(" [+") + std::to_string(extension_words) + "]";
Move string logic into `Preinstruction`.
2022-05-12 23:46:08 +00:00
return result;
}
Provide a route to operation that factors in addressing mode.
2022-09-06 15:26:16 +00:00
const char *Preinstruction::operation_string() const {
return _to_string(operation, mode<0>() == AddressingMode::Quick);
}
Reference in New Issue Copy Permalink