/* This file is part of the program psim. Copyright (C) 1994-1997, Andrew Cagney Copyright (C) 1996, 1997, Free Software Foundation This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef ENGINE_C #define ENGINE_C #include "sim-main.h" #include #include #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_STRING_H #include #else #ifdef HAVE_STRINGS_H #include #endif #endif static void do_stack_swap (SIM_DESC sd) { sim_cpu *cpu = STATE_CPU (sd, 0); unsigned new_sp = (PSW_VAL(PSW_SM) != 0); if (cpu->regs.current_sp != new_sp) { cpu->regs.sp[cpu->regs.current_sp] = SP; cpu->regs.current_sp = new_sp; SP = cpu->regs.sp[cpu->regs.current_sp]; } } #if WITH_TRACE /* Implement ALU tracing of 32-bit registers. */ static void trace_alu32 (SIM_DESC sd, sim_cpu *cpu, address_word cia, unsigned32 *ptr) { unsigned32 value = *ptr; if (ptr >= &GPR[0] && ptr <= &GPR[NR_GENERAL_PURPOSE_REGISTERS]) trace_one_insn (sd, cpu, cia, 1, "engine.c", __LINE__, "alu", "Set register r%-2d = 0x%.8lx (%ld)", ptr - &GPR[0], (long)value, (long)value); else if (ptr == &PSW || ptr == &bPSW || ptr == &DPSW) trace_one_insn (sd, cpu, cia, 1, "engine.c", __LINE__, "alu", "Set register %s = 0x%.8lx%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", (ptr == &PSW) ? "psw" : ((ptr == &bPSW) ? "bpsw" : "dpsw"), (long)value, (value & (0x80000000 >> PSW_SM)) ? ", sm" : "", (value & (0x80000000 >> PSW_EA)) ? ", ea" : "", (value & (0x80000000 >> PSW_DB)) ? ", db" : "", (value & (0x80000000 >> PSW_DS)) ? ", ds" : "", (value & (0x80000000 >> PSW_IE)) ? ", ie" : "", (value & (0x80000000 >> PSW_RP)) ? ", rp" : "", (value & (0x80000000 >> PSW_MD)) ? ", md" : "", (value & (0x80000000 >> PSW_F0)) ? ", f0" : "", (value & (0x80000000 >> PSW_F1)) ? ", f1" : "", (value & (0x80000000 >> PSW_F2)) ? ", f2" : "", (value & (0x80000000 >> PSW_F3)) ? ", f3" : "", (value & (0x80000000 >> PSW_S)) ? ", s" : "", (value & (0x80000000 >> PSW_V)) ? ", v" : "", (value & (0x80000000 >> PSW_VA)) ? ", va" : "", (value & (0x80000000 >> PSW_C)) ? ", c" : ""); else if (ptr >= &CREG[0] && ptr <= &CREG[NR_CONTROL_REGISTERS]) trace_one_insn (sd, cpu, cia, 1, "engine.c", __LINE__, "alu", "Set register cr%d = 0x%.8lx (%ld)", ptr - &CREG[0], (long)value, (long)value); } /* Implement ALU tracing of 32-bit registers. */ static void trace_alu64 (SIM_DESC sd, sim_cpu *cpu, address_word cia, unsigned64 *ptr) { unsigned64 value = *ptr; if (ptr >= &ACC[0] && ptr <= &ACC[NR_ACCUMULATORS]) trace_one_insn (sd, cpu, cia, 1, "engine.c", __LINE__, "alu", "Set register a%-2d = 0x%.8lx 0x%.8lx", ptr - &ACC[0], (unsigned long)(unsigned32)(value >> 32), (unsigned long)(unsigned32)value); } #endif /* Process all of the queued up writes in order now */ void unqueue_writes (SIM_DESC sd, sim_cpu *cpu, address_word cia) { int i, num; int did_psw = 0; unsigned32 *psw_addr = &PSW; num = WRITE32_NUM; for (i = 0; i < num; i++) { unsigned32 mask = WRITE32_MASK (i); unsigned32 *ptr = WRITE32_PTR (i); unsigned32 value = (*ptr & ~mask) | (WRITE32_VALUE (i) & mask); int j; if (ptr == psw_addr) { /* If MU instruction was not a MVTSYS, resolve PSW contention in favour of IU. */ if(! STATE_CPU (sd, 0)->mvtsys_left_p) { /* Detect contention in parallel writes to the same PSW flags. The hardware allows the updates from IU to prevail over those from MU. */ unsigned32 flag_bits = BIT32 (PSW_F0) | BIT32 (PSW_F1) | BIT32 (PSW_F2) | BIT32 (PSW_F3) | BIT32 (PSW_S) | BIT32 (PSW_V) | BIT32 (PSW_VA) | BIT32 (PSW_C); unsigned32 my_flag_bits = mask & flag_bits; for (j = i + 1; j < num; j++) if (WRITE32_PTR (j) == psw_addr && /* write to PSW */ WRITE32_MASK (j) & my_flag_bits) /* some of the same flags */ { /* Recompute local mask & value, to suppress this earlier write to the same flag bits. */ unsigned32 new_mask = mask & ~(WRITE32_MASK (j) & my_flag_bits); /* There is a special case for the VA (accumulated overflow) flag, in that it is only included in the second instruction's mask if the overflow occurred. Yet the hardware still suppresses the first instruction's update to VA. So we kludge this by inferring PSW_V -> PSW_VA for the second instruction. */ if (WRITE32_MASK (j) & BIT32 (PSW_V)) { new_mask &= ~BIT32 (PSW_VA); } value = (*ptr & ~new_mask) | (WRITE32_VALUE (i) & new_mask); } } did_psw = 1; } *ptr = value; #if WITH_TRACE if (TRACE_ALU_P (cpu)) trace_alu32 (sd, cpu, cia, ptr); #endif } num = WRITE64_NUM; for (i = 0; i < num; i++) { unsigned64 *ptr = WRITE64_PTR (i); *ptr = WRITE64_VALUE (i); #if WITH_TRACE if (TRACE_ALU_P (cpu)) trace_alu64 (sd, cpu, cia, ptr); #endif } WRITE32_NUM = 0; WRITE64_NUM = 0; if (DID_TRAP == 1) /* ordinary trap */ { bPSW = PSW; PSW &= (BIT32 (PSW_DB) | BIT32 (PSW_SM)); did_psw = 1; } else if (DID_TRAP == 2) /* debug trap */ { DPSW = PSW; PSW &= BIT32 (PSW_DS); PSW |= BIT32 (PSW_DS); did_psw = 1; } DID_TRAP = 0; if (did_psw) do_stack_swap (sd); } /* SIMULATE INSTRUCTIONS, various different ways of achieving the same thing */ static address_word do_long (SIM_DESC sd, l_instruction_word instruction, address_word cia) { address_word nia = l_idecode_issue(sd, instruction, cia); unqueue_writes (sd, STATE_CPU (sd, 0), cia); return nia; } static address_word do_2_short (SIM_DESC sd, s_instruction_word insn1, s_instruction_word insn2, cpu_units unit, address_word cia) { address_word nia; /* run the first instruction */ STATE_CPU (sd, 0)->unit = unit; STATE_CPU (sd, 0)->left_kills_right_p = 0; STATE_CPU (sd, 0)->mvtsys_left_p = 0; nia = s_idecode_issue(sd, insn1, cia); unqueue_writes (sd, STATE_CPU (sd, 0), cia); /* Only do the second instruction if the PC has not changed */ if ((nia == INVALID_INSTRUCTION_ADDRESS) && (! STATE_CPU (sd, 0)->left_kills_right_p)) { STATE_CPU (sd, 0)->unit = any_unit; nia = s_idecode_issue (sd, insn2, cia); unqueue_writes (sd, STATE_CPU (sd, 0), cia); } STATE_CPU (sd, 0)->left_kills_right_p = 0; STATE_CPU (sd, 0)->mvtsys_left_p = 0; return nia; } static address_word do_parallel (SIM_DESC sd, s_instruction_word left_insn, s_instruction_word right_insn, address_word cia) { address_word nia_left; address_word nia_right; address_word nia; /* run the first instruction */ STATE_CPU (sd, 0)->unit = memory_unit; STATE_CPU (sd, 0)->left_kills_right_p = 0; STATE_CPU (sd, 0)->mvtsys_left_p = 0; nia_left = s_idecode_issue(sd, left_insn, cia); /* run the second instruction */ STATE_CPU (sd, 0)->unit = integer_unit; nia_right = s_idecode_issue(sd, right_insn, cia); /* merge the PC's */ if (nia_left == INVALID_INSTRUCTION_ADDRESS) { if (nia_right == INVALID_INSTRUCTION_ADDRESS) nia = INVALID_INSTRUCTION_ADDRESS; else nia = nia_right; } else { if (nia_right == INVALID_INSTRUCTION_ADDRESS) nia = nia_left; else { sim_engine_abort (sd, STATE_CPU (sd, 0), cia, "parallel jumps"); nia = INVALID_INSTRUCTION_ADDRESS; } } unqueue_writes (sd, STATE_CPU (sd, 0), cia); return nia; } typedef enum { p_insn = 0, long_insn = 3, l_r_insn = 1, r_l_insn = 2, } instruction_types; STATIC_INLINE instruction_types instruction_type(l_instruction_word insn) { int fm0 = MASKED64(insn, 0, 0) != 0; int fm1 = MASKED64(insn, 32, 32) != 0; return ((fm0 << 1) | fm1); } void sim_engine_run (SIM_DESC sd, int last_cpu_nr, int nr_cpus, int siggnal) { while (1) { address_word cia = PC; address_word nia; l_instruction_word insn = IMEM(cia); int rp_was_set; int rpt_c_was_nonzero; /* Before executing the instruction, we need to test whether or not RPT_C is greater than zero, and save that state for use after executing the instruction. In particular, we need to not care whether the instruction changes RPT_C itself. */ rpt_c_was_nonzero = (RPT_C > 0); /* Before executing the instruction, we need to check to see if we have to decrement RPT_C, the repeat count register. Do this if PC == RPT_E, but only if we are in an active repeat block. */ if (PC == RPT_E && (RPT_C > 0 || PSW_VAL (PSW_RP) != 0)) { RPT_C --; } /* Now execute the instruction at PC */ switch (instruction_type (insn)) { case long_insn: nia = do_long (sd, insn, cia); break; case r_l_insn: /* L <- R */ nia = do_2_short (sd, insn, insn >> 32, integer_unit, cia); break; case l_r_insn: /* L -> R */ nia = do_2_short (sd, insn >> 32, insn, memory_unit, cia); break; case p_insn: nia = do_parallel (sd, insn >> 32, insn, cia); break; default: sim_engine_abort (sd, STATE_CPU (sd, 0), cia, "internal error - engine_run_until_stop - bad switch"); nia = -1; } if (TRACE_ACTION) { if (TRACE_ACTION & TRACE_ACTION_CALL) call_occurred (sd, STATE_CPU (sd, 0), cia, nia); if (TRACE_ACTION & TRACE_ACTION_RETURN) return_occurred (sd, STATE_CPU (sd, 0), cia, nia); TRACE_ACTION = 0; } /* Check now to see if we need to reset the RP bit in the PSW. There are three conditions for this, the RP bit is already set (just a speed optimization), the instruction we just executed is the last instruction in the loop, and the repeat count is currently zero. */ rp_was_set = PSW_VAL (PSW_RP); if (rp_was_set && (PC == RPT_E) && RPT_C == 0) { PSW_SET (PSW_RP, 0); } /* Now update the PC. If we just executed a jump instruction, that takes precedence over everything else. Next comes branching back to RPT_S as a result of a loop. Finally, the default is to simply advance to the next inline instruction. */ if (nia != INVALID_INSTRUCTION_ADDRESS) { PC = nia; } else if (rp_was_set && rpt_c_was_nonzero && (PC == RPT_E)) { PC = RPT_S; } else { PC = cia + 8; } /* Check for DDBT (debugger debug trap) condition. Do this after the repeat block checks so the excursion to the trap handler does not alter looping state. */ if (cia == IBA && PSW_VAL (PSW_DB)) { DPC = PC; PSW_SET (PSW_EA, 1); DPSW = PSW; /* clear all bits in PSW except SM */ PSW &= BIT32 (PSW_SM); /* add DS bit */ PSW |= BIT32 (PSW_DS); /* dispatch to DDBT handler */ PC = 0xfffff128; /* debugger_debug_trap_address */ } /* process any events */ /* FIXME - should L->R or L<-R insns count as two cycles? */ if (sim_events_tick (sd)) { sim_events_process (sd); } } } /* d30v external interrupt handler. Note: This should be replaced by a proper interrupt delivery mechanism. This interrupt mechanism discards later interrupts if an earlier interrupt hasn't been delivered. Note: This interrupt mechanism does not reset its self when the simulator is re-opened. */ void d30v_interrupt_event (SIM_DESC sd, void *data) { if (PSW_VAL (PSW_IE)) /* interrupts not masked */ { /* scrub any pending interrupt */ if (sd->pending_interrupt != NULL) sim_events_deschedule (sd, sd->pending_interrupt); /* deliver */ bPSW = PSW; bPC = PC; PSW = 0; PC = 0xfffff138; /* external interrupt */ do_stack_swap (sd); } else if (sd->pending_interrupt == NULL) /* interrupts masked and no interrupt pending */ { sd->pending_interrupt = sim_events_schedule (sd, 1, d30v_interrupt_event, data); } } #endif