void m6809_base_device::execute_run()
{
m_icount -= m_extra_cycles;
m_extra_cycles = 0;
check_irq_lines();
if (m_int_state & (M6809_CWAI | M6809_SYNC))
{
debugger_instruction_hook(this, PCD);
m_icount = 0;
}
else
{
do
{
pPPC = pPC;
debugger_instruction_hook(this, PCD);
m_ireg = ROP(PCD);
PC++;
(this->*m_opcode[m_ireg])();
m_icount -= m_cycles1[m_ireg];
} while( m_icount > 0 );
m_icount -= m_extra_cycles;
m_extra_cycles = 0;
}
}
/* execute instructions on this CPU until icount expires */
static CPU_EXECUTE( m6809 ) /* NS 970908 */
{
m68_state_t *m68_state = get_safe_token(device);
m68_state->icount -= m68_state->extra_cycles;
m68_state->extra_cycles = 0;
check_irq_lines(m68_state);
if (m68_state->int_state & (M6809_CWAI | M6809_SYNC))
{
debugger_instruction_hook(device, PCD);
m68_state->icount = 0;
}
else
{
do
{
pPPC = pPC;
debugger_instruction_hook(device, PCD);
m68_state->ireg = ROP(PCD);
PC++;
(*m6809_main[m68_state->ireg])(m68_state);
m68_state->icount -= cycles1[m68_state->ireg];
} while( m68_state->icount > 0 );
m68_state->icount -= m68_state->extra_cycles;
m68_state->extra_cycles = 0;
}
}
void nec_common_device::execute_run()
{
int prev_ICount;
if (m_halted)
{
m_icount = 0;
debugger_instruction_hook(this, (Sreg(PS)<<4) + m_ip);
return;
}
while(m_icount>0) {
/* Dispatch IRQ */
if (m_pending_irq && m_no_interrupt==0)
{
if (m_pending_irq & NMI_IRQ)
external_int();
else if (m_IF)
external_int();
}
/* No interrupt allowed between last instruction and this one */
if (m_no_interrupt)
m_no_interrupt--;
debugger_instruction_hook(this, (Sreg(PS)<<4) + m_ip);
prev_ICount = m_icount;
(this->*s_nec_instruction[fetchop()])();
do_prefetch(prev_ICount);
}
}
static CPU_EXECUTE( necv )
{
nec_state_t *nec_state = get_safe_token(device);
int prev_ICount;
if (nec_state->halted)
{
nec_state->icount = 0;
debugger_instruction_hook(device, (Sreg(PS)<<4) + nec_state->ip);
return;
}
while(nec_state->icount>0) {
/* Dispatch IRQ */
if (nec_state->pending_irq && nec_state->no_interrupt==0)
{
if (nec_state->pending_irq & NMI_IRQ)
external_int(nec_state);
else if (nec_state->IF)
external_int(nec_state);
}
/* No interrupt allowed between last instruction and this one */
if (nec_state->no_interrupt)
nec_state->no_interrupt--;
debugger_instruction_hook(device, (Sreg(PS)<<4) + nec_state->ip);
prev_ICount = nec_state->icount;
nec_instruction[fetchop(nec_state)](nec_state);
do_prefetch(nec_state, prev_ICount);
}
}
static CPU_EXECUTE( sc61860 )
{
sc61860_state *cpustate = get_safe_token(device);
do
{
cpustate->oldpc = cpustate->pc;
debugger_instruction_hook(device, cpustate->pc);
sc61860_instruction(cpustate);
#if 0
/* Are we in HLT-mode? */
if (cpustate->c & 4)
{
if ((cpustate->config && cpustate->config->ina && (cpustate->config->ina(cpustate)!=0)) || cpustate->timer.t512ms)
{
cpustate->c&=0xfb;
if (cpustate->config->outc) cpustate->config->outc(cpustate->c);
}
cpustate->icount-=4;
}
else if(cpustate->c & 8) {}
else sc61860_instruction(cpustate);
#endif
} while (cpustate->icount > 0);
}
void minx_cpu_device::execute_run()
{
do
{
m_curpc = GET_MINX_PC;
debugger_instruction_hook(this, m_curpc);
if ( m_interrupt_pending )
{
m_halted = 0;
if ( ! ( m_F & 0xc0 ) && m_U == m_V )
{
//logerror("minx_execute(): taking IRQ\n");
PUSH8( m_V );
PUSH16( m_PC );
PUSH8( m_F );
/* Set Interrupt Branch flag */
m_F |= 0x80;
m_V = 0;
m_PC = rd16( standard_irq_callback( 0 ) << 1 );
m_icount -= 28; /* This cycle count is a guess */
}
}
if ( m_halted )
{
m_icount -= insnminx_cycles_CE[0xAE];
}
else
{
execute_one();
}
} while ( m_icount > 0 );
}
static CPU_EXECUTE( t11 )
{
t11_state *cpustate = get_safe_token(device);
t11_check_irqs(cpustate);
if (cpustate->wait_state)
{
cpustate->icount = 0;
goto getout;
}
do
{
UINT16 op;
cpustate->ppc = cpustate->reg[7]; /* copy PC to previous PC */
debugger_instruction_hook(device, cpustate->PCD);
op = ROPCODE(cpustate);
(*opcode_table[op >> 3])(cpustate, op);
} while (cpustate->icount > 0);
getout:
;
}
void lr35902_cpu_device::execute_run()
{
do
{
if ( m_execution_state ) {
UINT8 x;
/* Execute instruction */
switch( m_op ) {
#include "opc_main.inc"
default:
// actually this should lock up the cpu!
logerror("LR35902: Illegal opcode $%02X @ %04X\n", m_op, m_PC);
break;
}
} else {
/* Fetch and count cycles */
check_interrupts();
debugger_instruction_hook(this, m_PC);
if ( m_enable & HALTED ) {
cycles_passed( 4 );
m_execution_state = 1;
} else {
m_op = mem_read_byte( m_PC++ );
if ( m_handle_halt_bug ) {
m_PC--;
m_handle_halt_bug = false;
}
}
}
m_execution_state ^= 1;
} while (m_icount > 0);
}
/* execute instructions on this CPU until icount expires */
static CPU_EXECUTE( konami )
{
konami_state *cpustate = get_safe_token(device);
check_irq_lines(cpustate);
if( cpustate->int_state & (KONAMI_CWAI | KONAMI_SYNC) )
{
cpustate->icount = 0;
}
else
{
do
{
UINT8 ireg;
pPPC = pPC;
debugger_instruction_hook(device, PCD);
cpustate->ireg = ireg = ROP(cpustate, PCD);
PC++;
(*konami_main[ireg])(cpustate);
cpustate->icount -= cycles1[ireg];
} while( cpustate->icount > 0 );
}
}
inline void cosmac_device::debug()
{
if (device_t::machine().debug_flags & DEBUG_FLAG_ENABLED)
{
debugger_instruction_hook(this, R[P]);
}
}
void lr35902_cpu_device::execute_run()
{
do
{
if ( m_execution_state ) {
UINT8 x;
/* Execute instruction */
switch( m_op ) {
#include "opc_main.h"
}
} else {
/* Fetch and count cycles */
check_interrupts();
debugger_instruction_hook(this, m_PC);
if ( m_enable & HALTED ) {
cycles_passed( 4 );
m_execution_state = 1;
} else {
m_op = mem_read_byte( m_PC++ );
if ( m_doHALTbug ) {
m_PC--;
m_doHALTbug = 0;
}
}
}
m_execution_state ^= 1;
} while (m_icount > 0);
}
void dsp16_device::execute_run()
{
// HACK TO MAKE CPU DO NOTHING.
// REMOVE IF DEVELOPING CPU CORE.
m_icount = 0;
return;
do
{
// debugging
m_ppc = m_pc; // copy PC to previous PC
debugger_instruction_hook(this, m_pc);
// instruction fetch & execute
UINT8 cycles;
UINT8 pcAdvance;
const UINT16 op = opcode_read();
execute_one(op, cycles, pcAdvance);
// step
m_pc += pcAdvance;
m_icount -= cycles;
// The 16 bit PI "shadow" register gets set to PC on each instruction except
// when an interrupt service routine is active (TODO: Interrupt check) (page 2-4)
m_pi = m_pc;
} while (m_icount > 0);
}
void tms32082_mp_device::execute_run()
{
while (m_icount > 0)
{
m_pc = m_fetchpc;
check_interrupts();
debugger_instruction_hook(this, m_pc);
m_ir = fetch();
execute();
m_tcount--;
if (m_tcount < 0)
{
// TODO: timer interrupt
m_tcount = m_tscale;
}
m_icount--;
};
return;
}
void tms32082_mp_device::delay_slot()
{
debugger_instruction_hook(this, m_pc);
m_ir = fetch();
execute();
m_icount--;
}
void alpha_device::execute_run()
{
while (m_icount > 0)
{
debugger_instruction_hook(m_pc);
m_icount--;
}
}
void tms32082_pp_device::execute_run()
{
m_pc = m_fetchpc;
debugger_instruction_hook(this, m_pc);
m_icount = 0;
return;
}
void pdp8_device::execute_run()
{
while (m_icount > 0)
{
m_pc &= 07777;
debugger_instruction_hook(this, m_pc);
UINT16 op = m_program->read_word(m_pc);
--m_icount;
}
}
void lr35902_cpu_device::execute_run()
{
do
{
if (m_dma_cycles_to_burn > 0)
{
if (m_dma_cycles_to_burn < 4)
{
cycles_passed(m_dma_cycles_to_burn);
m_dma_cycles_to_burn = 0;
}
else
{
cycles_passed(4);
m_dma_cycles_to_burn -= 4;
}
}
else
{
if ( m_execution_state ) {
uint8_t x;
/* Execute instruction */
switch( m_op ) {
#include "opc_main.hxx"
default:
// actually this should lock up the cpu!
logerror("LR35902: Illegal opcode $%02X @ %04X\n", m_op, m_PC);
break;
}
} else {
/* Fetch and count cycles */
bool was_halted = (m_enable & HALTED);
check_interrupts();
debugger_instruction_hook(m_PC);
if ( m_enable & HALTED ) {
cycles_passed(m_has_halt_bug ? 2 : 4);
m_execution_state = 1;
m_entering_halt = false;
} else {
if (was_halted) {
m_PC++;
} else {
m_op = mem_read_byte( m_PC++ );
}
}
}
m_execution_state ^= 1;
}
} while (m_icount > 0);
}
static CPU_EXECUTE( m6502 )
{
m6502_Regs *cpustate = get_safe_token(device);
do
{
UINT8 op;
PPC = PCD;
debugger_instruction_hook(device, PCD);
/* if an irq is pending, take it now */
if( cpustate->pending_irq )
m6502_take_irq(cpustate);
op = RDOP();
(*cpustate->insn[op])(cpustate);
/* check if the I flag was just reset (interrupts enabled) */
if( cpustate->after_cli )
{
LOG(("M6502 '%s' after_cli was >0", cpustate->device->tag()));
cpustate->after_cli = 0;
if (cpustate->irq_state != CLEAR_LINE)
{
LOG((": irq line is asserted: set pending IRQ\n"));
cpustate->pending_irq = 1;
}
else
{
LOG((": irq line is clear\n"));
}
}
else {
if ( cpustate->pending_irq == 2 ) {
if ( cpustate->int_occured - cpustate->icount > 1 ) {
cpustate->pending_irq = 1;
}
}
if( cpustate->pending_irq == 1 )
m6502_take_irq(cpustate);
if ( cpustate->pending_irq == 2 ) {
cpustate->pending_irq = 1;
}
}
} while (cpustate->icount > 0);
}
static CPU_EXECUTE( h6280 )
{
int in;
h6280_Regs* cpustate = get_safe_token(device);
if ( cpustate->irq_pending == 2 ) {
cpustate->irq_pending--;
}
/* Execute instructions */
do
{
cpustate->ppc = cpustate->pc;
debugger_instruction_hook(device, PCW);
/* Execute 1 instruction */
in=RDOP();
PCW++;
insnh6280[in](cpustate);
if ( cpustate->irq_pending ) {
if ( cpustate->irq_pending == 1 ) {
if ( !(P & _fI) ) {
cpustate->irq_pending--;
CHECK_AND_TAKE_IRQ_LINES;
}
} else {
cpustate->irq_pending--;
}
}
/* Check internal timer */
if(cpustate->timer_status)
{
if(cpustate->timer_value<=0)
{
if ( ! cpustate->irq_pending )
cpustate->irq_pending = 1;
while( cpustate->timer_value <= 0 )
cpustate->timer_value += cpustate->timer_load;
set_irq_line(cpustate, 2,ASSERT_LINE);
}
}
} while (cpustate->ICount > 0);
}
static CPU_EXECUTE( lh5801 )
{
lh5801_state *cpustate = get_safe_token(device);
if (cpustate->idle) {
cpustate->icount=0;
} else {
do
{
cpustate->oldpc = P;
debugger_instruction_hook(device, P);
lh5801_instruction(cpustate);
} while (cpustate->icount > 0);
}
}
void dsp16_device::execute_run()
{
bool check_debugger = ((device_t::machine().debug_flags & DEBUG_FLAG_ENABLED) != 0);
do
{
// debugging
m_ppc = m_pc; // copy PC to previous PC
if (check_debugger)
debugger_instruction_hook(this, m_pc);
// instruction fetch
//UINT16 op = opcode_read();
m_icount--;
} while (m_icount > 0);
}
void arc_device::execute_run()
{
//UINT32 lres;
//lres = 0;
while (m_icount > 0)
{
debugger_instruction_hook(this, m_pc<<2);
//UINT32 op = READ32(m_pc);
m_pc++;
m_icount--;
}
}
void v60_device::execute_run()
{
if (m_irq_line != CLEAR_LINE)
v60_try_irq();
while (m_icount > 0)
{
UINT32 inc;
m_PPC = PC;
debugger_instruction_hook(this, PC);
m_icount -= 8; /* fix me -- this is just an average */
inc = (this->*s_OpCodeTable[OpRead8(PC)])();
PC += inc;
if (m_irq_line != CLEAR_LINE)
v60_try_irq();
}
}
void lh5801_cpu_device::execute_run()
{
do
{
check_irq();
if (m_idle)
m_icount = 0;
else
{
m_oldpc = P;
debugger_instruction_hook(this, P);
lh5801_instruction();
}
} while (m_icount > 0);
}
void tms32082_mp_device::execute_run()
{
while (m_icount > 0)
{
m_pc = m_fetchpc;
check_interrupts();
debugger_instruction_hook(this, m_pc);
m_ir = fetch();
execute();
m_icount--;
};
return;
}
void sm510_base_device::execute_run()
{
while (m_icount > 0)
{
// remember previous state
m_prev_op = m_op;
m_prev_pc = m_pc;
// fetch next opcode
debugger_instruction_hook(this, m_pc);
m_icount -= 2; // 61us typical
m_op = m_program->read_byte(m_pc);
increment_pc();
get_opcode_param();
// handle opcode
}
}
static CPU_EXECUTE( m4510 )
{
m4510_Regs *cpustate = get_safe_token(device);
cpustate->icount = cycles;
do
{
UINT8 op;
PPC = PCD;
debugger_instruction_hook(device, PCD);
/* if an irq is pending, take it now */
if( cpustate->pending_irq )
m4510_take_irq(cpustate);
op = RDOP();
(*insn4510[op])(cpustate);
/* check if the I flag was just reset (interrupts enabled) */
if( cpustate->after_cli )
{
LOG(("M4510 '%s' after_cli was >0", cpustate->device->tag));
cpustate->after_cli = 0;
if (cpustate->irq_state != CLEAR_LINE)
{
LOG((": irq line is asserted: set pending IRQ\n"));
cpustate->pending_irq = 1;
}
else
{
LOG((": irq line is clear\n"));
}
}
else
if( cpustate->pending_irq )
m4510_take_irq(cpustate);
} while (cpustate->icount > 0);
return cycles - cpustate->icount;
}
/* Execute cycles */
void cp1610_cpu_device::execute_run()
{
UINT16 opcode;
do
{
debugger_instruction_hook(this, m_pc);
opcode = xxx_readop(m_pc);
m_pc++;
switch( opcode )
{
default:
xxx_illegal();
break;
}
} while( m_icount > 0 );
}
/* Execute cycles */
void mb86235_cpu_device::execute_run()
{
UINT32 opcode;
do
{
debugger_instruction_hook(this, m_pc);
opcode = mb86235_readop(m_pc);
//m_pc++;
switch( opcode )
{
default:
mb86235_illegal();
break;
}
} while( m_icount > 0 );
}