6502/EightBit
1
0
Fork 0
mirror of https://github.com/MoleskiCoder/EightBit.git synced 2024-06-26 04:29:26 +00:00
Code Issues Projects Releases Wiki Activity

More "noexcept" specifiers added to M6502 class

Browse Source
This commit is contained in:
Adrian Conlon 2022-01-24 23:00:25 +00:00
parent 1796d62517
commit 1a5df4c8a7
2 changed files with 71 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
M6502/inc/mos6502.h
View File

@ -74,7 +74,7 @@ namespace EightBit {
void handleNMI() noexcept; void handleNMI() noexcept;
void handleSO() noexcept; void handleSO() noexcept;
void interrupt(); void interrupt() noexcept;
void push(uint8_t value) noexcept final; void push(uint8_t value) noexcept final;
[[nodiscard]] uint8_t pop() noexcept final; [[nodiscard]] uint8_t pop() noexcept final;
@ -84,31 +84,31 @@ namespace EightBit {
// Addressing modes // Addressing modes
[[nodiscard]] register16_t Address_Absolute(); [[nodiscard]] register16_t Address_Absolute() noexcept;
[[nodiscard]] uint8_t Address_ZeroPage(); [[nodiscard]] uint8_t Address_ZeroPage() noexcept;
[[nodiscard]] register16_t Address_ZeroPageIndirect(); [[nodiscard]] register16_t Address_ZeroPageIndirect() noexcept;
[[nodiscard]] register16_t Address_Indirect(); [[nodiscard]] register16_t Address_Indirect() noexcept;
[[nodiscard]] uint8_t Address_ZeroPageX(); [[nodiscard]] uint8_t Address_ZeroPageX() noexcept;
[[nodiscard]] uint8_t Address_ZeroPageY(); [[nodiscard]] uint8_t Address_ZeroPageY() noexcept;
[[nodiscard]] std::pair<register16_t, uint8_t> Address_AbsoluteX(); [[nodiscard]] std::pair<register16_t, uint8_t> Address_AbsoluteX() noexcept;
[[nodiscard]] std::pair<register16_t, uint8_t> Address_AbsoluteY(); [[nodiscard]] std::pair<register16_t, uint8_t> Address_AbsoluteY() noexcept;
[[nodiscard]] register16_t Address_IndexedIndirectX(); [[nodiscard]] register16_t Address_IndexedIndirectX() noexcept;
[[nodiscard]] std::pair<register16_t, uint8_t> Address_IndirectIndexedY(); [[nodiscard]] std::pair<register16_t, uint8_t> Address_IndirectIndexedY() noexcept;
[[nodiscard]] register16_t Address_relative_byte(); [[nodiscard]] register16_t Address_relative_byte() noexcept;
// Addressing modes, read // Addressing modes, read
enum class PageCrossingBehavior { AlwaysReadTwice, MaybeReadTwice }; enum class PageCrossingBehavior { AlwaysReadTwice, MaybeReadTwice };
uint8_t AM_Immediate(); uint8_t AM_Immediate() noexcept;
uint8_t AM_Absolute(); uint8_t AM_Absolute() noexcept;
uint8_t AM_ZeroPage(); uint8_t AM_ZeroPage() noexcept;
uint8_t AM_AbsoluteX(PageCrossingBehavior behaviour = PageCrossingBehavior::MaybeReadTwice); uint8_t AM_AbsoluteX(PageCrossingBehavior behaviour = PageCrossingBehavior::MaybeReadTwice) noexcept;
uint8_t AM_AbsoluteY(); uint8_t AM_AbsoluteY() noexcept;
uint8_t AM_ZeroPageX(); uint8_t AM_ZeroPageX() noexcept;
uint8_t AM_ZeroPageY(); uint8_t AM_ZeroPageY() noexcept;
uint8_t AM_IndexedIndirectX(); uint8_t AM_IndexedIndirectX() noexcept;
uint8_t AM_IndirectIndexedY(); uint8_t AM_IndirectIndexedY() noexcept;
// Flag checking // Flag checking
@ -139,14 +139,14 @@ namespace EightBit {
// Miscellaneous // Miscellaneous
void branch(int condition); void branch(int condition) noexcept;
[[nodiscard]] constexpr auto through(const uint8_t data) noexcept { [[nodiscard]] constexpr auto through(const uint8_t data) noexcept {
adjustNZ(data); adjustNZ(data);
return data; return data;
} }
void memoryReadModifyWrite(const uint8_t data) { void memoryReadModifyWrite(const uint8_t data) noexcept {
// The read will have already taken place... // The read will have already taken place...
memoryWrite(); memoryWrite();
memoryWrite(data); memoryWrite(data);
@ -161,15 +161,15 @@ namespace EightBit {
[[nodiscard]] uint8_t dec(uint8_t value) noexcept; [[nodiscard]] uint8_t dec(uint8_t value) noexcept;
[[nodiscard]] uint8_t eorr(uint8_t operand, uint8_t data) noexcept; [[nodiscard]] uint8_t eorr(uint8_t operand, uint8_t data) noexcept;
[[nodiscard]] uint8_t inc(uint8_t value) noexcept; [[nodiscard]] uint8_t inc(uint8_t value) noexcept;
void jsr(); void jsr() noexcept;
[[nodiscard]] uint8_t lsr(uint8_t value) noexcept; [[nodiscard]] uint8_t lsr(uint8_t value) noexcept;
[[nodiscard]] uint8_t orr(uint8_t operand, uint8_t data) noexcept; [[nodiscard]] uint8_t orr(uint8_t operand, uint8_t data) noexcept;
void php(); void php() noexcept;
void plp(); void plp() noexcept;
[[nodiscard]] uint8_t rol(uint8_t operand) noexcept; [[nodiscard]] uint8_t rol(uint8_t operand) noexcept;
[[nodiscard]] uint8_t ror(uint8_t operand) noexcept; [[nodiscard]] uint8_t ror(uint8_t operand) noexcept;
void rti(); void rti() noexcept;
void rts(); void rts() noexcept;
// Undocumented compound instructions // Undocumented compound instructions
@ -177,17 +177,17 @@ namespace EightBit {
void arr(uint8_t value) noexcept; void arr(uint8_t value) noexcept;
void asr(uint8_t value) noexcept; void asr(uint8_t value) noexcept;
void axs(uint8_t value) noexcept; void axs(uint8_t value) noexcept;
void dcp(uint8_t value); void dcp(uint8_t value) noexcept;
void isb(uint8_t value); void isb(uint8_t value) noexcept;
void rla(uint8_t value); void rla(uint8_t value) noexcept;
void rra(uint8_t value); void rra(uint8_t value) noexcept;
void slo(uint8_t value); void slo(uint8_t value) noexcept;
void sre(uint8_t value); void sre(uint8_t value) noexcept;
// Complicated addressing mode implementations // Complicated addressing mode implementations
void sta_AbsoluteX(); void sta_AbsoluteX() noexcept;
void sta_AbsoluteY(); void sta_AbsoluteY() noexcept;
uint8_t x = 0; // index register X uint8_t x = 0; // index register X
uint8_t y = 0; // index register Y uint8_t y = 0; // index register Y

70
M6502/src/mos6502.cpp
View File

@ -70,7 +70,7 @@ void EightBit::MOS6502::handleINT() noexcept {
opcode() = 0x00; // BRK opcode() = 0x00; // BRK
} }
void EightBit::MOS6502::interrupt() { void EightBit::MOS6502::interrupt() noexcept {
const bool reset = m_handlingRESET; const bool reset = m_handlingRESET;
const bool nmi = m_handlingNMI; const bool nmi = m_handlingNMI;
const bool irq = m_handlingINT; const bool irq = m_handlingINT;
@ -407,76 +407,76 @@ void EightBit::MOS6502::dummyPush(const uint8_t value) noexcept {
//// ////
EightBit::register16_t EightBit::MOS6502::Address_Absolute() { EightBit::register16_t EightBit::MOS6502::Address_Absolute() noexcept {
return fetchWord(); return fetchWord();
} }
uint8_t EightBit::MOS6502::Address_ZeroPage() { uint8_t EightBit::MOS6502::Address_ZeroPage() noexcept {
return fetchByte(); return fetchByte();
} }
EightBit::register16_t EightBit::MOS6502::Address_ZeroPageIndirect() { EightBit::register16_t EightBit::MOS6502::Address_ZeroPageIndirect() noexcept {
return getWordPaged(0, Address_ZeroPage()); return getWordPaged(0, Address_ZeroPage());
} }
EightBit::register16_t EightBit::MOS6502::Address_Indirect() { EightBit::register16_t EightBit::MOS6502::Address_Indirect() noexcept {
const auto address = Address_Absolute(); const auto address = Address_Absolute();
return getWordPaged(address.high, address.low); return getWordPaged(address.high, address.low);
} }
uint8_t EightBit::MOS6502::Address_ZeroPageX() { uint8_t EightBit::MOS6502::Address_ZeroPageX() noexcept {
const auto address = Address_ZeroPage(); const auto address = Address_ZeroPage();
memoryRead(address); memoryRead(address);
return address + X(); return address + X();
} }
uint8_t EightBit::MOS6502::Address_ZeroPageY() { uint8_t EightBit::MOS6502::Address_ZeroPageY() noexcept {
const auto address = Address_ZeroPage(); const auto address = Address_ZeroPage();
memoryRead(address); memoryRead(address);
return address + Y(); return address + Y();
} }
std::pair<EightBit::register16_t, uint8_t> EightBit::MOS6502::Address_AbsoluteX() { std::pair<EightBit::register16_t, uint8_t> EightBit::MOS6502::Address_AbsoluteX() noexcept {
const auto address = Address_Absolute(); const auto address = Address_Absolute();
const auto page = address.high; const auto page = address.high;
return { address + X(), page }; return { address + X(), page };
} }
std::pair<EightBit::register16_t, uint8_t> EightBit::MOS6502::Address_AbsoluteY() { std::pair<EightBit::register16_t, uint8_t> EightBit::MOS6502::Address_AbsoluteY() noexcept {
const auto address = Address_Absolute(); const auto address = Address_Absolute();
const auto page = address.high; const auto page = address.high;
return { address + Y(), page }; return { address + Y(), page };
} }
EightBit::register16_t EightBit::MOS6502::Address_IndexedIndirectX() { EightBit::register16_t EightBit::MOS6502::Address_IndexedIndirectX() noexcept {
return getWordPaged(0, Address_ZeroPageX()); return getWordPaged(0, Address_ZeroPageX());
} }
std::pair<EightBit::register16_t, uint8_t> EightBit::MOS6502::Address_IndirectIndexedY() { std::pair<EightBit::register16_t, uint8_t> EightBit::MOS6502::Address_IndirectIndexedY() noexcept {
const auto address = Address_ZeroPageIndirect(); const auto address = Address_ZeroPageIndirect();
const auto page = address.high; const auto page = address.high;
return { address + Y(), page }; return { address + Y(), page };
} }
EightBit::register16_t EightBit::MOS6502::Address_relative_byte() { EightBit::register16_t EightBit::MOS6502::Address_relative_byte() noexcept {
return PC() + (int8_t)fetchByte(); return PC() + (int8_t)fetchByte();
} }
// Addressing modes, read // Addressing modes, read
uint8_t EightBit::MOS6502::AM_Immediate() { uint8_t EightBit::MOS6502::AM_Immediate() noexcept {
return fetchByte(); return fetchByte();
} }
uint8_t EightBit::MOS6502::AM_Absolute() { uint8_t EightBit::MOS6502::AM_Absolute() noexcept {
return memoryRead(Address_Absolute()); return memoryRead(Address_Absolute());
} }
uint8_t EightBit::MOS6502::AM_ZeroPage() { uint8_t EightBit::MOS6502::AM_ZeroPage() noexcept {
return memoryRead(Address_ZeroPage()); return memoryRead(Address_ZeroPage());
} }
uint8_t EightBit::MOS6502::AM_AbsoluteX(const PageCrossingBehavior behaviour) { uint8_t EightBit::MOS6502::AM_AbsoluteX(const PageCrossingBehavior behaviour) noexcept {
const auto [address, page] = Address_AbsoluteX(); const auto [address, page] = Address_AbsoluteX();
auto possible = getBytePaged(page, address.low); auto possible = getBytePaged(page, address.low);
if ((behaviour == PageCrossingBehavior::AlwaysReadTwice) || UNLIKELY(page != address.high)) if ((behaviour == PageCrossingBehavior::AlwaysReadTwice) || UNLIKELY(page != address.high))
@ -484,7 +484,7 @@ uint8_t EightBit::MOS6502::AM_AbsoluteX(const PageCrossingBehavior behaviour) {
return possible; return possible;
} }
uint8_t EightBit::MOS6502::AM_AbsoluteY() { uint8_t EightBit::MOS6502::AM_AbsoluteY() noexcept {
const auto [address, page] = Address_AbsoluteY(); const auto [address, page] = Address_AbsoluteY();
auto possible = getBytePaged(page, address.low); auto possible = getBytePaged(page, address.low);
if (UNLIKELY(page != address.high)) if (UNLIKELY(page != address.high))
@ -492,19 +492,19 @@ uint8_t EightBit::MOS6502::AM_AbsoluteY() {
return possible; return possible;
} }
uint8_t EightBit::MOS6502::AM_ZeroPageX() { uint8_t EightBit::MOS6502::AM_ZeroPageX() noexcept {
return memoryRead(Address_ZeroPageX()); return memoryRead(Address_ZeroPageX());
} }
uint8_t EightBit::MOS6502::AM_ZeroPageY() { uint8_t EightBit::MOS6502::AM_ZeroPageY() noexcept {
return memoryRead(Address_ZeroPageY()); return memoryRead(Address_ZeroPageY());
} }
uint8_t EightBit::MOS6502::AM_IndexedIndirectX() { uint8_t EightBit::MOS6502::AM_IndexedIndirectX() noexcept {
return memoryRead(Address_IndexedIndirectX()); return memoryRead(Address_IndexedIndirectX());
} }
uint8_t EightBit::MOS6502::AM_IndirectIndexedY() { uint8_t EightBit::MOS6502::AM_IndirectIndexedY() noexcept {
const auto [address, page] = Address_IndirectIndexedY(); const auto [address, page] = Address_IndirectIndexedY();
auto possible = getBytePaged(page, address.low); auto possible = getBytePaged(page, address.low);
if (page != address.high) if (page != address.high)
@ -514,7 +514,7 @@ uint8_t EightBit::MOS6502::AM_IndirectIndexedY() {
//// ////
void EightBit::MOS6502::branch(const int condition) { void EightBit::MOS6502::branch(const int condition) noexcept {
const auto destination = Address_relative_byte(); const auto destination = Address_relative_byte();
if (condition) { if (condition) {
memoryRead(PC()); memoryRead(PC());
@ -639,7 +639,7 @@ uint8_t EightBit::MOS6502::inc(const uint8_t value) noexcept {
return through(value + 1); return through(value + 1);
} }
void EightBit::MOS6502::jsr() { void EightBit::MOS6502::jsr() noexcept {
const auto low = fetchByte(); const auto low = fetchByte();
getBytePaged(1, S()); // dummy read getBytePaged(1, S()); // dummy read
pushWord(PC()); pushWord(PC());
@ -656,11 +656,11 @@ uint8_t EightBit::MOS6502::orr(const uint8_t operand, const uint8_t data) noexce
return through(operand | data); return through(operand | data);
} }
void EightBit::MOS6502::php() { void EightBit::MOS6502::php() noexcept {
push(P() | BF); push(P() | BF);
} }
void EightBit::MOS6502::plp() { void EightBit::MOS6502::plp() noexcept {
P() = (pop() | RF) & ~BF; P() = (pop() | RF) & ~BF;
} }
@ -678,13 +678,13 @@ uint8_t EightBit::MOS6502::ror(const uint8_t operand) noexcept {
return through(result); return through(result);
} }
void EightBit::MOS6502::rti() { void EightBit::MOS6502::rti() noexcept {
getBytePaged(1, S()); // dummy read getBytePaged(1, S()); // dummy read
plp(); plp();
ret(); ret();
} }
void EightBit::MOS6502::rts() { void EightBit::MOS6502::rts() noexcept {
getBytePaged(1, S()); // dummy read getBytePaged(1, S()); // dummy read
ret(); ret();
fetchByte(); fetchByte();
@ -714,45 +714,45 @@ void EightBit::MOS6502::axs(const uint8_t value) noexcept {
P() = clearBit(P(), CF, m_intermediate.high); P() = clearBit(P(), CF, m_intermediate.high);
} }
void EightBit::MOS6502::dcp(const uint8_t value) { void EightBit::MOS6502::dcp(const uint8_t value) noexcept {
memoryReadModifyWrite(dec(value)); memoryReadModifyWrite(dec(value));
cmp(A(), BUS().DATA()); cmp(A(), BUS().DATA());
} }
void EightBit::MOS6502::isb(const uint8_t value) { void EightBit::MOS6502::isb(const uint8_t value) noexcept {
memoryReadModifyWrite(inc(value)); memoryReadModifyWrite(inc(value));
A() = sbc(A(), BUS().DATA()); A() = sbc(A(), BUS().DATA());
} }
void EightBit::MOS6502::rla(const uint8_t value) { void EightBit::MOS6502::rla(const uint8_t value) noexcept {
memoryReadModifyWrite(rol(value)); memoryReadModifyWrite(rol(value));
A() = andr(A(), BUS().DATA()); A() = andr(A(), BUS().DATA());
} }
void EightBit::MOS6502::rra(const uint8_t value) { void EightBit::MOS6502::rra(const uint8_t value) noexcept {
memoryReadModifyWrite(ror(value)); memoryReadModifyWrite(ror(value));
A() = adc(A(), BUS().DATA()); A() = adc(A(), BUS().DATA());
} }
void EightBit::MOS6502::slo(const uint8_t value) { void EightBit::MOS6502::slo(const uint8_t value) noexcept {
memoryReadModifyWrite(asl(value)); memoryReadModifyWrite(asl(value));
A() = orr(A(), BUS().DATA()); A() = orr(A(), BUS().DATA());
} }
void EightBit::MOS6502::sre(const uint8_t value) { void EightBit::MOS6502::sre(const uint8_t value) noexcept {
memoryReadModifyWrite(lsr(value)); memoryReadModifyWrite(lsr(value));
A() = eorr(A(), BUS().DATA()); A() = eorr(A(), BUS().DATA());
} }
// //
void EightBit::MOS6502::sta_AbsoluteX() { void EightBit::MOS6502::sta_AbsoluteX() noexcept {
const auto [address, page] = Address_AbsoluteX(); const auto [address, page] = Address_AbsoluteX();
getBytePaged(page, address.low); getBytePaged(page, address.low);
memoryWrite(address, A()); memoryWrite(address, A());
} }
void EightBit::MOS6502::sta_AbsoluteY() { void EightBit::MOS6502::sta_AbsoluteY() noexcept {
const auto [address, page] = Address_AbsoluteY(); const auto [address, page] = Address_AbsoluteY();
getBytePaged(page, address.low); getBytePaged(page, address.low);
memoryWrite(address, A()); memoryWrite(address, A());