sim/d30v/engine.c

/*  This file is part of the program psim.

    Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
    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 <stdio.h>
#include <ctype.h>

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#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