534 lines
11 KiB
C++
534 lines
11 KiB
C++
#include "app/emu/audio/spc700.h"
|
|
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
namespace yaze {
|
|
namespace app {
|
|
namespace emu {
|
|
|
|
void SPC700::Reset() {}
|
|
|
|
void SPC700::ExecuteInstructions(uint8_t opcode) {
|
|
switch (opcode) {
|
|
// 8-bit Move Memory to Register
|
|
case 0xE8: // MOV A, #imm
|
|
MOV(A, imm());
|
|
break;
|
|
case 0xE6: // MOV A, (X)
|
|
MOV(A, X);
|
|
break;
|
|
case 0xBF: // MOV A, (X)+
|
|
MOV(A, X);
|
|
X++;
|
|
break;
|
|
case 0xE4: // MOV A, dp
|
|
MOV(A, dp());
|
|
break;
|
|
case 0xF4: // MOV A, dp+X
|
|
MOV(A, dp_plus_x());
|
|
break;
|
|
case 0xE5: // MOV A, !abs
|
|
MOV(A, abs());
|
|
break;
|
|
case 0xF5: // MOV A, !abs+X
|
|
MOV(A, abs() + X);
|
|
break;
|
|
case 0xF6: // MOV A, !abs+Y
|
|
MOV(A, abs() + Y);
|
|
break;
|
|
case 0xE7: // MOV A, [dp+X]
|
|
MOV(A, read(dp_plus_x_indirect()));
|
|
break;
|
|
case 0xF7: // MOV A, [dp]+Y
|
|
MOV(A, read(dp_indirect_plus_y()));
|
|
break;
|
|
case 0xCD: // MOV X, #imm
|
|
MOV(X, imm());
|
|
break;
|
|
case 0xF8: // MOV X, dp
|
|
MOV(X, dp());
|
|
break;
|
|
case 0xF9: // MOV X, dp+Y
|
|
MOV(X, dp_plus_y());
|
|
break;
|
|
case 0xE9: // MOV X, !abs
|
|
MOV(X, abs());
|
|
break;
|
|
case 0x8D: // MOV Y, #imm
|
|
MOV(Y, imm());
|
|
break;
|
|
case 0xEB: // MOV Y, dp
|
|
MOV(Y, dp());
|
|
break;
|
|
case 0xFB: // MOV Y, dp+X
|
|
MOV(Y, dp_plus_x());
|
|
break;
|
|
case 0xEC: // MOV Y, !abs
|
|
MOV(Y, abs());
|
|
break;
|
|
|
|
// 8-bit move register to memory
|
|
|
|
case 0xC6: // MOV (X), A
|
|
break;
|
|
case 0xAF: // MOV (X)+, A
|
|
break;
|
|
case 0xC4: // MOV dp, A
|
|
MOV_ADDR(get_dp_addr(), A);
|
|
break;
|
|
case 0xD4: // MOV dp+X, A
|
|
MOV_ADDR(get_dp_addr() + X, A);
|
|
break;
|
|
case 0xC5: // MOV !abs, A
|
|
MOV_ADDR(abs(), A);
|
|
break;
|
|
case 0xD5: // MOV !abs+X, A
|
|
MOV_ADDR(abs() + X, A);
|
|
break;
|
|
case 0xD6: // MOV !abs+Y, A
|
|
MOV_ADDR(abs() + Y, A);
|
|
break;
|
|
case 0xC7: // MOV [dp+X], A
|
|
MOV_ADDR(dp_plus_x_indirect(), A);
|
|
break;
|
|
case 0xD7: // MOV [dp]+Y, A
|
|
MOV_ADDR(dp_indirect_plus_y(), A);
|
|
break;
|
|
case 0xD8: // MOV dp, X
|
|
MOV_ADDR(get_dp_addr(), X);
|
|
break;
|
|
case 0xD9: // MOV dp+Y, X
|
|
MOV_ADDR(get_dp_addr() + Y, X);
|
|
break;
|
|
case 0xC9: // MOV !abs, X
|
|
MOV_ADDR(abs(), X);
|
|
break;
|
|
case 0xCB: // MOV dp, Y
|
|
MOV_ADDR(get_dp_addr(), Y);
|
|
break;
|
|
case 0xDB: // MOV dp+X, Y
|
|
MOV_ADDR(get_dp_addr() + X, Y);
|
|
break;
|
|
case 0xCC: // MOV !abs, Y
|
|
MOV_ADDR(abs(), Y);
|
|
break;
|
|
|
|
// . 8-bit move register to register / special direct page moves
|
|
|
|
case 0x7D: // MOV A, X
|
|
break;
|
|
case 0xDD: // MOV A, Y
|
|
break;
|
|
case 0x5D: // MOV X, A
|
|
break;
|
|
case 0xFD: // MOV Y, A
|
|
break;
|
|
case 0x9D: // MOV X, SP
|
|
break;
|
|
case 0xBD: // MOV SP, X
|
|
break;
|
|
case 0xFA: // MOV dp, dp
|
|
break;
|
|
case 0x8F: // MOV dp, #imm
|
|
break;
|
|
|
|
// . 8-bit arithmetic
|
|
|
|
case 0x88: // ADC A, #imm
|
|
ADC(A, imm());
|
|
break;
|
|
case 0x86: // ADC A, (X)
|
|
break;
|
|
case 0x84: // ADC A, dp
|
|
ADC(A, dp());
|
|
break;
|
|
case 0x94: // ADC A, dp+X
|
|
ADC(A, dp_plus_x());
|
|
break;
|
|
case 0x85: // ADC A, !abs
|
|
ADC(A, abs());
|
|
break;
|
|
case 0x95: // ADC A, !abs+X
|
|
break;
|
|
case 0x96: // ADC A, !abs+Y
|
|
break;
|
|
case 0x87: // ADC A, [dp+X]
|
|
ADC(A, dp_plus_x_indirect());
|
|
break;
|
|
case 0x97: // ADC A, [dp]+Y
|
|
ADC(A, dp_indirect_plus_y());
|
|
break;
|
|
case 0x99: // ADC (X), (Y)
|
|
break;
|
|
case 0x89: // ADC dp, dp
|
|
break;
|
|
case 0x98: // ADC dp, #imm
|
|
break;
|
|
case 0xA8: // SBC A, #imm
|
|
SBC(A, imm());
|
|
break;
|
|
case 0xA6: // SBC A, (X)
|
|
break;
|
|
case 0xA4: // SBC A, dp
|
|
break;
|
|
case 0xB4: // SBC A, dp+X
|
|
break;
|
|
case 0xA5: // SBC A, !abs
|
|
break;
|
|
case 0xB5: // SBC A, !abs+X
|
|
break;
|
|
case 0xB6: // SBC A, !abs+Y
|
|
break;
|
|
case 0xA7: // SBC A, [dp+X]
|
|
break;
|
|
case 0xB7: // SBC A, [dp]+Y
|
|
break;
|
|
case 0xB9: // SBC (X), (Y)
|
|
break;
|
|
case 0xA9: // SBC dp, dp
|
|
break;
|
|
case 0xB8: // SBC dp, #imm
|
|
break;
|
|
case 0x68: // CMP A, #imm
|
|
break;
|
|
case 0x66: // CMP A, (X)
|
|
break;
|
|
case 0x64: // CMP A, dp
|
|
break;
|
|
case 0x74: // CMP A, dp+X
|
|
break;
|
|
case 0x65: // CMP A, !abs
|
|
break;
|
|
case 0x75: // CMP A, !abs+X
|
|
break;
|
|
case 0x76: // CMP A, !abs+Y
|
|
break;
|
|
case 0x67: // CMP A, [dp+X]
|
|
break;
|
|
case 0x77: // CMP A, [dp]+Y
|
|
break;
|
|
case 0x79: // CMP (X), (Y)
|
|
break;
|
|
case 0x69: // CMP dp, dp
|
|
break;
|
|
case 0x78: // CMP dp, #imm
|
|
break;
|
|
case 0xC8: // CMP X, #imm
|
|
break;
|
|
case 0x3E: // CMP X, dp
|
|
break;
|
|
case 0x1E: // CMP X, !abs
|
|
break;
|
|
case 0xAD: // CMP Y, #imm
|
|
break;
|
|
case 0x7E: // CMP Y, dp
|
|
break;
|
|
case 0x5E: // CMP Y, !abs
|
|
break;
|
|
|
|
// 8-bit boolean logic
|
|
|
|
case 0x28: // AND A, #imm
|
|
break;
|
|
case 0x26: // AND A, (X)
|
|
break;
|
|
case 0x24: // AND A, dp
|
|
break;
|
|
case 0x34: // AND A, dp+X
|
|
break;
|
|
case 0x25: // AND A, !abs
|
|
break;
|
|
case 0x35: // AND A, !abs+X
|
|
break;
|
|
case 0x36: // AND A, !abs+Y
|
|
break;
|
|
case 0x27: // AND A, [dp+X]
|
|
break;
|
|
case 0x37: // AND A, [dp]+Y
|
|
break;
|
|
case 0x39: // AND (X), (Y)
|
|
break;
|
|
case 0x29: // AND dp, dp
|
|
break;
|
|
case 0x38: // AND dp, #imm
|
|
break;
|
|
case 0x08: // OR A, #imm
|
|
OR(A, imm());
|
|
break;
|
|
case 0x06: // OR A, (X)
|
|
break;
|
|
case 0x04: // OR A, dp
|
|
OR(A, dp());
|
|
break;
|
|
case 0x14: // OR A, dp+X
|
|
OR(A, dp_plus_x());
|
|
break;
|
|
case 0x05: // OR A, !abs
|
|
OR(A, abs());
|
|
break;
|
|
case 0x15: // OR A, !abs+X
|
|
break;
|
|
case 0x16: // OR A, !abs+Y
|
|
break;
|
|
case 0x07: // OR A, [dp+X]
|
|
break;
|
|
case 0x17: // OR A, [dp]+Y
|
|
break;
|
|
case 0x19: // OR (X), (Y)
|
|
break;
|
|
case 0x09: // OR dp, dp
|
|
break;
|
|
case 0x18: // OR dp, #imm
|
|
break;
|
|
case 0x48: // EOR A, #imm
|
|
EOR(A, imm());
|
|
break;
|
|
case 0x46: // EOR A, (X)
|
|
break;
|
|
case 0x44: // EOR A, dp
|
|
EOR(A, dp());
|
|
break;
|
|
case 0x54: // EOR A, dp+X
|
|
break;
|
|
case 0x45: // EOR A, !abs
|
|
break;
|
|
case 0x55: // EOR A, !abs+X
|
|
break;
|
|
case 0x56: // EOR A, !abs+Y
|
|
break;
|
|
case 0x47: // EOR A, [dp+X]
|
|
break;
|
|
case 0x57: // EOR A, [dp]+Y
|
|
break;
|
|
case 0x59: // EOR (X), (Y)
|
|
break;
|
|
case 0x49: // EOR dp, dp
|
|
break;
|
|
case 0x58: // EOR dp, #imm
|
|
break;
|
|
|
|
// . 8-bit increment / decrement
|
|
|
|
case 0xBC: // INC A
|
|
INC(A);
|
|
break;
|
|
case 0xAB: // INC dp
|
|
break;
|
|
case 0xBB: // INC dp+X
|
|
break;
|
|
case 0xAC: // INC !abs
|
|
break;
|
|
case 0x3D: // INC X
|
|
INC(X);
|
|
break;
|
|
case 0xFC: // INC Y
|
|
INC(Y);
|
|
break;
|
|
case 0x9C: // DEC A
|
|
DEC(A);
|
|
break;
|
|
case 0x8B: // DEC dp
|
|
break;
|
|
case 0x9B: // DEC dp+X
|
|
break;
|
|
case 0x8C: // DEC !abs
|
|
break;
|
|
case 0x1D: // DEC X
|
|
DEC(X);
|
|
break;
|
|
case 0xDC: // DEC Y
|
|
DEC(Y);
|
|
break;
|
|
|
|
// 8-bit shift / rotation
|
|
|
|
case 0x1C: // ASL A
|
|
ASL(A);
|
|
break;
|
|
case 0x0B: // ASL dp
|
|
ASL(dp());
|
|
break;
|
|
case 0x1B: // ASL dp+X
|
|
ASL(dp_plus_x());
|
|
break;
|
|
case 0x0C: // ASL !abs
|
|
ASL(abs());
|
|
break;
|
|
case 0x5C: // LSR A
|
|
LSR(A);
|
|
break;
|
|
case 0x4B: // LSR dp
|
|
break;
|
|
case 0x5B: // LSR dp+X
|
|
break;
|
|
case 0x4C: // LSR !abs
|
|
break;
|
|
case 0x3C: // ROL A
|
|
break;
|
|
case 0x2B: // ROL dp
|
|
break;
|
|
case 0x3B: // ROL dp+X
|
|
break;
|
|
case 0x2C: // ROL !abs
|
|
break;
|
|
case 0x7C: // ROR A
|
|
break;
|
|
case 0x6B: // ROR dp
|
|
break;
|
|
case 0x7B: // ROR dp+X
|
|
break;
|
|
case 0x6C: // ROR !abs
|
|
break;
|
|
case 0x9F: // XCN A Exchange nibbles of A
|
|
|
|
break;
|
|
|
|
// . 16-bit operations
|
|
|
|
case 0xBA: // MOVW YA, dp
|
|
break;
|
|
case 0xDA: // MOVW dp, YA
|
|
break;
|
|
case 0x3A: // INCW dp
|
|
break;
|
|
case 0x1A: // DECW dp
|
|
break;
|
|
case 0x7A: // ADDW YA, dp
|
|
break;
|
|
case 0x9A: // SUBW YA, dp
|
|
break;
|
|
case 0x5A: // CMPW YA, dp
|
|
break;
|
|
case 0xCF: // MUL YA
|
|
break;
|
|
case 0x9E: // DIV YA, X
|
|
break;
|
|
|
|
// . decimal adjust
|
|
|
|
case 0xDF: // DAA A
|
|
break;
|
|
case 0xBE: // DAS A
|
|
break;
|
|
|
|
// . branching
|
|
|
|
case 0x2F: // BRA rel
|
|
break;
|
|
case 0xF0: // BEQ rel
|
|
break;
|
|
case 0xD0: // BNE rel
|
|
break;
|
|
case 0xB0: // BCS rel
|
|
break;
|
|
case 0x90: // BCC rel
|
|
break;
|
|
case 0x70: // BVS rel
|
|
break;
|
|
case 0x50: // BVC rel
|
|
break;
|
|
case 0x30: // BMI rel
|
|
break;
|
|
case 0x10: // BPL rel
|
|
break;
|
|
case 0x2E: // CBNE dp, rel
|
|
break;
|
|
case 0xDE: // CBNE dp+X, rel
|
|
break;
|
|
case 0x6E: // DBNZ dp, rel
|
|
break;
|
|
case 0xFE: // DBNZ Y, rel
|
|
break;
|
|
case 0x5F: // JMP !abs
|
|
break;
|
|
case 0x1F: // JMP [!abs+X]
|
|
break;
|
|
|
|
// . subroutines
|
|
|
|
case 0x3F: // CALL !abs
|
|
break;
|
|
case 0x4F: // PCALL up
|
|
break;
|
|
case 0x6F: // RET
|
|
break;
|
|
case 0x7F: // RETI
|
|
break;
|
|
|
|
// . stack
|
|
|
|
case 0x2D: // PUSH A
|
|
break;
|
|
case 0x4D: // PUSH X
|
|
break;
|
|
case 0x6D: // PUSH Y
|
|
break;
|
|
case 0x0D: // PUSH PSW
|
|
break;
|
|
case 0xAE: // POP A
|
|
break;
|
|
case 0xCE: // POP X
|
|
break;
|
|
case 0xEE: // POP Y
|
|
break;
|
|
case 0x8E: // POP PSW
|
|
break;
|
|
|
|
// . memory bit operations
|
|
|
|
case 0xEA: // NOT1 abs, bit
|
|
break;
|
|
case 0xAA: // MOV1 C, abs, bit
|
|
break;
|
|
case 0xCA: // MOV1 abs, bit, C
|
|
break;
|
|
case 0x4A: // AND1 C, abs, bit
|
|
break;
|
|
case 0x6A: // AND1 C, /abs, bit
|
|
break;
|
|
case 0x0A: // OR1 C, abs, bit
|
|
break;
|
|
case 0x2A: // OR1 C, /abs, bit
|
|
break;
|
|
case 0x8A: // EOR1 C, abs, bit
|
|
break;
|
|
|
|
// . status flags
|
|
|
|
case 0x60: // CLRC
|
|
break;
|
|
case 0x80: // SETC
|
|
break;
|
|
case 0xED: // NOTC
|
|
break;
|
|
case 0xE0: // CLRV
|
|
break;
|
|
case 0x20: // CLRP
|
|
break;
|
|
case 0x40: // SETP
|
|
break;
|
|
case 0xA0: // EI
|
|
break;
|
|
case 0xC0: // DI
|
|
break;
|
|
|
|
// .no-operation and halt
|
|
|
|
case 0x00: // NOP
|
|
break;
|
|
case 0xEF: // SLEEP
|
|
break;
|
|
case 0x0F: // STOP
|
|
break;
|
|
|
|
default:
|
|
std::cout << "Unknown opcode: " << std::hex << opcode << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
|
|
} // namespace emu
|
|
} // namespace app
|
|
} // namespace yaze
|