541 lines
14 KiB
C++
541 lines
14 KiB
C++
// Copyright 2015 by Joseph Forgione
|
|
// This file is part of VCC (Virtual Color Computer).
|
|
//
|
|
// VCC (Virtual Color Computer) is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// VCC (Virtual Color Computer) is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with VCC (Virtual Color Computer). If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// OpDecoder Interface - Part of the Debugger package for VCC
|
|
// Author: Mike Rojas
|
|
#include "../../src/core/OpCodeTables.h"
|
|
#include <stdexcept>
|
|
#include "../../src/core/tcc1014mmu.h"
|
|
#include <bitset>
|
|
#include "DebuggerUtils.h"
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
|
|
namespace VCC::Debugger
|
|
{
|
|
bool OpCodeTables::ProcessHeuristics(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
bool valid = true;
|
|
trace.decodeCycles = state.IsNative6309 ? opcode.num6309cycles : opcode.num6809cycles;
|
|
|
|
switch (opcode.modifer)
|
|
{
|
|
case Heuristics::None:
|
|
case Heuristics::Fixed:
|
|
valid = ProcessNoAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::IndexedModeAdjust:
|
|
valid = ProcessIndexModeAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::InterruptAdjust:
|
|
valid = ProcessInterruptAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::StackAdjust:
|
|
valid = ProcessStackAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::LongBranchAdjust:
|
|
valid = ProcessLongBranchAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::TFMAdjust:
|
|
valid = ProcessTFMAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::DIVAdjust:
|
|
valid = ProcessDIVAdjust(opcode, state, trace);
|
|
break;
|
|
case Heuristics::WaitForSYNCAdjust:
|
|
valid = ProcessWaitForSYNCAdjust(opcode, state, trace);
|
|
break;
|
|
default:
|
|
valid = false;
|
|
throw std::runtime_error("Unhandled opcode heuristic");
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessNoAdjust(const OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
// Get the current PC.
|
|
unsigned short PC = state.PC;
|
|
|
|
// Skip past opcode bytes
|
|
PC += opcode.oplen;
|
|
|
|
// Number of bytes for the operand.
|
|
int operandLen = opcode.numbytes - opcode.oplen;
|
|
for (int n = 0; n < operandLen; n++)
|
|
{
|
|
trace.bytes.push_back(DbgRead8(state.phyAddr,state.block,PC++));
|
|
}
|
|
|
|
int operand = 0;
|
|
|
|
switch (operandLen)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
operand = trace.bytes[opcode.oplen];
|
|
break;
|
|
case 2:
|
|
operand = (trace.bytes[opcode.oplen] << 8) + trace.bytes[opcode.oplen + 1];
|
|
break;
|
|
}
|
|
|
|
switch (opcode.mode)
|
|
{
|
|
case Inherent:
|
|
break;
|
|
case Direct:
|
|
trace.operand = "<$" + ToHexString(operand, 2);
|
|
break;
|
|
case Indexed:
|
|
break;
|
|
case Relative:
|
|
trace.operand = ToRelativeAddressString(operand, operandLen);
|
|
break;
|
|
case Extended:
|
|
trace.operand = "$" + ToHexString(operand, 4);
|
|
break;
|
|
case Immediate:
|
|
{
|
|
// TFR and EXG - use inter-register operand
|
|
if (opcode.opcode == 0x1F || opcode.opcode == 0x1E)
|
|
{
|
|
// Get source and destination registers
|
|
unsigned char src = operand >> 4;
|
|
unsigned char dst = operand & 0b00001111;
|
|
|
|
trace.operand = ToInterRegister(src) + "," + ToInterRegister(dst);
|
|
}
|
|
else
|
|
{
|
|
trace.operand = "#$" + ToHexString(operand, 2);
|
|
}
|
|
}
|
|
break;
|
|
case LongRelative:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessIndexModeAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
// Get the current PC.
|
|
unsigned short PC = state.PC;
|
|
|
|
// Get the post byte.
|
|
PC += opcode.oplen;
|
|
unsigned char postbyte = DbgRead8(state.phyAddr,state.block,PC);
|
|
|
|
trace.bytes.push_back(postbyte);
|
|
|
|
// Determine various indexing modes.
|
|
IndexModeInfo mode;
|
|
if (!GetIndexMode(postbyte, mode, trace.operand))
|
|
{
|
|
// Index mode is not valid.
|
|
return false;
|
|
}
|
|
|
|
// One byte offset?
|
|
if (mode.numbytes == 1)
|
|
{
|
|
unsigned char b = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(b);
|
|
std::int32_t offset = b;
|
|
offset = (offset << 24) >> 24;
|
|
replace(trace.operand, "n", std::to_string(offset));
|
|
}
|
|
|
|
// Two byte offset?
|
|
if (mode.numbytes == 2)
|
|
{
|
|
unsigned char b1 = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(b1);
|
|
unsigned char b2 = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(b2);
|
|
std::int32_t offset = (b1 << 8) + b2;
|
|
// Extended Indirect?
|
|
if (trace.operand == "[n]")
|
|
{
|
|
replace(trace.operand, "n", "$" + ToHexString(offset, 4));
|
|
}
|
|
else
|
|
{
|
|
offset = (offset << 16) >> 16;
|
|
replace(trace.operand, "n", std::to_string(offset));
|
|
}
|
|
}
|
|
|
|
// Adjust for number of cycles.
|
|
int additionalCycles = (state.IsNative6309) ? mode.num6309cycles : mode.num6809cycles;
|
|
trace.decodeCycles = AdjustCycles(opcode, additionalCycles, mode.numbytes, state.IsNative6309);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::GetIndexMode(unsigned char postbyte, IndexModeInfo& mode, std::string& operand) const
|
|
{
|
|
// Convert to key.
|
|
std::string key = std::bitset<8>(postbyte).to_string();
|
|
|
|
// MSB = 0? 5 bit offset.
|
|
if (key[0] == '0')
|
|
{
|
|
mode = IndexingModes.at("0RRnnnnn");
|
|
operand = mode.form;
|
|
|
|
// Determine the register.
|
|
replace(operand, "R", ToRegister(postbyte));
|
|
|
|
// Convert 5 bits to sign extended offset (-16 to +15)
|
|
std::int32_t offset = std::bitset<5>(key.substr(3, 5)).to_ulong();
|
|
offset = (offset << 27) >> 27;
|
|
replace(operand, "n", std::to_string(offset));
|
|
|
|
return true;
|
|
}
|
|
|
|
// Try exact match.
|
|
if (IndexingModes.find(key) != IndexingModes.end())
|
|
{
|
|
mode = IndexingModes.at(key);
|
|
operand = mode.form;
|
|
return true;
|
|
}
|
|
|
|
// Try PCR modes.
|
|
key[1] = 'X';
|
|
key[2] = 'X';
|
|
if (IndexingModes.find(key) != IndexingModes.end())
|
|
{
|
|
mode = IndexingModes.at(key);
|
|
operand = mode.form;
|
|
return true;
|
|
}
|
|
|
|
// Try register modes.
|
|
key[1] = 'R';
|
|
key[2] = 'R';
|
|
if (IndexingModes.find(key) != IndexingModes.end())
|
|
{
|
|
mode = IndexingModes.at(key);
|
|
operand = mode.form;
|
|
replace(operand, "R", ToRegister(postbyte));
|
|
return true;
|
|
}
|
|
|
|
// Invalid mode.
|
|
return false;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessInterruptAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
trace.decodeCycles = AdjustCycles(opcode, 0, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessStackAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
// Get the current PC.
|
|
unsigned short PC = state.PC;
|
|
|
|
// Get the post byte.
|
|
unsigned char postbyte = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(postbyte);
|
|
|
|
// Count the number of registers set in post byte.
|
|
int additionalCycles = 0;
|
|
int regIndex = 0;
|
|
std::array<std::string, 8> registers = { "CC", "A", "B", "DP", "X", "Y", "U/S", "PC" };
|
|
std::array<int, 8> registerSize = { 1, 1, 1, 1, 2, 2, 2, 2 };
|
|
registers[6] = opcode.opcode & 0b00000010 ? "S" : "U";
|
|
while (postbyte)
|
|
{
|
|
int bit = postbyte & 1;
|
|
if (bit)
|
|
{
|
|
if (trace.operand.size() > 0)
|
|
{
|
|
trace.operand += ",";
|
|
}
|
|
trace.operand += registers[regIndex];
|
|
// One additional cycle per byte pushed/pulled.
|
|
additionalCycles += registerSize[regIndex];
|
|
}
|
|
postbyte >>= 1;
|
|
regIndex++;
|
|
}
|
|
|
|
// Adjust the number of cycles.
|
|
trace.decodeCycles = AdjustCycles(opcode, additionalCycles, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessLongBranchAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
// Get the current PC.
|
|
unsigned short PC = state.PC;
|
|
|
|
// Skip past opcode bytes
|
|
PC += opcode.oplen;
|
|
|
|
// Number of bytes for the operand.
|
|
int operandLen = opcode.numbytes - opcode.oplen;
|
|
for (int n = 0; n < operandLen; n++)
|
|
{
|
|
trace.bytes.push_back(DbgRead8(state.phyAddr,state.block,PC++));
|
|
}
|
|
|
|
// All long branches are relative.
|
|
int operand = (trace.bytes[opcode.oplen] << 8) + trace.bytes[opcode.oplen + 1];
|
|
trace.operand = ToRelativeAddressString(operand, operandLen);
|
|
|
|
// No adjustment needed on 6309
|
|
if (state.IsNative6309)
|
|
{
|
|
trace.decodeCycles = AdjustCycles(opcode, 0, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
// We need to determine if the branch will be taken
|
|
bool willBranch = false;
|
|
bool C = (state.CC & 0b00000001) == 1;
|
|
bool V = (state.CC & 0b00000010) == 1; // FIXME: This will never be true because the result can never be 1
|
|
bool Z = (state.CC & 0b00000100) == 1; // FIXME: This will never be true because the result can never be 1
|
|
bool N = (state.CC & 0b00001000) == 1; // FIXME: This will never be true because the result can never be 1
|
|
|
|
// Will the branch be taken?
|
|
switch (opcode.opcode)
|
|
{
|
|
case 0x24: // LBCC, LBHS
|
|
willBranch = !C; // IF CC.C = 0 then PC <- PC + IMM
|
|
break;
|
|
case 0x25: // LBCS, LBLO
|
|
willBranch = C; // IF CC.C = 1 then PC <- PC + IMM
|
|
break;
|
|
case 0x28: // LBVC
|
|
willBranch = !V; // IF CC.V = 0 then PC <- PC + IMM
|
|
break;
|
|
case 0x29: // LBVS
|
|
willBranch = V; // IF CC.V = 1 then PC <- PC + IMM
|
|
break;
|
|
case 0x26: // LBNE
|
|
willBranch = !Z; // IF CC.Z = 0 then PC <- PC + IMM
|
|
break;
|
|
case 0x27: // LBEQ
|
|
willBranch = Z; // IF CC.Z = 1 then PC <- PC + IMM
|
|
break;
|
|
case 0x2A: // LBPL
|
|
willBranch = !N; // IF CC.N = 0 then PC <- PC + IMM
|
|
break;
|
|
case 0x2B: // LBMI
|
|
willBranch = N; // IF CC.N = 1 then PC <- PC + IMM
|
|
break;
|
|
case 0x2C: // LBGE
|
|
willBranch = N == V; // IF CC.N = CC.V then PC <- PC + IMM
|
|
break;
|
|
case 0x2F: // LBLE
|
|
willBranch = (N != V) || Z; // IF (CC.N <> CC.V) OR (CC.Z = 1) then PC <- PC + IMM
|
|
break;
|
|
case 0x2E: // LBGT
|
|
willBranch = (N == V) && !Z; // IF (CC.N = CC.V) AND (CC.Z = 0) then PC <- PC + IMM
|
|
break;
|
|
case 0x2D: // LBLT
|
|
willBranch = N != V; // IF CC.N <> CC.V then PC <- PC + IMM
|
|
break;
|
|
case 0x22: // LBHI
|
|
willBranch = !Z && !C; // IF (CC.Z = 0) AND (CC.C = 0) then PC <- PC + IMM
|
|
break;
|
|
case 0x23: // LBLS
|
|
willBranch = Z || C; // IF (CC.Z = 1) OR (CC.C = 1) then PC <- PC + IMM
|
|
break;
|
|
}
|
|
|
|
// Additional cycle if branch is taken.
|
|
trace.decodeCycles = AdjustCycles(opcode, willBranch ? 1 : 0, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessTFMAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
// Get the current PC.
|
|
unsigned short PC = state.PC;
|
|
|
|
// Get the post byte.
|
|
unsigned char postbyte = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(postbyte);
|
|
|
|
// Get source and destination registers
|
|
unsigned char src = postbyte >> 4;
|
|
unsigned char dst = postbyte & 0b00001111;
|
|
|
|
trace.operand = ToInterRegister(src) + "," + ToInterRegister(dst);
|
|
|
|
// Assume invalid.
|
|
int additionalCycles = 0;
|
|
|
|
// Only D, X, Y, U, S are valid.
|
|
if (src < 0b0101 && dst < 0b0101)
|
|
{
|
|
// Get number of bytes that will be transferred.
|
|
unsigned short W = (state.E << 8) + state.F;
|
|
|
|
// Calculate total cycles to complete.
|
|
additionalCycles = 3 * W;
|
|
}
|
|
|
|
// Adjust the number of cycles.
|
|
trace.decodeCycles = AdjustCycles(opcode, additionalCycles, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessDIVAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
// Two rules:
|
|
// 1) DIVD executes in l fewer cycle if a two's-complement overflow occurs.
|
|
// 2) Range error means fewer cycles: (13 fewer for DIVD, 21 fewer for DIVQ)
|
|
|
|
// Get the current PC.
|
|
unsigned short PC = state.PC;
|
|
|
|
// Determine width.
|
|
bool wide = (opcode.opcode == 0x8E);
|
|
|
|
// Get the dividend
|
|
int dividend = (state.A << 8) + state.B;
|
|
|
|
// Get the divisor
|
|
int divisor;
|
|
if (wide)
|
|
{
|
|
unsigned char b1 = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(b1);
|
|
unsigned char b2 = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(b2);
|
|
divisor = (b1 << 8) + b2;
|
|
}
|
|
else
|
|
{
|
|
unsigned char b1 = DbgRead8(state.phyAddr,state.block,++PC);
|
|
trace.bytes.push_back(b1);
|
|
divisor = b1;
|
|
}
|
|
|
|
// Calculate the quotient
|
|
int quotient = dividend / divisor;
|
|
|
|
int additionalCycles = 0;
|
|
|
|
// Range Error?
|
|
if (!wide && ((quotient > 255) || (quotient < -256)) ||
|
|
(wide && ((quotient > 65535) || (quotient < -65536))))
|
|
{
|
|
additionalCycles = wide ? -21: -13;
|
|
}
|
|
// 2-complement Overflow?
|
|
else if (!wide && ((quotient > 127) || (quotient < -128)) ||
|
|
(wide && ((quotient > 32767) || (quotient < -32768))))
|
|
{
|
|
additionalCycles = -1;
|
|
}
|
|
|
|
trace.decodeCycles = AdjustCycles(opcode, additionalCycles, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
bool OpCodeTables::ProcessWaitForSYNCAdjust(OpCodeInfo& opcode, const CPUState& state, CPUTrace& trace) const
|
|
{
|
|
trace.decodeCycles = AdjustCycles(opcode, 0, 0, state.IsNative6309);
|
|
return true;
|
|
}
|
|
|
|
std::string OpCodeTables::ToInterRegister(unsigned char reg) const
|
|
{
|
|
std::vector<std::string> regs = { "D", "X", "Y", "U", "S", "PC", "W", "V", "A", "B", "CC", "DP", "0", "0", "E", "F" };
|
|
return regs[reg];
|
|
}
|
|
|
|
std::string OpCodeTables::ToRegister(unsigned char postbyte) const
|
|
{
|
|
int reg = (postbyte & 0b01100000) >> 5;
|
|
switch (reg)
|
|
{
|
|
case 0b00:
|
|
return "X";
|
|
case 0b01:
|
|
return "Y";
|
|
case 0b10:
|
|
return "U";
|
|
case 0b11:
|
|
return "S";
|
|
}
|
|
return "?";
|
|
}
|
|
|
|
std::string OpCodeTables::ToRelativeAddressString(int value, int operandlen) const
|
|
{
|
|
std::ostringstream fmt;
|
|
|
|
int length = operandlen * 2;
|
|
int relativeOffset = length + value;
|
|
switch (operandlen)
|
|
{
|
|
case 0:
|
|
if (relativeOffset > 15) relativeOffset -= 16;
|
|
break;
|
|
case 1:
|
|
if (relativeOffset > 127) relativeOffset -= 256;
|
|
break;
|
|
case 2:
|
|
if (relativeOffset > 32767) relativeOffset -= 65536;
|
|
break;
|
|
}
|
|
|
|
fmt << "*";
|
|
if (relativeOffset < 0)
|
|
{
|
|
relativeOffset *= -1;
|
|
fmt << "-$" << std::hex << std::setw(length) << std::uppercase << std::setfill('0') << relativeOffset;
|
|
}
|
|
else if (relativeOffset > 0)
|
|
{
|
|
fmt << "+$" << std::hex << std::setw(length) << std::uppercase << std::setfill('0') << relativeOffset;
|
|
}
|
|
|
|
return fmt.str();
|
|
}
|
|
|
|
int OpCodeTables::AdjustCycles(OpCodeInfo& opcode, int cycles, int bytes, bool IsNative6309) const
|
|
{
|
|
if (IsNative6309)
|
|
{
|
|
opcode.num6309cycles += cycles;
|
|
cycles = opcode.num6309cycles;
|
|
}
|
|
else
|
|
{
|
|
opcode.num6809cycles += cycles;
|
|
cycles = opcode.num6809cycles;
|
|
}
|
|
opcode.numbytes += bytes;
|
|
return cycles;
|
|
}
|
|
}
|