mirror of
https://github.com/TomHarte/CLK.git
synced 2024-07-02 20:30:00 +00:00
145 lines
3.8 KiB
C++
145 lines
3.8 KiB
C++
//
|
|
// Executor.h
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 16/01/21.
|
|
// Copyright © 2021 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#ifndef Executor_h
|
|
#define Executor_h
|
|
|
|
#include "Instruction.hpp"
|
|
#include "Parser.hpp"
|
|
#include "../CachingExecutor.hpp"
|
|
#include "../../ClockReceiver/ClockReceiver.hpp"
|
|
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
namespace InstructionSet {
|
|
namespace M50740 {
|
|
|
|
class Executor;
|
|
using CachingExecutor = CachingExecutor<Executor, 0x1fff, 255, Instruction, false>;
|
|
|
|
/*!
|
|
Executes M50740 code subject to heavy limitations:
|
|
|
|
* the instruction stream cannot run across any of the specialised IO addresses; and
|
|
* timing is correct to whole-opcode boundaries only.
|
|
*/
|
|
class Executor: public CachingExecutor {
|
|
public:
|
|
Executor();
|
|
void set_rom(const std::vector<uint8_t> &rom);
|
|
void reset();
|
|
|
|
/*!
|
|
Runs, in discrete steps, the minimum number of instructions as it takes to complete at least @c cycles.
|
|
*/
|
|
void run_for(Cycles cycles);
|
|
|
|
private:
|
|
// MARK: - CachingExecutor-facing interface.
|
|
|
|
friend CachingExecutor;
|
|
|
|
/*!
|
|
Maps instructions to performers; called by the CachingExecutor and for this instruction set, extremely trivial.
|
|
*/
|
|
inline PerformerIndex action_for(Instruction instruction) {
|
|
// This is a super-simple processor, so the opcode can be used directly to index the performers.
|
|
return instruction.opcode;
|
|
}
|
|
|
|
/*!
|
|
Parses from @c start and no later than @c max_address, using the CachingExecutor as a target.
|
|
*/
|
|
inline void parse(uint16_t start, uint16_t closing_bound) {
|
|
Parser<Executor, false> parser;
|
|
parser.parse(*this, memory_, start & 0x1fff, closing_bound);
|
|
}
|
|
|
|
private:
|
|
// MARK: - Internal framework for generator performers.
|
|
|
|
/*!
|
|
Provides dynamic lookup of @c perform(Executor*).
|
|
*/
|
|
class PerformerLookup {
|
|
public:
|
|
PerformerLookup() {
|
|
fill<int(MinOperation)>(performers_);
|
|
}
|
|
|
|
Performer performer(Operation operation, AddressingMode addressing_mode) {
|
|
const auto index =
|
|
(int(operation) - MinOperation) * (1 + MaxAddressingMode - MinAddressingMode) +
|
|
(int(addressing_mode) - MinAddressingMode);
|
|
return performers_[index];
|
|
}
|
|
|
|
private:
|
|
Performer performers_[(1 + MaxAddressingMode - MinAddressingMode) * (1 + MaxOperation - MinOperation)];
|
|
|
|
template<int operation, int addressing_mode> void fill_operation(Performer *target) {
|
|
*target = &Executor::perform<Operation(operation), AddressingMode(addressing_mode)>;
|
|
|
|
if constexpr (addressing_mode+1 <= MaxAddressingMode) {
|
|
fill_operation<operation, addressing_mode+1>(target + 1);
|
|
}
|
|
}
|
|
|
|
template<int operation> void fill(Performer *target) {
|
|
fill_operation<operation, int(MinAddressingMode)>(target);
|
|
target += 1 + MaxAddressingMode - MinAddressingMode;
|
|
|
|
if constexpr (operation+1 <= MaxOperation) {
|
|
fill<operation+1>(target);
|
|
}
|
|
}
|
|
};
|
|
inline static PerformerLookup performer_lookup_;
|
|
|
|
/*!
|
|
Performs @c operation using @c operand as the value fetched from memory, if any.
|
|
*/
|
|
template <Operation operation> void perform(uint8_t *operand);
|
|
|
|
/*!
|
|
Performs @c operation in @c addressing_mode.
|
|
*/
|
|
template <Operation operation, AddressingMode addressing_mode> void perform();
|
|
|
|
private:
|
|
// MARK: - Instruction set state.
|
|
|
|
// Memory.
|
|
uint8_t memory_[0x2000];
|
|
|
|
// Registers.
|
|
uint8_t a_, x_, y_, s_;
|
|
|
|
uint8_t negative_result_ = 0;
|
|
uint8_t zero_result_ = 0;
|
|
uint8_t interrupt_disable_ = 0;
|
|
uint8_t carry_flag_ = 0;
|
|
uint8_t overflow_result_;
|
|
bool index_mode_ = false;
|
|
bool decimal_mode_ = false;
|
|
|
|
inline uint8_t read(uint16_t address);
|
|
inline void write(uint16_t address, uint8_t value);
|
|
inline void push(uint8_t value);
|
|
inline uint8_t pull();
|
|
inline void set_flags(uint8_t);
|
|
inline uint8_t flags();
|
|
template<bool is_brk> inline void perform_interrupt();
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif /* Executor_h */
|