From 887b89308a34cb0bb4cfaae4957bba30dc19b94b Mon Sep 17 00:00:00 2001 From: Adrian Conlon Date: Sun, 25 Nov 2018 10:43:51 +0000 Subject: [PATCH] Ensure virtual methods are no longer defined inline. Signed-off-by: Adrian Conlon --- inc/IntelProcessor.h | 5 +---- inc/Memory.h | 5 +---- inc/Processor.h | 6 ++---- inc/Ram.h | 13 +++---------- inc/Register.h | 2 +- inc/Rom.h | 33 +++++++-------------------------- inc/UnusedMemory.h | 30 ++++++++++++------------------ src/IntelProcessor.cpp | 5 +++++ src/Memory.cpp | 8 ++++++++ src/Processor.cpp | 4 ++++ src/Ram.cpp | 13 +++++++++++++ src/Rom.cpp | 32 ++++++++++++++++++++++++++++++++ src/UnusedMemory.cpp | 29 +++++++++++++++++++++++++++++ 13 files changed, 118 insertions(+), 67 deletions(-) create mode 100644 src/Memory.cpp create mode 100644 src/Ram.cpp create mode 100644 src/UnusedMemory.cpp diff --git a/inc/IntelProcessor.h b/inc/IntelProcessor.h index 2a0051f..c6cec4b 100644 --- a/inc/IntelProcessor.h +++ b/inc/IntelProcessor.h @@ -162,10 +162,7 @@ namespace EightBit { return !!condition; } - virtual void ret() final { - Processor::ret(); - MEMPTR() = PC(); - } + virtual void ret() final; private: std::array m_decodedOpcodes; diff --git a/inc/Memory.h b/inc/Memory.h index 590a89e..2995550 100644 --- a/inc/Memory.h +++ b/inc/Memory.h @@ -2,7 +2,6 @@ #include #include -#include #include #include @@ -20,9 +19,7 @@ namespace EightBit { virtual size_t size() const = 0; virtual uint8_t peek(uint16_t address) const = 0; - virtual uint8_t& reference(uint16_t) { - throw new std::logic_error("Reference operation not allowed."); - } + virtual uint8_t& reference(uint16_t); virtual int load(std::ifstream& file, int writeOffset = 0, int readOffset = 0, int limit = -1) = 0; virtual int load(const std::string& path, int writeOffset = 0, int readOffset = 0, int limit = -1) = 0; diff --git a/inc/Processor.h b/inc/Processor.h index 3862de6..bfd72b5 100644 --- a/inc/Processor.h +++ b/inc/Processor.h @@ -71,7 +71,7 @@ namespace EightBit { virtual void push(uint8_t value) = 0; virtual uint8_t pop() = 0; - virtual void pushWord(const register16_t value) = 0; + virtual void pushWord(register16_t value) = 0; virtual register16_t popWord() = 0; auto getWord(const register16_t address) { @@ -93,9 +93,7 @@ namespace EightBit { jump(destination); } - virtual void ret() { - jump(popWord()); - } + virtual void ret(); void resetCycles() { m_cycles = 0; } void addCycles(const int extra) { m_cycles += extra; } diff --git a/inc/Ram.h b/inc/Ram.h index 66214eb..e44f6b1 100644 --- a/inc/Ram.h +++ b/inc/Ram.h @@ -9,16 +9,9 @@ namespace EightBit { // it's externally 'reference'able and 'poke'able. class Ram : public Rom { public: - Ram(const size_t size = 0) noexcept - : Rom(size) { - } + Ram(size_t size = 0) noexcept; - virtual uint8_t& reference(const uint16_t address) final { - return BYTES()[address]; - } - - virtual void poke(const uint16_t address, const uint8_t value) final { - Rom::poke(address, value); - } + virtual uint8_t& reference(uint16_t address) final; + virtual void poke(uint16_t address, uint8_t value) final; }; } diff --git a/inc/Register.h b/inc/Register.h index 6af0939..766c972 100644 --- a/inc/Register.h +++ b/inc/Register.h @@ -20,7 +20,7 @@ #endif namespace EightBit { - union register16_t { + union register16_t final { struct { #ifdef HOST_LITTLE_ENDIAN uint8_t low; diff --git a/inc/Rom.h b/inc/Rom.h index c27c42e..3c0c36d 100644 --- a/inc/Rom.h +++ b/inc/Rom.h @@ -19,39 +19,20 @@ namespace EightBit { const auto& BYTES() const { return m_bytes; } auto& BYTES() { return m_bytes; } - virtual void poke(const uint16_t address, const uint8_t value) override { - BYTES()[address] = value; - } + virtual void poke(uint16_t address, uint8_t value) override; public: static int load(std::ifstream& file, std::vector& output, int writeOffset = 0, int readOffset = 0, int limit = -1, int maximumSize = -1); static int load(const std::string& path, std::vector& output, int writeOffset = 0, int readOffset = 0, int limit = -1, int maximumSize = -1); - Rom(const size_t size = 0) noexcept - : m_bytes(size) { - } + Rom(size_t size = 0) noexcept; - virtual size_t size() const final { return m_bytes.size(); } + virtual size_t size() const final; - virtual int load(std::ifstream& file, const int writeOffset = 0, const int readOffset = 0, const int limit = -1) final { - const auto maximumSize = (int)size() - writeOffset; - return load(file, m_bytes, writeOffset, readOffset, limit, maximumSize); - } + virtual int load(std::ifstream& file, int writeOffset = 0, int readOffset = 0, int limit = -1) final; + virtual int load(const std::string& path, int writeOffset = 0, int readOffset = 0, int limit = -1) final; + virtual int load(const std::vector& bytes, int writeOffset = 0, int readOffset = 0, int limit = -1) final; - virtual int load(const std::string& path, const int writeOffset = 0, const int readOffset = 0, const int limit = -1) final { - const auto maximumSize = (int)size() - writeOffset; - return load(path, m_bytes, writeOffset, readOffset, limit, maximumSize); - } - - virtual int load(const std::vector& bytes, const int writeOffset = 0, const int readOffset = 0, int limit = -1) final { - if (limit < 0) - limit = (int)bytes.size() - readOffset; - std::copy(bytes.cbegin() + readOffset, bytes.cbegin() + limit, m_bytes.begin() + writeOffset); - return limit; - } - - virtual uint8_t peek(const uint16_t address) const final { - return BYTES()[address]; - } + virtual uint8_t peek(uint16_t address) const final; }; } diff --git a/inc/UnusedMemory.h b/inc/UnusedMemory.h index 1824239..bd602a9 100644 --- a/inc/UnusedMemory.h +++ b/inc/UnusedMemory.h @@ -1,5 +1,10 @@ #pragma once +#include +#include +#include +#include + #include "Memory.h" namespace EightBit { @@ -8,29 +13,18 @@ namespace EightBit { // is being read. class UnusedMemory final : public Memory { public: - UnusedMemory(const size_t size, const uint8_t value) - : m_size(size), m_value(value) {} + UnusedMemory(size_t size, uint8_t value); virtual ~UnusedMemory() = default; - virtual size_t size() const final { return m_size; } - virtual uint8_t peek(uint16_t address) const final { return m_value; } + virtual size_t size() const final; + virtual uint8_t peek(uint16_t address) const final; - virtual int load(std::ifstream& file, int writeOffset = 0, int readOffset = 0, int limit = -1) final { - throw new std::logic_error("load operation not allowed."); - } - - virtual int load(const std::string& path, int writeOffset = 0, int readOffset = 0, int limit = -1) final { - throw new std::logic_error("load operation not allowed."); - } - - virtual int load(const std::vector& bytes, int writeOffset = 0, int readOffset = 0, int limit = -1) final { - throw new std::logic_error("load operation not allowed."); - } + virtual int load(std::ifstream& file, int writeOffset = 0, int readOffset = 0, int limit = -1) final; + virtual int load(const std::string& path, int writeOffset = 0, int readOffset = 0, int limit = -1) final; + virtual int load(const std::vector& bytes, int writeOffset = 0, int readOffset = 0, int limit = -1) final; protected: - virtual void poke(uint16_t address, uint8_t value) { - throw new std::logic_error("Poke operation not allowed."); - } + virtual void poke(uint16_t address, uint8_t value) final; private: size_t m_size; diff --git a/src/IntelProcessor.cpp b/src/IntelProcessor.cpp index 69876af..5e3e93d 100644 --- a/src/IntelProcessor.cpp +++ b/src/IntelProcessor.cpp @@ -30,3 +30,8 @@ void EightBit::IntelProcessor::setWord(const register16_t value) { LittleEndianProcessor::setWord(value); MEMPTR() = BUS().ADDRESS(); } + +void EightBit::IntelProcessor::ret() { + Processor::ret(); + MEMPTR() = PC(); +} diff --git a/src/Memory.cpp b/src/Memory.cpp new file mode 100644 index 0000000..8a9ee20 --- /dev/null +++ b/src/Memory.cpp @@ -0,0 +1,8 @@ +#include "stdafx.h" +#include "Memory.h" + +#include + +uint8_t& EightBit::Memory::reference(uint16_t) { + throw new std::logic_error("Reference operation not allowed."); +} diff --git a/src/Processor.cpp b/src/Processor.cpp index 7bb58ba..342f4e6 100644 --- a/src/Processor.cpp +++ b/src/Processor.cpp @@ -39,3 +39,7 @@ int8_t EightBit::Processor::signExtend(const int b, uint8_t x) { const auto result = (x ^ m) - m; return result; } + +void EightBit::Processor::ret() { + jump(popWord()); +} diff --git a/src/Ram.cpp b/src/Ram.cpp new file mode 100644 index 0000000..7c6a78e --- /dev/null +++ b/src/Ram.cpp @@ -0,0 +1,13 @@ +#include "stdafx.h" +#include "Ram.h" + +EightBit::Ram::Ram(const size_t size) noexcept +: Rom(size) {} + +uint8_t& EightBit::Ram::reference(const uint16_t address) { + return BYTES()[address]; +} + +void EightBit::Ram::poke(const uint16_t address, const uint8_t value) { + Rom::poke(address, value); +} diff --git a/src/Rom.cpp b/src/Rom.cpp index 5eb3da7..80de6c5 100644 --- a/src/Rom.cpp +++ b/src/Rom.cpp @@ -36,3 +36,35 @@ int EightBit::Rom::load(const std::string& path, std::vector& output, c return size; } + +void EightBit::Rom::poke(const uint16_t address, const uint8_t value) { + BYTES()[address] = value; +} + +EightBit::Rom::Rom(const size_t size) noexcept +: m_bytes(size) {} + +size_t EightBit::Rom::size() const { + return m_bytes.size(); +} + +int EightBit::Rom::load(std::ifstream& file, const int writeOffset, const int readOffset, const int limit) { + const auto maximumSize = (int)size() - writeOffset; + return load(file, m_bytes, writeOffset, readOffset, limit, maximumSize); +} + +int EightBit::Rom::load(const std::string& path, const int writeOffset, const int readOffset, const int limit) { + const auto maximumSize = (int)size() - writeOffset; + return load(path, m_bytes, writeOffset, readOffset, limit, maximumSize); +} + +int EightBit::Rom::load(const std::vector& bytes, const int writeOffset, const int readOffset, int limit) { + if (limit < 0) + limit = (int)bytes.size() - readOffset; + std::copy(bytes.cbegin() + readOffset, bytes.cbegin() + limit, m_bytes.begin() + writeOffset); + return limit; +} + +uint8_t EightBit::Rom::peek(const uint16_t address) const { + return BYTES()[address]; +} diff --git a/src/UnusedMemory.cpp b/src/UnusedMemory.cpp new file mode 100644 index 0000000..a83938a --- /dev/null +++ b/src/UnusedMemory.cpp @@ -0,0 +1,29 @@ +#include "stdafx.h" +#include "UnusedMemory.h" + +EightBit::UnusedMemory::UnusedMemory(const size_t size, const uint8_t value) +: m_size(size), m_value(value) {} + +size_t EightBit::UnusedMemory::size() const { + return m_size; +} + +uint8_t EightBit::UnusedMemory::peek(uint16_t) const { + return m_value; +} + +int EightBit::UnusedMemory::load(std::ifstream&, int, int, int) { + throw new std::logic_error("load operation not allowed."); +} + +int EightBit::UnusedMemory::load(const std::string&, int, int, int) { + throw new std::logic_error("load operation not allowed."); +} + +int EightBit::UnusedMemory::load(const std::vector&, int, int, int) { + throw new std::logic_error("load operation not allowed."); +} + +void EightBit::UnusedMemory::poke(uint16_t, uint8_t) { + throw new std::logic_error("Poke operation not allowed."); +}