2020-09-24 02:14:42 +00:00
|
|
|
|
//
|
|
|
|
|
// 65816Implementation.hpp
|
|
|
|
|
// Clock Signal
|
|
|
|
|
//
|
|
|
|
|
// Created by Thomas Harte on 23/09/2020.
|
|
|
|
|
// Copyright © 2020 Thomas Harte. All rights reserved.
|
|
|
|
|
//
|
|
|
|
|
|
2020-09-25 02:27:20 +00:00
|
|
|
|
enum MicroOp: uint8_t {
|
|
|
|
|
/// Fetches a byte from the program counter to the instruction buffer and increments the program counter.
|
|
|
|
|
CycleFetchIncrementPC,
|
|
|
|
|
/// Fetches a byte from the program counter without incrementing it, and throws it away.
|
|
|
|
|
CycleFetchPC,
|
|
|
|
|
|
|
|
|
|
/// Fetches a byte from the data address to the data buffer.
|
|
|
|
|
CycleFetchData,
|
|
|
|
|
/// Fetches a byte from the data address to the data buffer and increments the data address.
|
|
|
|
|
CycleFetchIncrementData,
|
2020-09-26 01:16:36 +00:00
|
|
|
|
/// Fetches from the address formed by the low byte of the data address and the high byte
|
|
|
|
|
/// of the instruction buffer, throwing the result away.
|
|
|
|
|
CycleFetchIncorrectDataAddress,
|
2020-09-25 02:27:20 +00:00
|
|
|
|
|
2020-09-27 00:38:29 +00:00
|
|
|
|
/// Fetches a vector (i.e. IRQ, NMI, etc) into the data buffer.
|
|
|
|
|
CycleFetchVector,
|
|
|
|
|
|
2020-09-26 01:49:03 +00:00
|
|
|
|
// Dedicated block-move cycles; these use the data buffer as an intermediary.
|
|
|
|
|
CycleFetchBlockX,
|
|
|
|
|
CycleFetchBlockY,
|
|
|
|
|
CycleStoreBlockY,
|
|
|
|
|
|
2020-09-25 02:27:20 +00:00
|
|
|
|
/// Stores a byte from the data buffer.
|
|
|
|
|
CycleStoreData,
|
|
|
|
|
/// Stores a byte to the data address from the data buffer and increments the data address.
|
|
|
|
|
CycleStoreIncrementData,
|
|
|
|
|
/// Stores a byte to the data address from the data buffer and decrements the data address.
|
|
|
|
|
CycleStoreDecrementData,
|
|
|
|
|
|
|
|
|
|
/// Pushes a single byte from the data buffer to the stack.
|
|
|
|
|
CyclePush,
|
2020-09-25 22:35:00 +00:00
|
|
|
|
/// Fetches from the current stack location and throws the result away.
|
|
|
|
|
CycleAccessStack,
|
2020-09-27 00:38:29 +00:00
|
|
|
|
/// Pulls a single byte to the data buffer from the stack.
|
|
|
|
|
CyclePull,
|
2020-09-25 02:27:20 +00:00
|
|
|
|
|
|
|
|
|
/// Sets the data address by copying the final two bytes of the instruction buffer.
|
|
|
|
|
OperationConstructAbsolute,
|
2020-09-25 22:35:00 +00:00
|
|
|
|
/// Sets the data address to the result of (a, x).
|
|
|
|
|
/// TODO: explain better once implemented.
|
2020-09-25 02:27:20 +00:00
|
|
|
|
OperationConstructAbsoluteIndexedIndirect,
|
2020-09-25 23:27:17 +00:00
|
|
|
|
OperationConstructAbsoluteLongX,
|
2020-09-25 02:27:20 +00:00
|
|
|
|
|
2020-09-26 01:16:36 +00:00
|
|
|
|
/// Calculates an a, x address; if:
|
|
|
|
|
/// there was no carry into the top byte of the address; and
|
|
|
|
|
/// the process or in emulation or 8-bit index mode;
|
|
|
|
|
/// then it also skips the next micro-op.
|
|
|
|
|
OperationConstructAbsoluteXRead,
|
|
|
|
|
|
|
|
|
|
/// Calculates an a, x address.
|
|
|
|
|
OperationConstructAbsoluteX,
|
|
|
|
|
|
|
|
|
|
// These are analogous to the X versions above.
|
|
|
|
|
OperationConstructAbsoluteY,
|
|
|
|
|
OperationConstructAbsoluteYRead,
|
|
|
|
|
|
2020-09-26 02:01:36 +00:00
|
|
|
|
/// Constructs the current direct address using the value in the instruction buffer.
|
|
|
|
|
/// Skips the next micro-op if the low byte of the direct register is 0.
|
|
|
|
|
OperationConstructDirect,
|
|
|
|
|
|
2020-09-26 02:22:30 +00:00
|
|
|
|
// These follow similar skip-one-if-possible logic to OperationConstructDirect.
|
|
|
|
|
OperationConstructDirectIndexedIndirect,
|
|
|
|
|
OperationConstructDirectIndirect,
|
2020-09-26 20:55:58 +00:00
|
|
|
|
OperationConstructDirectIndirectIndexed,
|
|
|
|
|
OperationConstructDirectIndirectIndexedLong,
|
|
|
|
|
OperationConstructDirectIndirectLong,
|
2020-09-26 21:26:17 +00:00
|
|
|
|
OperationConstructDirectX,
|
|
|
|
|
OperationConstructDirectY,
|
2020-09-26 02:22:30 +00:00
|
|
|
|
|
2020-09-27 00:57:24 +00:00
|
|
|
|
OperationConstructPER,
|
2020-09-27 01:20:01 +00:00
|
|
|
|
OperationConstructBRK,
|
2020-09-27 00:57:24 +00:00
|
|
|
|
|
2020-09-27 01:35:31 +00:00
|
|
|
|
OperationConstructStackRelative,
|
|
|
|
|
OperationConstructStackRelativeIndexedIndirect,
|
|
|
|
|
|
2020-09-25 02:27:20 +00:00
|
|
|
|
/// Performs whatever operation goes with this program.
|
|
|
|
|
OperationPerform,
|
|
|
|
|
|
2020-09-25 02:37:31 +00:00
|
|
|
|
/// Copies the current program counter to the data buffer.
|
|
|
|
|
OperationCopyPCToData,
|
2020-09-26 21:42:42 +00:00
|
|
|
|
OperationCopyInstructionToData,
|
2020-09-25 02:37:31 +00:00
|
|
|
|
|
2020-09-25 22:35:00 +00:00
|
|
|
|
/// Copies the current PBR to the data buffer.
|
|
|
|
|
OperationCopyPBRToData,
|
|
|
|
|
|
2020-09-26 01:16:36 +00:00
|
|
|
|
OperationCopyAToData,
|
|
|
|
|
OperationCopyDataToA,
|
|
|
|
|
|
2020-09-27 00:38:29 +00:00
|
|
|
|
/// Fills the data buffer with three or four bytes, depending on emulation mode, containing the program
|
|
|
|
|
/// counter, flags and possibly the program bank. Also puts the appropriate vector address into the
|
|
|
|
|
/// address register.
|
|
|
|
|
OperationPrepareException,
|
|
|
|
|
|
2020-09-25 02:27:20 +00:00
|
|
|
|
/// Complete this set of micr-ops.
|
2020-09-28 02:20:58 +00:00
|
|
|
|
OperationMoveToNextProgram,
|
|
|
|
|
|
|
|
|
|
/// Inspects the instruction buffer and thereby selects the next set of micro-ops to schedule.
|
|
|
|
|
OperationDecode,
|
2020-09-25 02:27:20 +00:00
|
|
|
|
};
|
2020-09-24 02:23:23 +00:00
|
|
|
|
|
2020-09-25 21:18:25 +00:00
|
|
|
|
enum Operation: uint8_t {
|
|
|
|
|
// These perform the named operation using the value in the data buffer;
|
|
|
|
|
// they are implicitly AccessType::Read.
|
|
|
|
|
ADC, AND, BIT, CMP, CPX, CPY, EOR, ORA, SBC,
|
|
|
|
|
|
|
|
|
|
// These load the respective register from the data buffer;
|
|
|
|
|
// they are implicitly AccessType::Read.
|
|
|
|
|
LDA, LDX, LDY,
|
2020-09-27 00:38:29 +00:00
|
|
|
|
PLB, PLD, PLP, // LDA, LDX and LDY can be used for PLA, PLX, PLY.
|
2020-09-25 21:18:25 +00:00
|
|
|
|
|
|
|
|
|
// These move the respective register (or value) to the data buffer;
|
|
|
|
|
// they are implicitly AccessType::Write.
|
|
|
|
|
STA, STX, STY, STZ,
|
2020-09-27 00:38:29 +00:00
|
|
|
|
PHB, PHP, PHD, PHK,
|
2020-09-25 21:18:25 +00:00
|
|
|
|
|
2020-09-26 01:16:36 +00:00
|
|
|
|
// These modify the value in the data buffer as part of a read-modify-write.
|
|
|
|
|
ASL, DEC, INC, LSR, ROL, ROR, TRB, TSB,
|
|
|
|
|
|
2020-09-26 01:49:03 +00:00
|
|
|
|
// These merely decrement A, increment or decrement X and Y, and regress
|
|
|
|
|
// the program counter only if appropriate.
|
|
|
|
|
MVN, MVP,
|
|
|
|
|
|
2020-09-26 21:42:42 +00:00
|
|
|
|
// These use a value straight from the instruction buffer.
|
|
|
|
|
REP, SEP,
|
|
|
|
|
|
2020-09-27 00:24:50 +00:00
|
|
|
|
BCC, BCS, BEQ, BMI, BNE, BPL, BRA, BVC, BVS, BRL,
|
|
|
|
|
|
2020-09-26 21:42:42 +00:00
|
|
|
|
// These are all implicit.
|
|
|
|
|
CLC, CLD, CLI, CLV, DEX, DEY, INX, INY, NOP, SEC, SED, SEI,
|
|
|
|
|
TAX, TAY, TCD, TCS, TDC, TSC, TSX, TXA, TXS, TXY, TYA, TYX,
|
|
|
|
|
XCE, XBA,
|
|
|
|
|
|
2020-09-27 00:18:30 +00:00
|
|
|
|
STP, WAI,
|
|
|
|
|
|
2020-09-27 01:20:01 +00:00
|
|
|
|
// These unpack values from the data buffer, which has been filled
|
|
|
|
|
// from the stack.
|
|
|
|
|
RTI, RTL,
|
|
|
|
|
|
2020-09-25 21:18:25 +00:00
|
|
|
|
/// Loads the PC with the operand from the data buffer.
|
|
|
|
|
JMP,
|
|
|
|
|
|
2020-09-25 22:00:02 +00:00
|
|
|
|
/// Loads the PC and PBR with the operand from the data buffer.
|
|
|
|
|
JML,
|
|
|
|
|
|
2020-09-25 22:35:00 +00:00
|
|
|
|
/// Loads the PC with the operand from the data buffer, replacing
|
2020-09-25 21:18:25 +00:00
|
|
|
|
/// it with the old PC.
|
|
|
|
|
JSR,
|
2020-09-25 22:35:00 +00:00
|
|
|
|
|
|
|
|
|
/// Loads the PC and the PBR with the operand from the data buffer,
|
|
|
|
|
/// replacing it with the old PC (and only the PC; PBR not included).
|
|
|
|
|
JSL,
|
2020-09-27 01:20:01 +00:00
|
|
|
|
|
|
|
|
|
/// i.e. jump to vector. TODO: is this really distinct from JMP? I'm assuming so for now,
|
|
|
|
|
/// as I assume the PBR is implicitly modified. We'll see.
|
|
|
|
|
BRK,
|
2020-09-25 02:27:20 +00:00
|
|
|
|
};
|
2020-09-24 02:14:42 +00:00
|
|
|
|
|
2020-09-25 02:27:20 +00:00
|
|
|
|
class ProcessorStorageConstructor;
|
2020-09-24 02:14:42 +00:00
|
|
|
|
|
2020-09-28 02:20:58 +00:00
|
|
|
|
struct ProcessorStorage {
|
|
|
|
|
ProcessorStorage();
|
|
|
|
|
|
|
|
|
|
// Frustratingly, there is not quite enough space in 16 bits to store both
|
|
|
|
|
// the program offset and the operation as currently defined.
|
|
|
|
|
struct Instruction {
|
|
|
|
|
uint16_t program_offset;
|
|
|
|
|
Operation operation;
|
|
|
|
|
};
|
|
|
|
|
Instruction instructions[514]; // Arranged as:
|
|
|
|
|
// 256 entries: emulation-mode instructions;
|
|
|
|
|
// 256 entries: 16-bit instructions;
|
|
|
|
|
// the entry for 'exceptions' (i.e. reset, irq, nmi); and
|
|
|
|
|
// the entry for fetch-decode-execute.
|
|
|
|
|
|
|
|
|
|
enum class OperationSlot {
|
|
|
|
|
Exception = 512,
|
|
|
|
|
FetchDecodeExecute
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Registers.
|
|
|
|
|
RegisterPair16 a_;
|
|
|
|
|
RegisterPair16 x_, y_;
|
|
|
|
|
uint16_t pc_, s_;
|
|
|
|
|
|
2020-09-29 22:42:07 +00:00
|
|
|
|
// A helper for testing.
|
|
|
|
|
uint16_t last_operation_pc_;
|
|
|
|
|
Instruction *active_instruction_;
|
|
|
|
|
Cycles cycles_left_to_run_;
|
|
|
|
|
|
2020-09-28 02:20:58 +00:00
|
|
|
|
// I.e. the offset for direct addressing (outside of emulation mode).
|
2020-09-29 22:42:07 +00:00
|
|
|
|
uint16_t direct_ = 0;
|
2020-09-28 02:20:58 +00:00
|
|
|
|
|
|
|
|
|
// Banking registers are all stored with the relevant byte
|
|
|
|
|
// shifted up bits 16–23.
|
2020-09-29 22:42:07 +00:00
|
|
|
|
uint32_t data_bank_ = 0; // i.e. DBR.
|
|
|
|
|
uint32_t program_bank_ = 0; // i.e. PBR.
|
2020-09-28 02:20:58 +00:00
|
|
|
|
|
|
|
|
|
static constexpr int PowerOn = 1 << 0;
|
|
|
|
|
static constexpr int Reset = 1 << 1;
|
|
|
|
|
static constexpr int IRQ = 1 << 2;
|
|
|
|
|
static constexpr int NMI = 1 << 3;
|
2020-09-29 22:42:07 +00:00
|
|
|
|
int pending_exceptions_ = PowerOn; // By default.
|
2020-09-28 02:20:58 +00:00
|
|
|
|
|
2020-09-28 22:43:53 +00:00
|
|
|
|
/// Defines a four-byte buffer which can be cleared or filled in single-byte increments from least significant byte
|
|
|
|
|
/// to most significant.
|
|
|
|
|
struct Buffer {
|
|
|
|
|
uint32_t value = 0;
|
|
|
|
|
int size = 0;
|
|
|
|
|
|
|
|
|
|
void clear() {
|
|
|
|
|
value = 0;
|
|
|
|
|
size = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t *next() {
|
|
|
|
|
#if TARGET_RT_BIG_ENDIAN
|
|
|
|
|
uint8_t *const target = reinterpret_cast<uint8_t *>(&value) + (3 ^ size);
|
|
|
|
|
#else
|
|
|
|
|
uint8_t *const target = reinterpret_cast<uint8_t *>(&value) + size;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
++size;
|
|
|
|
|
return target;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
Buffer instruction_buffer_, data_buffer_;
|
|
|
|
|
|
2020-09-28 02:20:58 +00:00
|
|
|
|
std::vector<MicroOp> micro_ops_;
|
|
|
|
|
MicroOp *next_op_ = nullptr;
|
2020-09-24 02:14:42 +00:00
|
|
|
|
};
|