From c4b2b70d96a3702ea6ee0cd65db0ee58d3fcf65f Mon Sep 17 00:00:00 2001 From: jborza Date: Tue, 7 May 2019 21:04:04 +0200 Subject: [PATCH] refactored the read_word function to allow for wrap --- memory.c | 65 +++++++++++++++++++++++++----------------------------- memory.h | 2 ++ test6502.c | 1 - 3 files changed, 32 insertions(+), 36 deletions(-) diff --git a/memory.c b/memory.c index 8b69d8f..f412c34 100644 --- a/memory.c +++ b/memory.c @@ -11,105 +11,100 @@ word fetch_word(State6502* state) { return result; } -word read_word(State6502* state, word address) { - if ((address & 0xFF) == 0xFF) - { - return state->memory[address] | state->memory[address - 0xFF] << 8; - } - else { - return state->memory[address] | state->memory[address + 1] << 8; - } +word read_word(State6502 * state, word address) { + return state->memory[address] | state->memory[address + 1] << 8; } -word get_address_zero_page(State6502* state) { +word read_word_wrap(State6502 * state, word address) { + word address_low = address; + //page wraparound + word address_high = (address_low & 0xFF) == 0xFF ? address - 0xFF : address_low + 1; + return state->memory[address_low] | state->memory[address_high] << 8; +} + +word get_address_zero_page(State6502 * state) { return fetch_byte(state); } -byte get_byte_zero_page(State6502* state) { +byte get_byte_zero_page(State6502 * state) { //8 bit addressing, only the first 256 bytes of the memory return state->memory[get_address_zero_page(state)]; } -word get_address_zero_page_x(State6502* state) { +word get_address_zero_page_x(State6502 * state) { //address is zero page, so wraparound byte byte address = fetch_byte(state) + state->x; return address; } -byte get_byte_zero_page_x(State6502* state) { +byte get_byte_zero_page_x(State6502 * state) { return state->memory[get_address_zero_page_x(state)]; } -word get_address_zero_page_y(State6502* state) { +word get_address_zero_page_y(State6502 * state) { //address is zero page, so wraparound byte byte address = fetch_byte(state) + state->y; return address; } -byte get_byte_zero_page_y(State6502* state) { +byte get_byte_zero_page_y(State6502 * state) { return state->memory[get_address_zero_page_y(state)]; } -word get_address_absolute(State6502* state) { +word get_address_absolute(State6502 * state) { //absolute indexed, 16 bits word address = fetch_word(state); return address; } -byte get_byte_absolute(State6502* state) +byte get_byte_absolute(State6502 * state) { //absolute indexed, 16 bits return state->memory[get_address_absolute(state)]; } -word get_address_absolute_x(State6502* state) { +word get_address_absolute_x(State6502 * state) { //absolute added with the contents of x register word address = fetch_word(state) + state->x; return address; } -byte get_byte_absolute_x(State6502* state) { +byte get_byte_absolute_x(State6502 * state) { return state->memory[get_address_absolute_x(state)]; } -word get_address_absolute_y(State6502* state) { +word get_address_absolute_y(State6502 * state) { //absolute added with the contents of x register word address = fetch_word(state) + state->y; return address; } -byte get_byte_absolute_y(State6502* state) { +byte get_byte_absolute_y(State6502 * state) { //absolute added with the contents of y register return state->memory[get_address_absolute_y(state)]; } -word get_address_indirect_jmp(State6502* state) { - //AN INDIRECT JUMP MUST NEVER USE A VECTOR BEGINNING ON THE LAST BYTE OF A PAGE +word get_address_indirect_jmp(State6502 * state) { word indirect_address = fetch_word(state); - if ((indirect_address & 0xFF) == 0xFF) { - //avoid crossing the page boundary - return state->memory[indirect_address] | state->memory[indirect_address - 0xFF] << 8; - } - else { - return read_word(state, indirect_address); - } + //AN INDIRECT JUMP MUST NEVER USE A VECTOR BEGINNING ON THE LAST BYTE OF A PAGE + return read_word_wrap(state, indirect_address); } -word get_address_indirect_x(State6502* state) { +word get_address_indirect_x(State6502 * state) { //pre-indexed indirect with the X register //zero-page address is added to x register byte indirect_address = fetch_byte(state) + state->x; //pointing to address of a word holding the address of the operand - word address = read_word(state, indirect_address); + word address = read_word_wrap(state, indirect_address); return address; } -byte get_byte_indirect_x(State6502* state) { +byte get_byte_indirect_x(State6502 * state) { //pre-indexed indirect with the X register return state->memory[get_address_indirect_x(state)]; } -word get_address_indirect_y(State6502* state) { +word get_address_indirect_y(State6502 * state) { //post-indexed indirect //zero-page address as an argument byte indirect_address = fetch_byte(state); @@ -118,11 +113,11 @@ word get_address_indirect_y(State6502* state) { return address; } -byte get_byte_indirect_y(State6502* state) { +byte get_byte_indirect_y(State6502 * state) { return state->memory[get_address_indirect_y(state)]; } -word get_address_relative(State6502* state) { +word get_address_relative(State6502 * state) { int8_t address = (int8_t)fetch_byte(state); return state->pc + address; } \ No newline at end of file diff --git a/memory.h b/memory.h index 5822322..23ec311 100644 --- a/memory.h +++ b/memory.h @@ -7,6 +7,8 @@ word fetch_word(State6502* state); word read_word(State6502* state, word address); +word read_word_wrap(State6502* state, word address); + word get_address_zero_page(State6502* state); byte get_byte_zero_page(State6502* state); diff --git a/test6502.c b/test6502.c index 0fa35fa..d78b138 100644 --- a/test6502.c +++ b/test6502.c @@ -2533,7 +2533,6 @@ void run_suite(fp * *suite, int size) { } void run_tests() { - test_LDA_INDX_wraparound(); RUN(tests_ror); RUN(tests_asl); RUN(tests_rti);