1343 lines
25 KiB
C
1343 lines
25 KiB
C
// $package. http://www.slack.net/~ant/
|
|
|
|
#if 0
|
|
/* Define these macros in the source file before #including this file.
|
|
- Parameters might be expressions, so they are best evaluated only once,
|
|
though they NEVER have side-effects, so multiple evaluation is OK.
|
|
- Output parameters might be a multiple-assignment expression like "a=x",
|
|
so they must NOT be parenthesized.
|
|
- Except where noted, time() and related functions will NOT work
|
|
correctly inside a macro. TIME() is always correct, and FLUSH_TIME() and
|
|
CACHE_TIME() allow the time changing functions to work.
|
|
- Macros "returning" void may use a {} statement block. */
|
|
|
|
// 0 <= addr <= 0xFFFF + page_size
|
|
// time functions can be used
|
|
int READ_MEM( addr_t );
|
|
void WRITE_MEM( addr_t, int data );
|
|
|
|
// 0 <= addr <= 0x1FF
|
|
int READ_LOW( addr_t );
|
|
void WRITE_LOW( addr_t, int data );
|
|
|
|
// 0 <= addr <= 0xFFFF + page_size
|
|
// Used by common instructions.
|
|
int READ_FAST( addr_t, int& out );
|
|
void WRITE_FAST( addr_t, int data );
|
|
|
|
// 0 <= addr <= 2
|
|
// ST0, ST1, ST2 instructions
|
|
void WRITE_VDP( int addr, int data );
|
|
|
|
// The following can be used within macros:
|
|
|
|
// Current time
|
|
time_t TIME();
|
|
|
|
// Allows use of time functions
|
|
void FLUSH_TIME();
|
|
|
|
// Must be used before end of macro if FLUSH_TIME() was used earlier
|
|
void CACHE_TIME();
|
|
|
|
// Configuration (optional; commented behavior if defined)
|
|
|
|
// Expanded just before beginning of code, to help debugger
|
|
#define CPU_BEGIN void my_run_cpu() {
|
|
#endif
|
|
|
|
/* Copyright (C) 2003-2008 Shay Green. This module is free software; you
|
|
can redistribute it and/or modify it under the terms of the GNU Lesser
|
|
General Public License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version. This
|
|
module is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
|
|
details. You should have received a copy of the GNU Lesser General Public
|
|
License along with this module; if not, write to the Free Software Foundation,
|
|
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
// TODO: support T flag, including clearing it at appropriate times?
|
|
|
|
// all zero-page should really use whatever is at page 1, but that would
|
|
// reduce efficiency quite a bit
|
|
int const ram_addr = 0x2000;
|
|
|
|
void Hes_Cpu::reset()
|
|
{
|
|
check( cpu_state == &cpu_state_ );
|
|
cpu_state = &cpu_state_;
|
|
|
|
cpu_state_.time = 0;
|
|
cpu_state_.base = 0;
|
|
irq_time_ = future_time;
|
|
end_time_ = future_time;
|
|
|
|
r.flags = 0x04;
|
|
r.sp = 0;
|
|
r.pc = 0;
|
|
r.a = 0;
|
|
r.x = 0;
|
|
r.y = 0;
|
|
|
|
// Be sure "blargg_endian.h" has been #included
|
|
blargg_verify_byte_order();
|
|
}
|
|
|
|
// Allows MWCW debugger to step through code properly
|
|
#ifdef CPU_BEGIN
|
|
CPU_BEGIN
|
|
#endif
|
|
|
|
// Time
|
|
#define TIME() (s_time + s.base)
|
|
#define FLUSH_TIME() {s.time = s_time;}
|
|
#define CACHE_TIME() {s_time = s.time;}
|
|
|
|
// Memory
|
|
#define READ_STACK READ_LOW
|
|
#define WRITE_STACK WRITE_LOW
|
|
|
|
#define CODE_PAGE( addr ) s.code_map [HES_CPU_PAGE( addr )]
|
|
#define CODE_OFFSET( addr ) HES_CPU_OFFSET( addr )
|
|
#define READ_CODE( addr ) CODE_PAGE( addr ) [CODE_OFFSET( addr )]
|
|
|
|
// Stack
|
|
#define SET_SP( v ) (sp = ((v) + 1) | 0x100)
|
|
#define GET_SP() ((sp - 1) & 0xFF)
|
|
#define SP( o ) ((sp + (o - (o>0)*0x100)) | 0x100)
|
|
|
|
// Truncation
|
|
#define BYTE( n ) ((BOOST::uint8_t ) (n)) /* (unsigned) n & 0xFF */
|
|
#define SBYTE( n ) ((BOOST::int8_t ) (n)) /* (BYTE( n ) ^ 0x80) - 0x80 */
|
|
#define WORD( n ) ((BOOST::uint16_t) (n)) /* (unsigned) n & 0xFFFF */
|
|
|
|
// Flags with hex value for clarity when used as mask.
|
|
// Stored in indicated variable during emulation.
|
|
int const n80 = 0x80; // nz
|
|
int const v40 = 0x40; // flags
|
|
//int const t20 = 0x20;
|
|
int const b10 = 0x10;
|
|
int const d08 = 0x08; // flags
|
|
int const i04 = 0x04; // flags
|
|
int const z02 = 0x02; // nz
|
|
int const c01 = 0x01; // c
|
|
|
|
#define IS_NEG (nz & 0x8080)
|
|
|
|
#define GET_FLAGS( out ) \
|
|
{\
|
|
out = flags & (v40 | d08 | i04);\
|
|
out += ((nz >> 8) | nz) & n80;\
|
|
out += c >> 8 & c01;\
|
|
if ( !BYTE( nz ) )\
|
|
out += z02;\
|
|
}
|
|
|
|
#define SET_FLAGS( in ) \
|
|
{\
|
|
flags = in & (v40 | d08 | i04);\
|
|
c = nz = in << 8;\
|
|
nz += ~in & z02;\
|
|
}
|
|
|
|
bool illegal_encountered = false;
|
|
{
|
|
Hes_Cpu::cpu_state_t s = CPU.cpu_state_;
|
|
CPU.cpu_state = &s;
|
|
// even on x86, using s.time in place of s_time was slower
|
|
int s_time = s.time;
|
|
|
|
// registers
|
|
int pc = CPU.r.pc;
|
|
int a = CPU.r.a;
|
|
int x = CPU.r.x;
|
|
int y = CPU.r.y;
|
|
int sp;
|
|
SET_SP( CPU.r.sp );
|
|
|
|
// Flags
|
|
int flags;
|
|
int c; // carry set if (c & 0x100) != 0
|
|
int nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
|
|
{
|
|
int temp = CPU.r.flags;
|
|
SET_FLAGS( temp );
|
|
}
|
|
|
|
loop:
|
|
|
|
#ifndef NDEBUG
|
|
{
|
|
time_t correct = CPU.end_time_;
|
|
if ( !(flags & i04) && correct > CPU.irq_time_ )
|
|
correct = CPU.irq_time_;
|
|
check( s.base == correct );
|
|
/*
|
|
static int count;
|
|
if ( count == 1844 ) Debugger();
|
|
if ( s.base != correct ) dprintf( "%ld\n", count );
|
|
count++;
|
|
*/
|
|
}
|
|
#endif
|
|
|
|
// Check all values
|
|
check( (unsigned) sp - 0x100 < 0x100 );
|
|
check( (unsigned) pc < 0x10000 + 0x100 ); // +0x100 so emulator can catch wrap-around
|
|
check( (unsigned) a < 0x100 );
|
|
check( (unsigned) x < 0x100 );
|
|
check( (unsigned) y < 0x100 );
|
|
|
|
// Read instruction
|
|
byte const* instr = CODE_PAGE( pc );
|
|
int opcode;
|
|
|
|
if ( CODE_OFFSET(~0) == ~0 )
|
|
{
|
|
opcode = instr [pc];
|
|
pc++;
|
|
instr += pc;
|
|
}
|
|
else
|
|
{
|
|
instr += CODE_OFFSET( pc );
|
|
opcode = *instr++;
|
|
pc++;
|
|
}
|
|
|
|
// TODO: each reference lists slightly different timing values, ugh
|
|
static byte const clock_table [256] =
|
|
{// 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
1,7,3, 4,6,4,6,7,3,2,2,2,7,5,7,4,// 0
|
|
2,7,7, 4,6,4,6,7,2,5,2,2,7,5,7,4,// 1
|
|
7,7,3, 4,4,4,6,7,4,2,2,2,5,5,7,4,// 2
|
|
2,7,7, 2,4,4,6,7,2,5,2,2,5,5,7,4,// 3
|
|
7,7,3, 4,8,4,6,7,3,2,2,2,4,5,7,4,// 4
|
|
2,7,7, 5,2,4,6,7,2,5,3,2,2,5,7,4,// 5
|
|
7,7,2, 2,4,4,6,7,4,2,2,2,7,5,7,4,// 6
|
|
2,7,7,17,4,4,6,7,2,5,4,2,7,5,7,4,// 7
|
|
4,7,2, 7,4,4,4,7,2,2,2,2,5,5,5,4,// 8
|
|
2,7,7, 8,4,4,4,7,2,5,2,2,5,5,5,4,// 9
|
|
2,7,2, 7,4,4,4,7,2,2,2,2,5,5,5,4,// A
|
|
2,7,7, 8,4,4,4,7,2,5,2,2,5,5,5,4,// B
|
|
2,7,2,17,4,4,6,7,2,2,2,2,5,5,7,4,// C
|
|
2,7,7,17,2,4,6,7,2,5,3,2,2,5,7,4,// D
|
|
2,7,2,17,4,4,6,7,2,2,2,2,5,5,7,4,// E
|
|
2,7,7,17,2,4,6,7,2,5,4,2,2,5,7,4 // F
|
|
}; // 0x00 was 8
|
|
|
|
// Update time
|
|
if ( s_time >= 0 )
|
|
goto out_of_time;
|
|
|
|
#ifdef HES_CPU_LOG_H
|
|
log_cpu( "new", pc - 1, opcode, instr [0], instr [1], instr [2],
|
|
instr [3], instr [4], instr [5], a, x, y );
|
|
//log_opcode( opcode );
|
|
#endif
|
|
|
|
s_time += clock_table [opcode];
|
|
|
|
int data;
|
|
data = *instr;
|
|
|
|
switch ( opcode )
|
|
{
|
|
// Macros
|
|
|
|
#define GET_MSB() (instr [1])
|
|
#define ADD_PAGE( out ) (pc++, out = data + 0x100 * GET_MSB());
|
|
#define GET_ADDR() GET_LE16( instr )
|
|
|
|
// TODO: is the penalty really always added? the original 6502 was much better
|
|
//#define PAGE_PENALTY( lsb ) (void) (s_time += (lsb) >> 8)
|
|
#define PAGE_PENALTY( lsb )
|
|
|
|
// Branch
|
|
|
|
// TODO: more efficient way to handle negative branch that wraps PC around
|
|
#define BRANCH_( cond, adj )\
|
|
{\
|
|
pc++;\
|
|
if ( !(cond) ) goto loop;\
|
|
pc = (BOOST::uint16_t) (pc + SBYTE( data ));\
|
|
s_time += adj;\
|
|
goto loop;\
|
|
}
|
|
|
|
#define BRANCH( cond ) BRANCH_( cond, 2 )
|
|
|
|
case 0xF0: // BEQ
|
|
BRANCH( !BYTE( nz ) );
|
|
|
|
case 0xD0: // BNE
|
|
BRANCH( BYTE( nz ) );
|
|
|
|
case 0x10: // BPL
|
|
BRANCH( !IS_NEG );
|
|
|
|
case 0x90: // BCC
|
|
BRANCH( !(c & 0x100) )
|
|
|
|
case 0x30: // BMI
|
|
BRANCH( IS_NEG )
|
|
|
|
case 0x50: // BVC
|
|
BRANCH( !(flags & v40) )
|
|
|
|
case 0x70: // BVS
|
|
BRANCH( flags & v40 )
|
|
|
|
case 0xB0: // BCS
|
|
BRANCH( c & 0x100 )
|
|
|
|
case 0x80: // BRA
|
|
branch_taken:
|
|
BRANCH_( true, 0 );
|
|
|
|
case 0xFF:
|
|
#ifdef IDLE_ADDR
|
|
if ( pc == IDLE_ADDR + 1 )
|
|
goto idle_done;
|
|
#endif
|
|
|
|
pc = (BOOST::uint16_t) pc;
|
|
|
|
case 0x0F: // BBRn
|
|
case 0x1F:
|
|
case 0x2F:
|
|
case 0x3F:
|
|
case 0x4F:
|
|
case 0x5F:
|
|
case 0x6F:
|
|
case 0x7F:
|
|
case 0x8F: // BBSn
|
|
case 0x9F:
|
|
case 0xAF:
|
|
case 0xBF:
|
|
case 0xCF:
|
|
case 0xDF:
|
|
case 0xEF: {
|
|
// Make two copies of bits, one negated
|
|
int t = 0x101 * READ_LOW( data );
|
|
t ^= 0xFF;
|
|
pc++;
|
|
data = GET_MSB();
|
|
BRANCH( t & (1 << (opcode >> 4)) )
|
|
}
|
|
|
|
case 0x4C: // JMP abs
|
|
pc = GET_ADDR();
|
|
goto loop;
|
|
|
|
case 0x7C: // JMP (ind+X)
|
|
data += x;
|
|
case 0x6C:{// JMP (ind)
|
|
data += 0x100 * GET_MSB();
|
|
pc = GET_LE16( &READ_CODE( data ) );
|
|
goto loop;
|
|
}
|
|
|
|
// Subroutine
|
|
|
|
case 0x44: // BSR
|
|
WRITE_STACK( SP( -1 ), pc >> 8 );
|
|
sp = SP( -2 );
|
|
WRITE_STACK( sp, pc );
|
|
goto branch_taken;
|
|
|
|
case 0x20: { // JSR
|
|
int temp = pc + 1;
|
|
pc = GET_ADDR();
|
|
WRITE_STACK( SP( -1 ), temp >> 8 );
|
|
sp = SP( -2 );
|
|
WRITE_STACK( sp, temp );
|
|
goto loop;
|
|
}
|
|
|
|
case 0x60: // RTS
|
|
pc = 1 + READ_STACK( sp );
|
|
pc += 0x100 * READ_STACK( SP( 1 ) );
|
|
sp = SP( 2 );
|
|
goto loop;
|
|
|
|
case 0x00: // BRK
|
|
goto handle_brk;
|
|
|
|
// Common
|
|
|
|
case 0xBD:{// LDA abs,X
|
|
PAGE_PENALTY( data + x );
|
|
int addr = GET_ADDR() + x;
|
|
pc += 2;
|
|
READ_FAST( addr, nz );
|
|
a = nz;
|
|
goto loop;
|
|
}
|
|
|
|
case 0x9D:{// STA abs,X
|
|
int addr = GET_ADDR() + x;
|
|
pc += 2;
|
|
WRITE_FAST( addr, a );
|
|
goto loop;
|
|
}
|
|
|
|
case 0x95: // STA zp,x
|
|
data = BYTE( data + x );
|
|
case 0x85: // STA zp
|
|
pc++;
|
|
WRITE_LOW( data, a );
|
|
goto loop;
|
|
|
|
case 0xAE:{// LDX abs
|
|
int addr = GET_ADDR();
|
|
pc += 2;
|
|
READ_FAST( addr, nz );
|
|
x = nz;
|
|
goto loop;
|
|
}
|
|
|
|
case 0xA5: // LDA zp
|
|
a = nz = READ_LOW( data );
|
|
pc++;
|
|
goto loop;
|
|
|
|
// Load/store
|
|
|
|
{
|
|
int addr;
|
|
case 0x91: // STA (ind),Y
|
|
addr = 0x100 * READ_LOW( BYTE( data + 1 ) );
|
|
addr += READ_LOW( data ) + y;
|
|
pc++;
|
|
goto sta_ptr;
|
|
|
|
case 0x81: // STA (ind,X)
|
|
data = BYTE( data + x );
|
|
case 0x92: // STA (ind)
|
|
addr = 0x100 * READ_LOW( BYTE( data + 1 ) );
|
|
addr += READ_LOW( data );
|
|
pc++;
|
|
goto sta_ptr;
|
|
|
|
case 0x99: // STA abs,Y
|
|
data += y;
|
|
case 0x8D: // STA abs
|
|
addr = data + 0x100 * GET_MSB();
|
|
pc += 2;
|
|
sta_ptr:
|
|
WRITE_FAST( addr, a );
|
|
goto loop;
|
|
}
|
|
|
|
{
|
|
int addr;
|
|
case 0xA1: // LDA (ind,X)
|
|
data = BYTE( data + x );
|
|
case 0xB2: // LDA (ind)
|
|
addr = 0x100 * READ_LOW( BYTE( data + 1 ) );
|
|
addr += READ_LOW( data );
|
|
pc++;
|
|
goto a_nz_read_addr;
|
|
|
|
case 0xB1:// LDA (ind),Y
|
|
addr = READ_LOW( data ) + y;
|
|
PAGE_PENALTY( addr );
|
|
addr += 0x100 * READ_LOW( BYTE( data + 1 ) );
|
|
pc++;
|
|
goto a_nz_read_addr;
|
|
|
|
case 0xB9: // LDA abs,Y
|
|
data += y;
|
|
PAGE_PENALTY( data );
|
|
case 0xAD: // LDA abs
|
|
addr = data + 0x100 * GET_MSB();
|
|
pc += 2;
|
|
a_nz_read_addr:
|
|
READ_FAST( addr, nz );
|
|
a = nz;
|
|
goto loop;
|
|
}
|
|
|
|
case 0xBE:{// LDX abs,y
|
|
PAGE_PENALTY( data + y );
|
|
int addr = GET_ADDR() + y;
|
|
pc += 2;
|
|
FLUSH_TIME();
|
|
x = nz = READ_MEM( addr );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
}
|
|
|
|
case 0xB5: // LDA zp,x
|
|
a = nz = READ_LOW( BYTE( data + x ) );
|
|
pc++;
|
|
goto loop;
|
|
|
|
case 0xA9: // LDA #imm
|
|
pc++;
|
|
a = data;
|
|
nz = data;
|
|
goto loop;
|
|
|
|
// Bit operations
|
|
|
|
case 0x3C: // BIT abs,x
|
|
data += x;
|
|
case 0x2C:{// BIT abs
|
|
int addr;
|
|
ADD_PAGE( addr );
|
|
FLUSH_TIME();
|
|
nz = READ_MEM( addr );
|
|
CACHE_TIME();
|
|
goto bit_common;
|
|
}
|
|
case 0x34: // BIT zp,x
|
|
data = BYTE( data + x );
|
|
case 0x24: // BIT zp
|
|
data = READ_LOW( data );
|
|
case 0x89: // BIT imm
|
|
nz = data;
|
|
bit_common:
|
|
pc++;
|
|
flags = (flags & ~v40) + (nz & v40);
|
|
if ( nz & a )
|
|
goto loop; // Z should be clear, and nz must be non-zero if nz & a is
|
|
nz <<= 8; // set Z flag without affecting N flag
|
|
goto loop;
|
|
|
|
{
|
|
int addr;
|
|
|
|
case 0xB3: // TST abs,x
|
|
addr = GET_MSB() + x;
|
|
goto tst_abs;
|
|
|
|
case 0x93: // TST abs
|
|
addr = GET_MSB();
|
|
tst_abs:
|
|
addr += 0x100 * instr [2];
|
|
pc++;
|
|
FLUSH_TIME();
|
|
nz = READ_MEM( addr );
|
|
CACHE_TIME();
|
|
goto tst_common;
|
|
}
|
|
|
|
case 0xA3: // TST zp,x
|
|
nz = READ_LOW( BYTE( GET_MSB() + x ) );
|
|
goto tst_common;
|
|
|
|
case 0x83: // TST zp
|
|
nz = READ_LOW( GET_MSB() );
|
|
tst_common:
|
|
pc += 2;
|
|
flags = (flags & ~v40) + (nz & v40);
|
|
if ( nz & data )
|
|
goto loop; // Z should be clear, and nz must be non-zero if nz & data is
|
|
nz <<= 8; // set Z flag without affecting N flag
|
|
goto loop;
|
|
|
|
{
|
|
int addr;
|
|
case 0x0C: // TSB abs
|
|
case 0x1C: // TRB abs
|
|
addr = GET_ADDR();
|
|
pc++;
|
|
goto txb_addr;
|
|
|
|
// TODO: everyone lists different behaviors for the flags flags, ugh
|
|
case 0x04: // TSB zp
|
|
case 0x14: // TRB zp
|
|
addr = data + ram_addr;
|
|
txb_addr:
|
|
FLUSH_TIME();
|
|
nz = a | READ_MEM( addr );
|
|
if ( opcode & 0x10 )
|
|
nz ^= a; // bits from a will already be set, so this clears them
|
|
flags = (flags & ~v40) + (nz & v40);
|
|
pc++;
|
|
WRITE_MEM( addr, nz );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
}
|
|
|
|
case 0x07: // RMBn
|
|
case 0x17:
|
|
case 0x27:
|
|
case 0x37:
|
|
case 0x47:
|
|
case 0x57:
|
|
case 0x67:
|
|
case 0x77:
|
|
pc++;
|
|
READ_LOW( data ) &= ~(1 << (opcode >> 4));
|
|
goto loop;
|
|
|
|
case 0x87: // SMBn
|
|
case 0x97:
|
|
case 0xA7:
|
|
case 0xB7:
|
|
case 0xC7:
|
|
case 0xD7:
|
|
case 0xE7:
|
|
case 0xF7:
|
|
pc++;
|
|
READ_LOW( data ) |= 1 << ((opcode >> 4) - 8);
|
|
goto loop;
|
|
|
|
// Load/store
|
|
|
|
case 0x9E: // STZ abs,x
|
|
data += x;
|
|
case 0x9C: // STZ abs
|
|
ADD_PAGE( data );
|
|
pc++;
|
|
FLUSH_TIME();
|
|
WRITE_MEM( data, 0 );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
|
|
case 0x74: // STZ zp,x
|
|
data = BYTE( data + x );
|
|
case 0x64: // STZ zp
|
|
pc++;
|
|
WRITE_LOW( data, 0 );
|
|
goto loop;
|
|
|
|
case 0x94: // STY zp,x
|
|
data = BYTE( data + x );
|
|
case 0x84: // STY zp
|
|
pc++;
|
|
WRITE_LOW( data, y );
|
|
goto loop;
|
|
|
|
case 0x96: // STX zp,y
|
|
data = BYTE( data + y );
|
|
case 0x86: // STX zp
|
|
pc++;
|
|
WRITE_LOW( data, x );
|
|
goto loop;
|
|
|
|
case 0xB6: // LDX zp,y
|
|
data = BYTE( data + y );
|
|
case 0xA6: // LDX zp
|
|
data = READ_LOW( data );
|
|
case 0xA2: // LDX #imm
|
|
pc++;
|
|
x = data;
|
|
nz = data;
|
|
goto loop;
|
|
|
|
case 0xB4: // LDY zp,x
|
|
data = BYTE( data + x );
|
|
case 0xA4: // LDY zp
|
|
data = READ_LOW( data );
|
|
case 0xA0: // LDY #imm
|
|
pc++;
|
|
y = data;
|
|
nz = data;
|
|
goto loop;
|
|
|
|
case 0xBC: // LDY abs,X
|
|
data += x;
|
|
PAGE_PENALTY( data );
|
|
case 0xAC:{// LDY abs
|
|
int addr = data + 0x100 * GET_MSB();
|
|
pc += 2;
|
|
FLUSH_TIME();
|
|
y = nz = READ_MEM( addr );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
}
|
|
|
|
{
|
|
int temp;
|
|
case 0x8C: // STY abs
|
|
temp = y;
|
|
if ( 0 )
|
|
case 0x8E: // STX abs
|
|
temp = x;
|
|
int addr = GET_ADDR();
|
|
pc += 2;
|
|
FLUSH_TIME();
|
|
WRITE_MEM( addr, temp );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
}
|
|
|
|
// Compare
|
|
|
|
case 0xEC:{// CPX abs
|
|
int addr = GET_ADDR();
|
|
pc++;
|
|
FLUSH_TIME();
|
|
data = READ_MEM( addr );
|
|
CACHE_TIME();
|
|
goto cpx_data;
|
|
}
|
|
|
|
case 0xE4: // CPX zp
|
|
data = READ_LOW( data );
|
|
case 0xE0: // CPX #imm
|
|
cpx_data:
|
|
nz = x - data;
|
|
pc++;
|
|
c = ~nz;
|
|
nz = BYTE( nz );
|
|
goto loop;
|
|
|
|
case 0xCC:{// CPY abs
|
|
int addr = GET_ADDR();
|
|
pc++;
|
|
FLUSH_TIME();
|
|
data = READ_MEM( addr );
|
|
CACHE_TIME();
|
|
goto cpy_data;
|
|
}
|
|
|
|
case 0xC4: // CPY zp
|
|
data = READ_LOW( data );
|
|
case 0xC0: // CPY #imm
|
|
cpy_data:
|
|
nz = y - data;
|
|
pc++;
|
|
c = ~nz;
|
|
nz = BYTE( nz );
|
|
goto loop;
|
|
|
|
// Logical
|
|
|
|
#define ARITH_ADDR_MODES( op )\
|
|
case op - 0x04: /* (ind,x) */\
|
|
data = BYTE( data + x );\
|
|
case op + 0x0D: /* (ind) */\
|
|
data = 0x100 * READ_LOW( BYTE( data + 1 ) ) + READ_LOW( data );\
|
|
goto ptr##op;\
|
|
case op + 0x0C:{/* (ind),y */\
|
|
int temp = READ_LOW( data ) + y;\
|
|
PAGE_PENALTY( temp );\
|
|
data = temp + 0x100 * READ_LOW( BYTE( data + 1 ) );\
|
|
goto ptr##op;\
|
|
}\
|
|
case op + 0x10: /* zp,X */\
|
|
data = BYTE( data + x );\
|
|
case op + 0x00: /* zp */\
|
|
data = READ_LOW( data );\
|
|
goto imm##op;\
|
|
case op + 0x14: /* abs,Y */\
|
|
data += y;\
|
|
goto ind##op;\
|
|
case op + 0x18: /* abs,X */\
|
|
data += x;\
|
|
ind##op:\
|
|
PAGE_PENALTY( data );\
|
|
case op + 0x08: /* abs */\
|
|
ADD_PAGE( data );\
|
|
ptr##op:\
|
|
FLUSH_TIME();\
|
|
data = READ_MEM( data );\
|
|
CACHE_TIME();\
|
|
case op + 0x04: /* imm */\
|
|
imm##op:
|
|
|
|
ARITH_ADDR_MODES( 0xC5 ) // CMP
|
|
nz = a - data;
|
|
pc++;
|
|
c = ~nz;
|
|
nz = BYTE( nz );
|
|
goto loop;
|
|
|
|
ARITH_ADDR_MODES( 0x25 ) // AND
|
|
nz = (a &= data);
|
|
pc++;
|
|
goto loop;
|
|
|
|
ARITH_ADDR_MODES( 0x45 ) // EOR
|
|
nz = (a ^= data);
|
|
pc++;
|
|
goto loop;
|
|
|
|
ARITH_ADDR_MODES( 0x05 ) // ORA
|
|
nz = (a |= data);
|
|
pc++;
|
|
goto loop;
|
|
|
|
// Add/subtract
|
|
|
|
ARITH_ADDR_MODES( 0xE5 ) // SBC
|
|
data ^= 0xFF;
|
|
goto adc_imm;
|
|
|
|
ARITH_ADDR_MODES( 0x65 ) // ADC
|
|
adc_imm: {
|
|
if ( flags & d08 )
|
|
dprintf( "Decimal mode not supported\n" );
|
|
int carry = c >> 8 & 1;
|
|
int ov = (a ^ 0x80) + carry + SBYTE( data );
|
|
flags = (flags & ~v40) + (ov >> 2 & v40);
|
|
c = nz = a + data + carry;
|
|
pc++;
|
|
a = BYTE( nz );
|
|
goto loop;
|
|
}
|
|
|
|
// Shift/rotate
|
|
|
|
case 0x4A: // LSR A
|
|
c = 0;
|
|
case 0x6A: // ROR A
|
|
nz = c >> 1 & 0x80;
|
|
c = a << 8;
|
|
nz += a >> 1;
|
|
a = nz;
|
|
goto loop;
|
|
|
|
case 0x0A: // ASL A
|
|
nz = a << 1;
|
|
c = nz;
|
|
a = BYTE( nz );
|
|
goto loop;
|
|
|
|
case 0x2A: { // ROL A
|
|
nz = a << 1;
|
|
int temp = c >> 8 & 1;
|
|
c = nz;
|
|
nz += temp;
|
|
a = BYTE( nz );
|
|
goto loop;
|
|
}
|
|
|
|
case 0x5E: // LSR abs,X
|
|
data += x;
|
|
case 0x4E: // LSR abs
|
|
c = 0;
|
|
case 0x6E: // ROR abs
|
|
ror_abs: {
|
|
ADD_PAGE( data );
|
|
FLUSH_TIME();
|
|
int temp = READ_MEM( data );
|
|
nz = (c >> 1 & 0x80) + (temp >> 1);
|
|
c = temp << 8;
|
|
goto rotate_common;
|
|
}
|
|
|
|
case 0x3E: // ROL abs,X
|
|
data += x;
|
|
goto rol_abs;
|
|
|
|
case 0x1E: // ASL abs,X
|
|
data += x;
|
|
case 0x0E: // ASL abs
|
|
c = 0;
|
|
case 0x2E: // ROL abs
|
|
rol_abs:
|
|
ADD_PAGE( data );
|
|
nz = c >> 8 & 1;
|
|
FLUSH_TIME();
|
|
nz += (c = READ_MEM( data ) << 1);
|
|
rotate_common:
|
|
pc++;
|
|
WRITE_MEM( data, BYTE( nz ) );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
|
|
case 0x7E: // ROR abs,X
|
|
data += x;
|
|
goto ror_abs;
|
|
|
|
case 0x76: // ROR zp,x
|
|
data = BYTE( data + x );
|
|
goto ror_zp;
|
|
|
|
case 0x56: // LSR zp,x
|
|
data = BYTE( data + x );
|
|
case 0x46: // LSR zp
|
|
c = 0;
|
|
case 0x66: // ROR zp
|
|
ror_zp: {
|
|
int temp = READ_LOW( data );
|
|
nz = (c >> 1 & 0x80) + (temp >> 1);
|
|
c = temp << 8;
|
|
goto write_nz_zp;
|
|
}
|
|
|
|
case 0x36: // ROL zp,x
|
|
data = BYTE( data + x );
|
|
goto rol_zp;
|
|
|
|
case 0x16: // ASL zp,x
|
|
data = BYTE( data + x );
|
|
case 0x06: // ASL zp
|
|
c = 0;
|
|
case 0x26: // ROL zp
|
|
rol_zp:
|
|
nz = c >> 8 & 1;
|
|
nz += (c = READ_LOW( data ) << 1);
|
|
goto write_nz_zp;
|
|
|
|
// Increment/decrement
|
|
|
|
#define INC_DEC( reg, n ) reg = BYTE( nz = reg + n ); goto loop;
|
|
|
|
case 0x1A: // INA
|
|
INC_DEC( a, +1 )
|
|
|
|
case 0xE8: // INX
|
|
INC_DEC( x, +1 )
|
|
|
|
case 0xC8: // INY
|
|
INC_DEC( y, +1 )
|
|
|
|
case 0x3A: // DEA
|
|
INC_DEC( a, -1 )
|
|
|
|
case 0xCA: // DEX
|
|
INC_DEC( x, -1 )
|
|
|
|
case 0x88: // DEY
|
|
INC_DEC( y, -1 )
|
|
|
|
case 0xF6: // INC zp,x
|
|
data = BYTE( data + x );
|
|
case 0xE6: // INC zp
|
|
nz = 1;
|
|
goto add_nz_zp;
|
|
|
|
case 0xD6: // DEC zp,x
|
|
data = BYTE( data + x );
|
|
case 0xC6: // DEC zp
|
|
nz = -1;
|
|
add_nz_zp:
|
|
nz += READ_LOW( data );
|
|
write_nz_zp:
|
|
pc++;
|
|
WRITE_LOW( data, nz );
|
|
goto loop;
|
|
|
|
case 0xFE: // INC abs,x
|
|
data = x + GET_ADDR();
|
|
goto inc_ptr;
|
|
|
|
case 0xEE: // INC abs
|
|
data = GET_ADDR();
|
|
inc_ptr:
|
|
nz = 1;
|
|
goto inc_common;
|
|
|
|
case 0xDE: // DEC abs,x
|
|
data = x + GET_ADDR();
|
|
goto dec_ptr;
|
|
|
|
case 0xCE: // DEC abs
|
|
data = GET_ADDR();
|
|
dec_ptr:
|
|
nz = -1;
|
|
inc_common:
|
|
FLUSH_TIME();
|
|
pc += 2;
|
|
nz += READ_MEM( data );
|
|
WRITE_MEM( data, BYTE( nz ) );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
|
|
// Transfer
|
|
|
|
case 0xA8: // TAY
|
|
y = nz = a;
|
|
goto loop;
|
|
|
|
case 0x98: // TYA
|
|
a = nz = y;
|
|
goto loop;
|
|
|
|
case 0xAA: // TAX
|
|
x = nz = a;
|
|
goto loop;
|
|
|
|
case 0x8A: // TXA
|
|
a = nz = x;
|
|
goto loop;
|
|
|
|
case 0x9A: // TXS
|
|
SET_SP( x ); // verified (no flag change)
|
|
goto loop;
|
|
|
|
case 0xBA: // TSX
|
|
x = nz = GET_SP();
|
|
goto loop;
|
|
|
|
#define SWAP_REGS( r1, r2 ) {\
|
|
int t = r1;\
|
|
r1 = r2;\
|
|
r2 = t;\
|
|
goto loop;\
|
|
}
|
|
|
|
case 0x02: // SXY
|
|
SWAP_REGS( x, y );
|
|
|
|
case 0x22: // SAX
|
|
SWAP_REGS( a, x );
|
|
|
|
case 0x42: // SAY
|
|
SWAP_REGS( a, y );
|
|
|
|
case 0x62: // CLA
|
|
a = 0;
|
|
goto loop;
|
|
|
|
case 0x82: // CLX
|
|
x = 0;
|
|
goto loop;
|
|
|
|
case 0xC2: // CLY
|
|
y = 0;
|
|
goto loop;
|
|
|
|
// Stack
|
|
|
|
case 0x48: // PHA
|
|
sp = SP( -1 );
|
|
WRITE_STACK( sp, a );
|
|
goto loop;
|
|
|
|
case 0x68: // PLA
|
|
a = nz = READ_STACK( sp );
|
|
sp = SP( 1 );
|
|
goto loop;
|
|
|
|
case 0xDA: // PHX
|
|
sp = SP( -1 );
|
|
WRITE_STACK( sp, x );
|
|
goto loop;
|
|
|
|
case 0x5A: // PHY
|
|
sp = SP( -1 );
|
|
WRITE_STACK( sp, y );
|
|
goto loop;
|
|
|
|
case 0x40:{// RTI
|
|
pc = READ_STACK( SP( 1 ) );
|
|
pc += READ_STACK( SP( 2 ) ) * 0x100;
|
|
int temp = READ_STACK( sp );
|
|
sp = SP( 3 );
|
|
data = flags;
|
|
SET_FLAGS( temp );
|
|
CPU.r.flags = flags; // update externally-visible I flag
|
|
if ( (data ^ flags) & i04 )
|
|
{
|
|
time_t new_time = CPU.end_time_;
|
|
if ( !(flags & i04) && new_time > CPU.irq_time_ )
|
|
new_time = CPU.irq_time_;
|
|
int delta = s.base - new_time;
|
|
s.base = new_time;
|
|
s_time += delta;
|
|
}
|
|
goto loop;
|
|
}
|
|
|
|
case 0xFA: // PLX
|
|
x = nz = READ_STACK( sp );
|
|
sp = SP( 1 );
|
|
goto loop;
|
|
|
|
case 0x7A: // PLY
|
|
y = nz = READ_STACK( sp );
|
|
sp = SP( 1 );
|
|
goto loop;
|
|
|
|
case 0x28:{// PLP
|
|
int temp = READ_STACK( sp );
|
|
sp = SP( 1 );
|
|
int changed = flags ^ temp;
|
|
SET_FLAGS( temp );
|
|
if ( !(changed & i04) )
|
|
goto loop; // I flag didn't change
|
|
if ( flags & i04 )
|
|
goto handle_sei;
|
|
goto handle_cli;
|
|
}
|
|
|
|
case 0x08:{// PHP
|
|
int temp;
|
|
GET_FLAGS( temp );
|
|
sp = SP( -1 );
|
|
WRITE_STACK( sp, temp | b10 );
|
|
goto loop;
|
|
}
|
|
|
|
// Flags
|
|
|
|
case 0x38: // SEC
|
|
c = 0x100;
|
|
goto loop;
|
|
|
|
case 0x18: // CLC
|
|
c = 0;
|
|
goto loop;
|
|
|
|
case 0xB8: // CLV
|
|
flags &= ~v40;
|
|
goto loop;
|
|
|
|
case 0xD8: // CLD
|
|
flags &= ~d08;
|
|
goto loop;
|
|
|
|
case 0xF8: // SED
|
|
flags |= d08;
|
|
goto loop;
|
|
|
|
case 0x58: // CLI
|
|
if ( !(flags & i04) )
|
|
goto loop;
|
|
flags &= ~i04;
|
|
handle_cli: {
|
|
//dprintf( "CLI at %d\n", TIME );
|
|
CPU.r.flags = flags; // update externally-visible I flag
|
|
int delta = s.base - CPU.irq_time_;
|
|
if ( delta <= 0 )
|
|
{
|
|
if ( TIME() < CPU.irq_time_ )
|
|
goto loop;
|
|
goto delayed_cli;
|
|
}
|
|
s.base = CPU.irq_time_;
|
|
s_time += delta;
|
|
if ( s_time < 0 )
|
|
goto loop;
|
|
|
|
if ( delta >= s_time + 1 )
|
|
{
|
|
// delayed irq until after next instruction
|
|
s.base += s_time + 1;
|
|
s_time = -1;
|
|
CPU.irq_time_ = s.base; // TODO: remove, as only to satisfy debug check in loop
|
|
goto loop;
|
|
}
|
|
|
|
// TODO: implement
|
|
delayed_cli:
|
|
dprintf( "Delayed CLI not supported\n" );
|
|
goto loop;
|
|
}
|
|
|
|
case 0x78: // SEI
|
|
if ( flags & i04 )
|
|
goto loop;
|
|
flags |= i04;
|
|
handle_sei: {
|
|
CPU.r.flags = flags; // update externally-visible I flag
|
|
int delta = s.base - CPU.end_time_;
|
|
s.base = CPU.end_time_;
|
|
s_time += delta;
|
|
if ( s_time < 0 )
|
|
goto loop;
|
|
|
|
dprintf( "Delayed SEI not supported\n" );
|
|
goto loop;
|
|
}
|
|
|
|
// Special
|
|
|
|
case 0x53:{// TAM
|
|
int bits = data; // avoid using data across function call
|
|
pc++;
|
|
for ( int i = 0; i < 8; i++ )
|
|
if ( bits & (1 << i) )
|
|
SET_MMR( i, a );
|
|
goto loop;
|
|
}
|
|
|
|
case 0x43:{// TMA
|
|
pc++;
|
|
byte const* in = CPU.mmr;
|
|
do
|
|
{
|
|
if ( data & 1 )
|
|
a = *in;
|
|
in++;
|
|
}
|
|
while ( (data >>= 1) != 0 );
|
|
goto loop;
|
|
}
|
|
|
|
case 0x03: // ST0
|
|
case 0x13: // ST1
|
|
case 0x23:{// ST2
|
|
int addr = opcode >> 4;
|
|
if ( addr )
|
|
addr++;
|
|
pc++;
|
|
FLUSH_TIME();
|
|
WRITE_VDP( addr, data );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
}
|
|
|
|
case 0xEA: // NOP
|
|
goto loop;
|
|
|
|
case 0x54: // CSL
|
|
dprintf( "CSL not supported\n" );
|
|
illegal_encountered = true;
|
|
goto loop;
|
|
|
|
case 0xD4: // CSH
|
|
goto loop;
|
|
|
|
case 0xF4: { // SET
|
|
//int operand = GET_MSB();
|
|
dprintf( "SET not handled\n" );
|
|
//switch ( data )
|
|
//{
|
|
//}
|
|
illegal_encountered = true;
|
|
goto loop;
|
|
}
|
|
|
|
// Block transfer
|
|
|
|
{
|
|
int in_alt;
|
|
int in_inc;
|
|
int out_alt;
|
|
int out_inc;
|
|
|
|
case 0xE3: // TIA
|
|
in_alt = 0;
|
|
goto bxfer_alt;
|
|
|
|
case 0xF3: // TAI
|
|
in_alt = 1;
|
|
bxfer_alt:
|
|
in_inc = in_alt ^ 1;
|
|
out_alt = in_inc;
|
|
out_inc = in_alt;
|
|
goto bxfer;
|
|
|
|
case 0xD3: // TIN
|
|
in_inc = 1;
|
|
out_inc = 0;
|
|
goto bxfer_no_alt;
|
|
|
|
case 0xC3: // TDD
|
|
in_inc = -1;
|
|
out_inc = -1;
|
|
goto bxfer_no_alt;
|
|
|
|
case 0x73: // TII
|
|
in_inc = 1;
|
|
out_inc = 1;
|
|
bxfer_no_alt:
|
|
in_alt = 0;
|
|
out_alt = 0;
|
|
bxfer:
|
|
int in = GET_LE16( instr + 0 );
|
|
int out = GET_LE16( instr + 2 );
|
|
int count = GET_LE16( instr + 4 );
|
|
if ( !count )
|
|
count = 0x10000;
|
|
pc += 6;
|
|
WRITE_STACK( SP( -1 ), y );
|
|
WRITE_STACK( SP( -2 ), a );
|
|
WRITE_STACK( SP( -3 ), x );
|
|
FLUSH_TIME();
|
|
do
|
|
{
|
|
// TODO: reads from $0800-$1400 in I/O page should do I/O
|
|
int t = READ_MEM( in );
|
|
in = WORD( in + in_inc );
|
|
s.time += 6;
|
|
if ( in_alt )
|
|
in_inc = -in_inc;
|
|
WRITE_MEM( out, t );
|
|
out = WORD( out + out_inc );
|
|
if ( out_alt )
|
|
out_inc = -out_inc;
|
|
}
|
|
while ( --count );
|
|
CACHE_TIME();
|
|
goto loop;
|
|
}
|
|
|
|
// Illegal
|
|
|
|
default:
|
|
check( (unsigned) opcode <= 0xFF );
|
|
dprintf( "Illegal opcode $%02X at $%04X\n", (int) opcode, (int) pc - 1 );
|
|
illegal_encountered = true;
|
|
goto loop;
|
|
}
|
|
assert( false ); // catch missing 'goto loop' or accidental 'break'
|
|
|
|
int result_;
|
|
handle_brk:
|
|
pc++;
|
|
result_ = 6;
|
|
|
|
interrupt:
|
|
{
|
|
s_time += 7;
|
|
|
|
// Save PC and read vector
|
|
WRITE_STACK( SP( -1 ), pc >> 8 );
|
|
WRITE_STACK( SP( -2 ), pc );
|
|
pc = GET_LE16( &READ_CODE( 0xFFF0 ) + result_ );
|
|
|
|
// Save flags
|
|
int temp;
|
|
GET_FLAGS( temp );
|
|
if ( result_ == 6 )
|
|
temp |= b10; // BRK sets B bit
|
|
sp = SP( -3 );
|
|
WRITE_STACK( sp, temp );
|
|
|
|
// Update I flag in externally-visible flags
|
|
flags &= ~d08;
|
|
CPU.r.flags = (flags |= i04);
|
|
|
|
// Update time
|
|
int delta = s.base - CPU.end_time_;
|
|
if ( delta >= 0 )
|
|
goto loop;
|
|
s_time += delta;
|
|
s.base = CPU.end_time_;
|
|
goto loop;
|
|
}
|
|
|
|
idle_done:
|
|
s_time = 0;
|
|
|
|
out_of_time:
|
|
pc--;
|
|
|
|
// Optional action that triggers interrupt or changes irq/end time
|
|
#ifdef CPU_DONE
|
|
{
|
|
CPU_DONE( result_ );
|
|
if ( result_ >= 0 )
|
|
goto interrupt;
|
|
if ( s_time < 0 )
|
|
goto loop;
|
|
}
|
|
#endif
|
|
|
|
// Flush cached state
|
|
CPU.r.pc = pc;
|
|
CPU.r.sp = GET_SP();
|
|
CPU.r.a = a;
|
|
CPU.r.x = x;
|
|
CPU.r.y = y;
|
|
|
|
int temp;
|
|
GET_FLAGS( temp );
|
|
CPU.r.flags = temp;
|
|
|
|
CPU.cpu_state_.base = s.base;
|
|
CPU.cpu_state_.time = s_time;
|
|
CPU.cpu_state = &CPU.cpu_state_;
|
|
}
|