aboutsummaryrefslogtreecommitdiff
path: root/sim/d30v/engine.c
blob: 2bbaad16a16cf82db5531612e5fa3f20d1ce04b7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
/*  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